| blob | 7dd23a8ae6320c84c213a943551d9876027a57aa |
1 /*-------------------------------------------------------------------------
2 *
3 * rewriteHandler.c
4 * Primary module of query rewriter.
5 *
6 * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 * IDENTIFICATION
10 * $PostgreSQL$
11 *
12 *-------------------------------------------------------------------------
13 */
31 /* We use a list of these to detect recursion in RewriteQuery */
33 {
43 CmdType event,
61 /*
62 * AcquireRewriteLocks -
63 * Acquire suitable locks on all the relations mentioned in the Query.
64 * These locks will ensure that the relation schemas don't change under us
65 * while we are rewriting and planning the query.
66 *
67 * A secondary purpose of this routine is to fix up JOIN RTE references to
68 * dropped columns (see details below). Because the RTEs are modified in
69 * place, it is generally appropriate for the caller of this routine to have
70 * first done a copyObject() to make a writable copy of the querytree in the
71 * current memory context.
72 *
73 * This processing can, and for efficiency's sake should, be skipped when the
74 * querytree has just been built by the parser: parse analysis already got
75 * all the same locks we'd get here, and the parser will have omitted dropped
76 * columns from JOINs to begin with. But we must do this whenever we are
77 * dealing with a querytree produced earlier than the current command.
78 *
79 * About JOINs and dropped columns: although the parser never includes an
80 * already-dropped column in a JOIN RTE's alias var list, it is possible for
81 * such a list in a stored rule to include references to dropped columns.
82 * (If the column is not explicitly referenced anywhere else in the query,
83 * the dependency mechanism won't consider it used by the rule and so won't
84 * prevent the column drop.) To support get_rte_attribute_is_dropped(),
85 * we replace join alias vars that reference dropped columns with NULL Const
86 * nodes.
87 *
88 * (In PostgreSQL 8.0, we did not do this processing but instead had
89 * get_rte_attribute_is_dropped() recurse to detect dropped columns in joins.
90 * That approach had horrible performance unfortunately; in particular
91 * construction of a nested join was O(N^2) in the nesting depth.)
92 */
93 void
95 {
99 /*
100 * First, process RTEs of the current query level.
101 */
104 {
106 Relation rel;
107 LOCKMODE lockmode;
109 Index curinputvarno;
115 {
118 /*
119 * Grab the appropriate lock type for the relation, and do not
120 * release it until end of transaction. This protects the
121 * rewriter and planner against schema changes mid-query.
122 *
123 * If the relation is the query's result relation, then we
124 * need RowExclusiveLock. Otherwise, check to see if the
125 * relation is accessed FOR UPDATE/SHARE or not. We can't
126 * just grab AccessShareLock because then the executor would
127 * be trying to upgrade the lock, leading to possible
128 * deadlocks.
129 */
134 else
143 /*
144 * Scan the join's alias var list to see if any columns have
145 * been dropped, and if so replace those Vars with NULL
146 * Consts.
147 *
148 * Since a join has only two inputs, we can expect to see
149 * multiple references to the same input RTE; optimize away
150 * multiple fetches.
151 */
156 {
159 /*
160 * If the list item isn't a simple Var, then it must
161 * represent a merged column, ie a USING column, and so it
162 * couldn't possibly be dropped, since it's referenced in
163 * the join clause. (Conceivably it could also be a NULL
164 * constant already? But that's OK too.)
165 */
167 {
168 /*
169 * The elements of an alias list have to refer to
170 * earlier RTEs of the same rtable, because that's the
171 * order the planner builds things in. So we already
172 * processed the referenced RTE, and so it's safe to
173 * use get_rte_attribute_is_dropped on it. (This might
174 * not hold after rewriting or planning, but it's OK
175 * to assume here.)
176 */
179 {
186 }
189 {
190 /*
191 * can't use vartype here, since that might be a
192 * now-dropped type OID, but it doesn't really
193 * matter what type the Const claims to be.
194 */
196 }
197 }
199 }
205 /*
206 * The subquery RTE itself is all right, but we have to
207 * recurse to process the represented subquery.
208 */
213 /* ignore other types of RTEs */
215 }
216 }
218 /* Recurse into subqueries in WITH */
220 {
224 }
226 /*
227 * Recurse into sublink subqueries, too. But we already did the ones in
228 * the rtable and cteList.
229 */
232 QTW_IGNORE_RC_SUBQUERIES);
233 }
235 /*
236 * Walker to find sublink subqueries for AcquireRewriteLocks
237 */
238 static bool
240 {
244 {
247 /* Do what we came for */
249 /* Fall through to process lefthand args of SubLink */
250 }
252 /*
253 * Do NOT recurse into Query nodes, because AcquireRewriteLocks already
254 * processed subselects of subselects for us.
255 */
257 }
260 /*
261 * rewriteRuleAction -
262 * Rewrite the rule action with appropriate qualifiers (taken from
263 * the triggering query).
264 *
265 * Input arguments:
266 * parsetree - original query
267 * rule_action - one action (query) of a rule
268 * rule_qual - WHERE condition of rule, or NULL if unconditional
269 * rt_index - RT index of result relation in original query
270 * event - type of rule event
271 * Output arguments:
272 * *returning_flag - set TRUE if we rewrite RETURNING clause in rule_action
273 * (must be initialized to FALSE)
274 * Return value:
275 * rewritten form of rule_action
276 */
282 CmdType event,
284 {
286 new_varno;
291 /*
292 * Make modifiable copies of rule action and qual (what we're passed are
293 * the stored versions in the relcache; don't touch 'em!).
294 */
298 /*
299 * Acquire necessary locks and fix any deleted JOIN RTE entries.
300 */
308 /*
309 * Adjust rule action and qual to offset its varnos, so that we can merge
310 * its rtable with the main parsetree's rtable.
311 *
312 * If the rule action is an INSERT...SELECT, the OLD/NEW rtable entries
313 * will be in the SELECT part, and we have to modify that rather than the
314 * top-level INSERT (kluge!).
315 */
320 /* but references to *OLD* should point at original rt_index */
326 /*
327 * Generate expanded rtable consisting of main parsetree's rtable plus
328 * rule action's rtable; this becomes the complete rtable for the rule
329 * action. Some of the entries may be unused after we finish rewriting,
330 * but we leave them all in place for two reasons:
331 *
332 * We'd have a much harder job to adjust the query's varnos if we
333 * selectively removed RT entries.
334 *
335 * If the rule is INSTEAD, then the original query won't be executed at
336 * all, and so its rtable must be preserved so that the executor will do
337 * the correct permissions checks on it.
338 *
339 * RT entries that are not referenced in the completed jointree will be
340 * ignored by the planner, so they do not affect query semantics. But any
341 * permissions checks specified in them will be applied during executor
342 * startup (see ExecCheckRTEPerms()). This allows us to check that the
343 * caller has, say, insert-permission on a view, when the view is not
344 * semantically referenced at all in the resulting query.
345 *
346 * When a rule is not INSTEAD, the permissions checks done on its copied
347 * RT entries will be redundant with those done during execution of the
348 * original query, but we don't bother to treat that case differently.
349 *
350 * NOTE: because planner will destructively alter rtable, we must ensure
351 * that rule action's rtable is separate and shares no substructure with
352 * the main rtable. Hence do a deep copy here.
353 */
357 /*
358 * There could have been some SubLinks in parsetree's rtable, in which
359 * case we'd better mark the sub_action correctly.
360 */
362 {
366 {
370 {
380 /* other RTE types don't contain bare expressions */
382 }
385 }
386 }
388 /*
389 * Each rule action's jointree should be the main parsetree's jointree
390 * plus that rule's jointree, but usually *without* the original rtindex
391 * that we're replacing (if present, which it won't be for INSERT). Note
392 * that if the rule action refers to OLD, its jointree will add a
393 * reference to rt_index. If the rule action doesn't refer to OLD, but
394 * either the rule_qual or the user query quals do, then we need to keep
395 * the original rtindex in the jointree to provide data for the quals. We
396 * don't want the original rtindex to be joined twice, however, so avoid
397 * keeping it if the rule action mentions it.
398 *
399 * As above, the action's jointree must not share substructure with the
400 * main parsetree's.
401 */
403 {
414 {
415 /*
416 * If sub_action is a setop, manipulating its jointree will do no
417 * good at all, because the jointree is dummy. (Perhaps someday
418 * we could push the joining and quals down to the member
419 * statements of the setop?)
420 */
429 /*
430 * There could have been some SubLinks in newjointree, in which
431 * case we'd better mark the sub_action correctly.
432 */
436 }
437 }
439 /*
440 * Event Qualification forces copying of parsetree and splitting into two
441 * queries one w/rule_qual, one w/NOT rule_qual. Also add user query qual
442 * onto rule action
443 */
448 /*
449 * Rewrite new.attribute w/ right hand side of target-list entry for
450 * appropriate field name in insert/update.
451 *
452 * KLUGE ALERT: since ResolveNew returns a mutated copy, we can't just
453 * apply it to sub_action; we have to remember to update the sublink
454 * inside rule_action, too.
455 */
458 {
460 new_varno,
465 event,
466 current_varno);
469 else
471 }
473 /*
474 * If rule_action has a RETURNING clause, then either throw it away if the
475 * triggering query has no RETURNING clause, or rewrite it to emit what
476 * the triggering query's RETURNING clause asks for. Throw an error if
477 * more than one rule has a RETURNING clause.
478 */
482 {
495 CMD_SELECT,
498 /*
499 * There could have been some SubLinks in parsetree's returningList,
500 * in which case we'd better mark the rule_action correctly.
501 */
505 }
508 }
510 /*
511 * Copy the query's jointree list, and optionally attempt to remove any
512 * occurrence of the given rt_index as a top-level join item (we do not look
513 * for it within join items; this is OK because we are only expecting to find
514 * it as an UPDATE or DELETE target relation, which will be at the top level
515 * of the join). Returns modified jointree list --- this is a separate copy
516 * sharing no nodes with the original.
517 */
520 {
525 {
527 {
532 {
535 /*
536 * foreach is safe because we exit loop after list_delete...
537 */
539 }
540 }
541 }
543 }
546 /*
547 * rewriteTargetList - rewrite INSERT/UPDATE targetlist into standard form
548 *
549 * This has the following responsibilities:
550 *
551 * 1. For an INSERT, add tlist entries to compute default values for any
552 * attributes that have defaults and are not assigned to in the given tlist.
553 * (We do not insert anything for default-less attributes, however. The
554 * planner will later insert NULLs for them, but there's no reason to slow
555 * down rewriter processing with extra tlist nodes.) Also, for both INSERT
556 * and UPDATE, replace explicit DEFAULT specifications with column default
557 * expressions.
558 *
559 * 2. Merge multiple entries for the same target attribute, or declare error
560 * if we can't. Multiple entries are only allowed for INSERT/UPDATE of
561 * portions of an array or record field, for example
562 * UPDATE table SET foo[2] = 42, foo[4] = 43;
563 * We can merge such operations into a single assignment op. Essentially,
564 * the expression we want to produce in this case is like
565 * foo = array_set(array_set(foo, 2, 42), 4, 43)
566 *
567 * 3. Sort the tlist into standard order: non-junk fields in order by resno,
568 * then junk fields (these in no particular order).
569 *
570 * We must do items 1 and 2 before firing rewrite rules, else rewritten
571 * references to NEW.foo will produce wrong or incomplete results. Item 3
572 * is not needed for rewriting, but will be needed by the planner, and we
573 * can do it essentially for free while handling items 1 and 2.
574 *
575 * If attrno_list isn't NULL, we return an additional output besides the
576 * rewritten targetlist: an integer list of the assigned-to attnums, in
577 * order of the original tlist's non-junk entries. This is needed for
578 * processing VALUES RTEs.
579 */
580 static void
583 {
588 Form_pg_attribute att_tup;
590 next_junk_attrno,
591 numattrs;
597 /*
598 * We process the normal (non-junk) attributes by scanning the input tlist
599 * once and transferring TLEs into an array, then scanning the array to
600 * build an output tlist. This avoids O(N^2) behavior for large numbers
601 * of attributes.
602 *
603 * Junk attributes are tossed into a separate list during the same tlist
604 * scan, then appended to the reconstructed tlist.
605 */
611 {
615 {
616 /* Normal attr: stash it into new_tles[] */
622 /* put attrno into attrno_list even if it's dropped */
626 /* We can (and must) ignore deleted attributes */
630 /* Merge with any prior assignment to same attribute */
635 }
636 else
637 {
638 /*
639 * Copy all resjunk tlist entries to junk_tlist, and assign them
640 * resnos above the last real resno.
641 *
642 * Typical junk entries include ORDER BY or GROUP BY expressions
643 * (are these actually possible in an INSERT or UPDATE?), system
644 * attribute references, etc.
645 */
647 /* Get the resno right, but don't copy unnecessarily */
649 {
652 }
654 next_junk_attrno++;
655 }
656 }
659 {
664 /* We can (and must) ignore deleted attributes */
668 /*
669 * Handle the two cases where we need to insert a default expression:
670 * it's an INSERT and there's no tlist entry for the column, or the
671 * tlist entry is a DEFAULT placeholder node.
672 */
675 {
680 /*
681 * If there is no default (ie, default is effectively NULL), we
682 * can omit the tlist entry in the INSERT case, since the planner
683 * can insert a NULL for itself, and there's no point in spending
684 * any more rewriter cycles on the entry. But in the UPDATE case
685 * we've got to explicitly set the column to NULL.
686 */
688 {
691 else
692 {
699 /* this is to catch a NOT NULL domain constraint */
703 COERCE_IMPLICIT_CAST,
707 }
708 }
712 attrno,
715 }
719 }
724 }
727 /*
728 * Convert a matched TLE from the original tlist into a correct new TLE.
729 *
730 * This routine detects and handles multiple assignments to the same target
731 * attribute. (The attribute name is needed only for error messages.)
732 */
737 {
747 {
748 /*
749 * Normal case where this is the first assignment to the attribute.
750 */
752 }
754 /*----------
755 * Multiple assignments to same attribute. Allow only if all are
756 * FieldStore or ArrayRef assignment operations. This is a bit
757 * tricky because what we may actually be looking at is a nest of
758 * such nodes; consider
759 * UPDATE tab SET col.fld1.subfld1 = x, col.fld2.subfld2 = y
760 * The two expressions produced by the parser will look like
761 * FieldStore(col, fld1, FieldStore(placeholder, subfld1, x))
762 * FieldStore(col, fld2, FieldStore(placeholder, subfld2, x))
763 * However, we can ignore the substructure and just consider the top
764 * FieldStore or ArrayRef from each assignment, because it works to
765 * combine these as
766 * FieldStore(FieldStore(col, fld1,
767 * FieldStore(placeholder, subfld1, x)),
768 * fld2, FieldStore(placeholder, subfld2, x))
769 * Note the leftmost expression goes on the inside so that the
770 * assignments appear to occur left-to-right.
771 *
772 * For FieldStore, instead of nesting we can generate a single
773 * FieldStore with multiple target fields. We must nest when
774 * ArrayRefs are involved though.
775 *----------
776 */
787 attrName)));
789 /*
790 * Prior TLE could be a nest of assignments if we do this more than once.
791 */
794 {
800 }
805 attrName)));
807 /*
808 * Looks OK to nest 'em.
809 */
811 {
815 {
816 /* combine the two */
824 }
825 else
826 {
827 /* general case, just nest 'em */
830 }
832 }
834 {
840 }
841 else
842 {
845 }
850 }
852 /*
853 * If node is an assignment node, return its input; else return NULL
854 */
857 {
861 {
865 }
867 {
873 }
875 }
877 /*
878 * Make an expression tree for the default value for a column.
879 *
880 * If there is no default, return a NULL instead.
881 */
882 Node *
884 {
890 Oid exprtype;
892 /*
893 * Scan to see if relation has a default for this column.
894 */
896 {
901 {
903 {
904 /*
905 * Found it, convert string representation to node tree.
906 */
909 }
910 }
911 }
914 {
915 /*
916 * No per-column default, so look for a default for the type itself.
917 */
919 }
924 /*
925 * Make sure the value is coerced to the target column type; this will
926 * generally be true already, but there seem to be some corner cases
927 * involving domain defaults where it might not be true. This should match
928 * the parser's processing of non-defaulted expressions --- see
929 * transformAssignedExpr().
930 */
936 COERCION_ASSIGNMENT,
937 COERCE_IMPLICIT_CAST,
950 }
953 /* Does VALUES RTE contain any SetToDefault items? */
954 static bool
956 {
960 {
965 {
970 }
971 }
973 }
975 /*
976 * When processing INSERT ... VALUES with a VALUES RTE (ie, multiple VALUES
977 * lists), we have to replace any DEFAULT items in the VALUES lists with
978 * the appropriate default expressions. The other aspects of rewriteTargetList
979 * need be applied only to the query's targetlist proper.
980 *
981 * Note that we currently can't support subscripted or field assignment
982 * in the multi-VALUES case. The targetlist will contain simple Vars
983 * referencing the VALUES RTE, and therefore process_matched_tle() will
984 * reject any such attempt with "multiple assignments to same column".
985 */
986 static void
988 {
992 /*
993 * Rebuilding all the lists is a pretty expensive proposition in a big
994 * VALUES list, and it's a waste of time if there aren't any DEFAULT
995 * placeholders. So first scan to see if there are any.
996 */
1000 /* Check list lengths (we can assume all the VALUES sublists are alike) */
1005 {
1012 {
1017 {
1018 Form_pg_attribute att_tup;
1025 else
1028 /*
1029 * If there is no default (ie, default is effectively NULL),
1030 * we've got to explicitly set the column to NULL.
1031 */
1033 {
1040 /* this is to catch a NOT NULL domain constraint */
1044 COERCE_IMPLICIT_CAST,
1048 }
1050 }
1051 else
1053 }
1055 }
1057 }
1060 /*
1061 * matchLocks -
1062 * match the list of locks and returns the matching rules
1063 */
1069 {
1078 {
1081 }
1086 {
1089 /*
1090 * Suppress ON INSERT/UPDATE/DELETE rules that are disabled or
1091 * configured to not fire during the current sessions replication
1092 * role. ON SELECT rules will always be applied in order to keep views
1093 * working even in LOCAL or REPLICA role.
1094 */
1096 {
1098 {
1102 }
1104 {
1108 }
1109 }
1112 {
1119 }
1120 }
1123 }
1126 /*
1127 * ApplyRetrieveRule - expand an ON SELECT rule
1128 */
1134 Relation relation,
1136 {
1149 /*
1150 * Make a modifiable copy of the view query, and acquire needed locks on
1151 * the relations it mentions.
1152 */
1157 /*
1158 * Recursively expand any view references inside the view.
1159 */
1162 /*
1163 * VIEWs are really easy --- just plug the view query in as a subselect,
1164 * replacing the relation's original RTE.
1165 */
1173 /*
1174 * We move the view's permission check data down to its rangetable. The
1175 * checks will actually be done against the *OLD* entry therein.
1176 */
1185 /*
1186 * FOR UPDATE/SHARE of view?
1187 */
1189 {
1190 /*
1191 * Remove the view from the list of rels that will actually be marked
1192 * FOR UPDATE/SHARE by the executor. It will still be access-checked
1193 * for write access, though.
1194 */
1197 /*
1198 * Set up the view's referenced tables as if FOR UPDATE/SHARE.
1199 */
1202 }
1205 }
1207 /*
1208 * Recursively mark all relations used by a view as FOR UPDATE/SHARE.
1209 *
1210 * This may generate an invalid query, eg if some sub-query uses an
1211 * aggregate. We leave it to the planner to detect that.
1212 *
1213 * NB: this must agree with the parser's transformLockingClause() routine.
1214 * However, unlike the parser we have to be careful not to mark a view's
1215 * OLD and NEW rels for updating. The best way to handle that seems to be
1216 * to scan the jointree to determine which rels are used.
1217 */
1218 static void
1220 {
1224 {
1229 {
1232 }
1234 {
1235 /* FOR UPDATE/SHARE of subquery is propagated to subquery's rels */
1238 }
1240 {
1241 /*
1242 * We allow FOR UPDATE/SHARE of a WITH query to be propagated into
1243 * the WITH, but it doesn't seem very sane to allow this for a
1244 * reference to an outer-level WITH (compare
1245 * transformLockingClause). Which simplifies life here.
1246 */
1255 {
1259 }
1262 /* should be analyzed by now */
1267 }
1268 }
1270 {
1276 }
1278 {
1283 }
1284 else
1287 }
1290 /*
1291 * fireRIRonSubLink -
1292 * Apply fireRIRrules() to each SubLink (subselect in expression) found
1293 * in the given tree.
1294 *
1295 * NOTE: although this has the form of a walker, we cheat and modify the
1296 * SubLink nodes in-place. It is caller's responsibility to ensure that
1297 * no unwanted side-effects occur!
1298 *
1299 * This is unlike most of the other routines that recurse into subselects,
1300 * because we must take control at the SubLink node in order to replace
1301 * the SubLink's subselect link with the possibly-rewritten subquery.
1302 */
1303 static bool
1305 {
1309 {
1312 /* Do what we came for */
1314 activeRIRs);
1315 /* Fall through to process lefthand args of SubLink */
1316 }
1318 /*
1319 * Do NOT recurse into Query nodes, because fireRIRrules already processed
1320 * subselects of subselects for us.
1321 */
1324 }
1327 /*
1328 * fireRIRrules -
1329 * Apply all RIR rules on each rangetable entry in a query
1330 */
1333 {
1337 /*
1338 * don't try to convert this into a foreach loop, because rtable list can
1339 * get changed each time through...
1340 */
1343 {
1345 Relation rel;
1355 /*
1356 * A subquery RTE can't have associated rules, so there's nothing to
1357 * do to this level of the query, but we must recurse into the
1358 * subquery to expand any rule references in it.
1359 */
1361 {
1364 }
1366 /*
1367 * Joins and other non-relation RTEs can be ignored completely.
1368 */
1372 /*
1373 * If the table is not referenced in the query, then we ignore it.
1374 * This prevents infinite expansion loop due to new rtable entries
1375 * inserted by expansion of a rule. A table is referenced if it is
1376 * part of the join set (a source table), or is referenced by any Var
1377 * nodes, or is the result table.
1378 */
1383 /*
1384 * We can use NoLock here since either the parser or
1385 * AcquireRewriteLocks should have locked the rel already.
1386 */
1389 /*
1390 * Collect the RIR rules that we must apply
1391 */
1394 {
1397 }
1400 {
1406 {
1407 /* per-attr rule; do we need it? */
1411 }
1414 }
1416 /*
1417 * If we found any, apply them --- but first check for recursion!
1418 */
1420 {
1431 {
1435 rule,
1436 rt_index,
1438 rel,
1439 activeRIRs);
1440 }
1443 }
1446 }
1448 /* Recurse into subqueries in WITH */
1450 {
1455 }
1457 /*
1458 * Recurse into sublink subqueries, too. But we already did the ones in
1459 * the rtable and cteList.
1460 */
1463 QTW_IGNORE_RC_SUBQUERIES);
1466 }
1469 /*
1470 * Modify the given query by adding 'AND rule_qual IS NOT TRUE' to its
1471 * qualification. This is used to generate suitable "else clauses" for
1472 * conditional INSTEAD rules. (Unfortunately we must use "x IS NOT TRUE",
1473 * not just "NOT x" which the planner is much smarter about, else we will
1474 * do the wrong thing when the qual evaluates to NULL.)
1475 *
1476 * The rule_qual may contain references to OLD or NEW. OLD references are
1477 * replaced by references to the specified rt_index (the relation that the
1478 * rule applies to). NEW references are only possible for INSERT and UPDATE
1479 * queries on the relation itself, and so they should be replaced by copies
1480 * of the related entries in the query's own targetlist.
1481 */
1486 CmdType event)
1487 {
1488 /* Don't scribble on the passed qual (it's in the relcache!) */
1491 /*
1492 * In case there are subqueries in the qual, acquire necessary locks and
1493 * fix any deleted JOIN RTE entries. (This is somewhat redundant with
1494 * rewriteRuleAction, but not entirely ... consider restructuring so that
1495 * we only need to process the qual this way once.)
1496 */
1499 /* Fix references to OLD */
1501 /* Fix references to NEW */
1504 PRS2_NEW_VARNO,
1508 event,
1509 rt_index);
1510 /* And attach the fixed qual */
1514 }
1517 /*
1518 * fireRules -
1519 * Iterate through rule locks applying rules.
1520 *
1521 * Input arguments:
1522 * parsetree - original query
1523 * rt_index - RT index of result relation in original query
1524 * event - type of rule event
1525 * locks - list of rules to fire
1526 * Output arguments:
1527 * *instead_flag - set TRUE if any unqualified INSTEAD rule is found
1528 * (must be initialized to FALSE)
1529 * *returning_flag - set TRUE if we rewrite RETURNING clause in any rule
1530 * (must be initialized to FALSE)
1531 * *qual_product - filled with modified original query if any qualified
1532 * INSTEAD rule is found (must be initialized to NULL)
1533 * Return value:
1534 * list of rule actions adjusted for use with this query
1535 *
1536 * Qualified INSTEAD rules generate their action with the qualification
1537 * condition added. They also generate a modified version of the original
1538 * query with the negated qualification added, so that it will run only for
1539 * rows that the qualified action doesn't act on. (If there are multiple
1540 * qualified INSTEAD rules, we AND all the negated quals onto a single
1541 * modified original query.) We won't execute the original, unmodified
1542 * query if we find either qualified or unqualified INSTEAD rules. If
1543 * we find both, the modified original query is discarded too.
1544 */
1548 CmdType event,
1553 {
1558 {
1562 QuerySource qsrc;
1565 /* Determine correct QuerySource value for actions */
1567 {
1570 else
1571 {
1574 }
1575 }
1576 else
1580 {
1581 /*
1582 * If there are INSTEAD rules with qualifications, the original
1583 * query is still performed. But all the negated rule
1584 * qualifications of the INSTEAD rules are added so it does its
1585 * actions only in cases where the rule quals of all INSTEAD rules
1586 * are false. Think of it as the default action in a case. We save
1587 * this in *qual_product so RewriteQuery() can add it to the query
1588 * list after we mangled it up enough.
1589 *
1590 * If we have already found an unqualified INSTEAD rule, then
1591 * *qual_product won't be used, so don't bother building it.
1592 */
1594 {
1598 event_qual,
1599 rt_index,
1600 event);
1601 }
1602 }
1604 /* Now process the rule's actions and add them to the result list */
1606 {
1614 returning_flag);
1620 }
1621 }
1624 }
1627 /*
1628 * RewriteQuery -
1629 * rewrites the query and apply the rules again on the queries rewritten
1630 *
1631 * rewrite_events is a list of open query-rewrite actions, so we can detect
1632 * infinite recursion.
1633 */
1636 {
1643 /*
1644 * If the statement is an update, insert or delete - fire rules on it.
1645 *
1646 * SELECT rules are handled later when we have all the queries that should
1647 * get executed. Also, utilities aren't rewritten at all (do we still
1648 * need that check?)
1649 */
1651 {
1654 Relation rt_entry_relation;
1662 /*
1663 * We can use NoLock here since either the parser or
1664 * AcquireRewriteLocks should have locked the rel already.
1665 */
1668 /*
1669 * If it's an INSERT or UPDATE, rewrite the targetlist into standard
1670 * form. This will be needed by the planner anyway, and doing it now
1671 * ensures that any references to NEW.field will behave sanely.
1672 */
1676 {
1679 /*
1680 * If it's an INSERT ... VALUES (...), (...), ... there will be a
1681 * single RTE for the VALUES targetlists.
1682 */
1684 {
1688 {
1694 }
1695 }
1698 {
1701 /* Process the main targetlist ... */
1703 /* ... and the VALUES expression lists */
1705 }
1706 else
1707 {
1708 /* Process just the main targetlist */
1710 }
1711 }
1713 /*
1714 * Collect and apply the appropriate rules.
1715 */
1720 {
1724 result_relation,
1725 event,
1726 locks,
1731 /*
1732 * If we got any product queries, recursively rewrite them --- but
1733 * first check for recursion!
1734 */
1736 {
1741 {
1749 }
1757 {
1763 }
1766 }
1767 }
1769 /*
1770 * If there is an INSTEAD, and the original query has a RETURNING, we
1771 * have to have found a RETURNING in the rule(s), else fail. (Because
1772 * DefineQueryRewrite only allows RETURNING in unconditional INSTEAD
1773 * rules, there's no need to worry whether the substituted RETURNING
1774 * will actually be executed --- it must be.)
1775 */
1779 {
1781 {
1807 }
1808 }
1811 }
1813 /*
1814 * For INSERTs, the original query is done first; for UPDATE/DELETE, it is
1815 * done last. This is needed because update and delete rule actions might
1816 * not do anything if they are invoked after the update or delete is
1817 * performed. The command counter increment between the query executions
1818 * makes the deleted (and maybe the updated) tuples disappear so the scans
1819 * for them in the rule actions cannot find them.
1820 *
1821 * If we found any unqualified INSTEAD, the original query is not done at
1822 * all, in any form. Otherwise, we add the modified form if qualified
1823 * INSTEADs were found, else the unmodified form.
1824 */
1826 {
1828 {
1831 else
1833 }
1834 else
1835 {
1838 else
1840 }
1841 }
1844 }
1847 /*
1848 * QueryRewrite -
1849 * Primary entry point to the query rewriter.
1850 * Rewrite one query via query rewrite system, possibly returning 0
1851 * or many queries.
1852 *
1853 * NOTE: the parsetree must either have come straight from the parser,
1854 * or have been scanned by AcquireRewriteLocks to acquire suitable locks.
1855 */
1856 List *
1858 {
1862 CmdType origCmdType;
1866 /*
1867 * Step 1
1868 *
1869 * Apply all non-SELECT rules possibly getting 0 or many queries
1870 */
1873 /*
1874 * Step 2
1875 *
1876 * Apply all the RIR rules on each query
1877 */
1879 {
1884 /*
1885 * If the query target was rewritten as a view, complain.
1886 */
1888 {
1893 {
1895 {
1918 }
1919 }
1920 }
1923 }
1925 /*
1926 * Step 3
1927 *
1928 * Determine which, if any, of the resulting queries is supposed to set
1929 * the command-result tag; and update the canSetTag fields accordingly.
1930 *
1931 * If the original query is still in the list, it sets the command tag.
1932 * Otherwise, the last INSTEAD query of the same kind as the original is
1933 * allowed to set the tag. (Note these rules can leave us with no query
1934 * setting the tag. The tcop code has to cope with this by setting up a
1935 * default tag based on the original un-rewritten query.)
1936 *
1937 * The Asserts verify that at most one query in the result list is marked
1938 * canSetTag. If we aren't checking asserts, we can fall out of the loop
1939 * as soon as we find the original query.
1940 */
1946 {
1950 {
1954 #ifndef USE_ASSERT_CHECKING
1956 #endif
1957 }
1958 else
1959 {
1965 }
1966 }
1972 }