Loading...
Searching...
No Matches
rewriteHandler.c File Reference
#include "postgres.h"#include "access/relation.h"#include "access/sysattr.h"#include "access/table.h"#include "catalog/dependency.h"#include "commands/trigger.h"#include "executor/executor.h"#include "foreign/fdwapi.h"#include "miscadmin.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "optimizer/optimizer.h"#include "parser/analyze.h"#include "parser/parse_coerce.h"#include "parser/parse_relation.h"#include "parser/parsetree.h"#include "rewrite/rewriteDefine.h"#include "rewrite/rewriteHandler.h"#include "rewrite/rewriteManip.h"#include "rewrite/rewriteSearchCycle.h"#include "rewrite/rowsecurity.h"#include "tcop/tcopprot.h"#include "utils/builtins.h"#include "utils/lsyscache.h"#include "utils/rel.h"
Include dependency graph for rewriteHandler.c:
Go to the source code of this file.
Data Structures | |
| struct | rewrite_event |
| struct | acquireLocksOnSubLinks_context |
| struct | fireRIRonSubLink_context |
Macros | |
| #define | ALL_EVENTS ((1 << CMD_INSERT) | (1 << CMD_UPDATE) | (1 << CMD_DELETE)) |
Typedefs | |
| typedef struct rewrite_event | rewrite_event |
| typedef struct acquireLocksOnSubLinks_context | acquireLocksOnSubLinks_context |
| typedef struct fireRIRonSubLink_context | fireRIRonSubLink_context |
Macro Definition Documentation
◆ ALL_EVENTS
| #define ALL_EVENTS ((1 << CMD_INSERT) | (1 << CMD_UPDATE) | (1 << CMD_DELETE)) |
Typedef Documentation
◆ acquireLocksOnSubLinks_context
◆ fireRIRonSubLink_context
◆ rewrite_event
Function Documentation
◆ acquireLocksOnSubLinks()
|
static |
Definition at line 310 of file rewriteHandler.c.
311{
313 return false;
315 {
317
318 /* Do what we came for */
320 context->for_execute,
321 false);
322 /* Fall through to process lefthand args of SubLink */
323 }
324
325 /*
326 * Do NOT recurse into Query nodes, because AcquireRewriteLocks already
327 * processed subselects of subselects for us.
328 */
330}
void AcquireRewriteLocks(Query *parsetree, bool forExecute, bool forUpdatePushedDown)
Definition rewriteHandler.c:148
static bool acquireLocksOnSubLinks(Node *node, acquireLocksOnSubLinks_context *context)
Definition rewriteHandler.c:310
Definition parsenodes.h:118
Definition primnodes.h:1041
References acquireLocksOnSubLinks(), AcquireRewriteLocks(), expression_tree_walker, fb(), acquireLocksOnSubLinks_context::for_execute, IsA, and SubLink::subselect.
Referenced by acquireLocksOnSubLinks(), AcquireRewriteLocks(), CopyAndAddInvertedQual(), fireRIRrules(), rewriteRuleAction(), and rewriteTargetView().
◆ AcquireRewriteLocks()
Definition at line 148 of file rewriteHandler.c.
151{
152 ListCell *l;
153 int rt_index;
154 acquireLocksOnSubLinks_context context;
155
157
158 /*
159 * First, process RTEs of the current query level.
160 */
161 rt_index = 0;
163 {
165 Relation rel;
166 LOCKMODE lockmode;
170 ListCell *ll;
171
172 ++rt_index;
174 {
176
177 /*
178 * Grab the appropriate lock type for the relation, and do not
179 * release it until end of transaction. This protects the
180 * rewriter, planner, and executor against schema changes
181 * mid-query.
182 *
183 * If forExecute is false, ignore rellockmode and just use
184 * AccessShareLock.
185 */
187 lockmode = AccessShareLock;
189 {
190 /* Upgrade RTE's lock mode to reflect pushed-down lock */
193 lockmode = rte->rellockmode;
194 }
195 else
196 lockmode = rte->rellockmode;
197
199
200 /*
201 * While we have the relation open, update the RTE's relkind,
202 * just in case it changed since this rule was made.
203 */
205
207 break;
208
210
211 /*
212 * Scan the join's alias var list to see if any columns have
213 * been dropped, and if so replace those Vars with null
214 * pointers.
215 *
216 * Since a join has only two inputs, we can expect to see
217 * multiple references to the same input RTE; optimize away
218 * multiple fetches.
219 */
221 curinputvarno = 0;
224 {
227
228 /* Look through any implicit coercion */
230
231 /*
232 * If the list item isn't a simple Var, then it must
233 * represent a merged column, ie a USING column, and so it
234 * couldn't possibly be dropped, since it's referenced in
235 * the join clause. (Conceivably it could also be a null
236 * pointer already? But that's OK too.)
237 */
239 {
240 /*
241 * The elements of an alias list have to refer to
242 * earlier RTEs of the same rtable, because that's the
243 * order the planner builds things in. So we already
244 * processed the referenced RTE, and so it's safe to
245 * use get_rte_attribute_is_dropped on it. (This might
246 * not hold after rewriting or planning, but it's OK
247 * to assume here.)
248 */
251 {
255 curinputvarno, rt_index);
257 parsetree->rtable);
258 }
260 aliasvar->varattno))
261 {
262 /* Replace the join alias item with a NULL */
264 }
265 }
267 }
269 break;
270
272
273 /*
274 * The subquery RTE itself is all right, but we have to
275 * recurse to process the represented subquery.
276 */
278 forExecute,
279 (forUpdatePushedDown ||
281 break;
282
283 default:
284 /* ignore other types of RTEs */
285 break;
286 }
287 }
288
289 /* Recurse into subqueries in WITH */
291 {
293
295 }
296
297 /*
298 * Recurse into sublink subqueries, too. But we already did the ones in
299 * the rtable and cteList.
300 */
301 if (parsetree->hasSubLinks)
303 QTW_IGNORE_RC_SUBQUERIES);
304}
RowMarkClause * get_parse_rowmark(Query *qry, Index rtindex)
Definition parse_relation.c:3561
bool get_rte_attribute_is_dropped(RangeTblEntry *rte, AttrNumber attnum)
Definition parse_relation.c:3392
Definition parsenodes.h:1727
Definition pg_list.h:54
Definition nodes.h:135
Definition parsenodes.h:1085
Definition rel.h:56
Definition primnodes.h:262
Definition pg_list.h:46
References AccessShareLock, acquireLocksOnSubLinks(), AcquireRewriteLocks(), Assert, Query::cteList, CommonTableExpr::ctequery, elog, ERROR, fb(), acquireLocksOnSubLinks_context::for_execute, get_parse_rowmark(), get_rte_attribute_is_dropped(), IsA, lappend(), lfirst, NIL, NoLock, QTW_IGNORE_RC_SUBQUERIES, query_tree_walker, RelationData::rd_rel, RowShareLock, rt_fetch, Query::rtable, RTE_JOIN, RTE_RELATION, RTE_SUBQUERY, strip_implicit_coercions(), table_close(), and table_open().
Referenced by acquireLocksOnSubLinks(), AcquireRewriteLocks(), ApplyRetrieveRule(), fmgr_sql_validator(), get_query_def(), inline_sql_function_in_from(), make_ruledef(), prepare_next_query(), print_function_sqlbody(), refresh_matview_datafill(), RevalidateCachedQuery(), and rewriteRuleAction().
◆ adjust_view_column_set()
Definition at line 3048 of file rewriteHandler.c.
3049{
3052
3053 col = -1;
3055 {
3056 /* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
3058
3060 {
3061 /*
3062 * There's a whole-row reference to the view. For permissions
3063 * purposes, treat it as a reference to each column available from
3064 * the view. (We should *not* convert this to a whole-row
3065 * reference to the base relation, since the view may not touch
3066 * all columns of the base relation.)
3067 */
3069
3071 {
3073 Var *var;
3074
3076 continue;
3078 result = bms_add_member(result,
3080 }
3081 }
3082 else
3083 {
3084 /*
3085 * Views do not have system columns, so we do not expect to see
3086 * any other system attnos here. If we do find one, the error
3087 * case will apply.
3088 */
3090
3092 {
3094
3095 result = bms_add_member(result,
3096 var->varattno - FirstLowInvalidHeapAttributeNumber);
3097 }
3098 else
3100 attno);
3101 }
3102 }
3103
3104 return result;
3105}
TargetEntry * get_tle_by_resno(List *tlist, AttrNumber resno)
Definition parse_relation.c:3541
Definition bitmapset.h:50
Definition primnodes.h:2236
References bms_add_member(), bms_next_member(), castNode, elog, ERROR, fb(), FirstLowInvalidHeapAttributeNumber, get_tle_by_resno(), InvalidAttrNumber, IsA, lfirst_node, and Var::varattno.
Referenced by relation_is_updatable(), and rewriteTargetView().
◆ adjustJoinTreeList()
Definition at line 713 of file rewriteHandler.c.
714{
716 ListCell *l;
717
719 {
721 {
723
725 rtr->rtindex == rt_index)
726 {
728 break;
729 }
730 }
731 }
733}
Definition primnodes.h:2293
References copyObject, fb(), foreach_delete_current, FromExpr::fromlist, IsA, Query::jointree, and lfirst.
Referenced by rewriteRuleAction().
◆ ApplyRetrieveRule()
|
static |
Definition at line 1714 of file rewriteHandler.c.
1719{
1722 RowMarkClause *rc;
1723 int numCols;
1724
1729
1730 /* Check if the expansion of non-system views are restricted */
1736 RelationGetRelationName(relation))));
1737
1738 if (rt_index == parsetree->resultRelation)
1739 {
1740 /*
1741 * We have a view as the result relation of the query, and it wasn't
1742 * rewritten by any rule. This case is supported if there is an
1743 * INSTEAD OF trigger that will trap attempts to insert/update/delete
1744 * view rows. The executor will check that; for the moment just plow
1745 * ahead. We have two cases:
1746 *
1747 * For INSERT, we needn't do anything. The unmodified RTE will serve
1748 * fine as the result relation.
1749 *
1750 * For UPDATE/DELETE/MERGE, we need to expand the view so as to have
1751 * source data for the operation. But we also need an unmodified RTE
1752 * to serve as the target. So, copy the RTE and add the copy to the
1753 * rangetable. Note that the copy does not get added to the jointree.
1754 * Also note that there's a hack in fireRIRrules to avoid calling this
1755 * function again when it arrives at the copied RTE.
1756 */
1758 return parsetree;
1762 {
1764 Var *var;
1766
1771 /* parsetree->mergeTargetRelation unchanged (use expanded view) */
1772
1773 /*
1774 * For the most part, Vars referencing the view should remain as
1775 * they are, meaning that they implicitly represent OLD values.
1776 * But in the RETURNING list if any, we want such Vars to
1777 * represent NEW values, so change them to reference the new RTE.
1778 *
1779 * Since ChangeVarNodes scribbles on the tree in-place, copy the
1780 * RETURNING list first for safety.
1781 */
1784 parsetree->resultRelation, 0);
1785
1786 /*
1787 * To allow the executor to compute the original view row to pass
1788 * to the INSTEAD OF trigger, we add a resjunk whole-row Var
1789 * referencing the original RTE. This will later get expanded
1790 * into a RowExpr computing all the OLD values of the view row.
1791 */
1796 true);
1797
1799
1800 /* Now, continue with expanding the original view RTE */
1801 }
1802 else
1805 }
1806
1807 /*
1808 * Check if there's a FOR [KEY] UPDATE/SHARE clause applying to this view.
1809 *
1810 * Note: we needn't explicitly consider any such clauses appearing in
1811 * ancestor query levels; their effects have already been pushed down to
1812 * here by markQueryForLocking, and will be reflected in "rc".
1813 */
1814 rc = get_parse_rowmark(parsetree, rt_index);
1815
1816 /*
1817 * Make a modifiable copy of the view query, and acquire needed locks on
1818 * the relations it mentions. Force at least RowShareLock for all such
1819 * rels if there's a FOR [KEY] UPDATE/SHARE clause affecting this view.
1820 */
1822
1824
1825 /*
1826 * If FOR [KEY] UPDATE/SHARE of view, mark all the contained tables as
1827 * implicit FOR [KEY] UPDATE/SHARE, the same as the parser would have done
1828 * if the view's subquery had been written out explicitly.
1829 */
1833
1834 /*
1835 * Recursively expand any view references inside the view.
1836 */
1838
1839 /*
1840 * Make sure the query is marked as having row security if the view query
1841 * does.
1842 */
1843 parsetree->hasRowSecurity |= rule_action->hasRowSecurity;
1844
1845 /*
1846 * Now, plug the view query in as a subselect, converting the relation's
1847 * original RTE to a subquery RTE.
1848 */
1850
1854
1855 /*
1856 * Clear fields that should not be set in a subquery RTE. Note that we
1857 * leave the relid, relkind, rellockmode, and perminfoindex fields set, so
1858 * that the view relation can be appropriately locked before execution and
1859 * its permissions checked.
1860 */
1863
1864 /*
1865 * Since we allow CREATE OR REPLACE VIEW to add columns to a view, the
1866 * rule_action might emit more columns than we expected when the current
1867 * query was parsed. Various places expect rte->eref->colnames to be
1868 * consistent with the non-junk output columns of the subquery, so patch
1869 * things up if necessary by adding some dummy column names.
1870 */
1873 {
1876 }
1877
1878 return parsetree;
1879}
Var * makeWholeRowVar(RangeTblEntry *rte, int varno, Index varlevelsup, bool allowScalar)
Definition makefuncs.c:137
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition makefuncs.c:289
static void markQueryForLocking(Query *qry, Node *jtnode, LockClauseStrength strength, LockWaitPolicy waitPolicy, bool pushedDown)
Definition rewriteHandler.c:1894
static Query * fireRIRrules(Query *parsetree, List *activeRIRs)
Definition rewriteHandler.c:1994
void ChangeVarNodes(Node *node, int rt_index, int new_index, int sublevels_up)
Definition rewriteManip.c:733
Definition primnodes.h:189
Definition parsenodes.h:1635
Definition localtime.c:73
References AcquireRewriteLocks(), ChangeVarNodes(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_UPDATE, Query::commandType, copyObject, elog, ereport, errcode(), errmsg(), ERROR, ExecCleanTargetListLength(), fb(), fireRIRrules(), FirstNormalObjectId, get_parse_rowmark(), lappend(), linitial, list_length(), makeString(), makeTargetEntry(), makeWholeRowVar(), markQueryForLocking(), pstrdup(), RelationGetRelationName, RelationGetRelid, RelationIsSecurityView, restrict_nonsystem_relation_kind, RESTRICT_RELKIND_VIEW, Query::returningList, rt_fetch, Query::rtable, RTE_SUBQUERY, RowMarkClause::strength, Query::targetList, unlikely, and RowMarkClause::waitPolicy.
Referenced by fireRIRrules().
◆ build_column_default()
Definition at line 1231 of file rewriteHandler.c.
1232{
1238 Oid exprtype;
1239
1241 {
1243
1246
1248 }
1249
1250 /*
1251 * If relation has a default for this column, fetch that expression.
1252 */
1254 {
1259 }
1260
1261 /*
1262 * No per-column default, so look for a default for the type itself. But
1263 * not for generated columns.
1264 */
1266 expr = get_typdefault(atttype);
1267
1270
1271 /*
1272 * Make sure the value is coerced to the target column type; this will
1273 * generally be true already, but there seem to be some corner cases
1274 * involving domain defaults where it might not be true. This should match
1275 * the parser's processing of non-defaulted expressions --- see
1276 * transformAssignedExpr().
1277 */
1278 exprtype = exprType(expr);
1279
1281 expr, exprtype,
1282 atttype, atttypmod,
1283 COERCION_ASSIGNMENT,
1284 COERCE_IMPLICIT_CAST,
1285 -1);
1290 " but default expression is of type %s",
1292 format_type_be(atttype),
1293 format_type_be(exprtype)),
1295
1296 return expr;
1297}
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition parse_coerce.c:79
Oid getIdentitySequence(Relation rel, AttrNumber attnum, bool missing_ok)
Definition pg_depend.c:945
Definition primnodes.h:2135
Definition tupdesc.h:136
Node * TupleDescGetDefault(TupleDesc tupdesc, AttrNumber attnum)
Definition tupdesc.c:1092
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:160
References COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, elog, ereport, errcode(), errhint(), errmsg(), ERROR, exprType(), fb(), format_type_be(), get_typdefault(), getIdentitySequence(), makeNode, NameStr, RelationData::rd_att, RelationGetRelationName, TupleDescAttr(), and TupleDescGetDefault().
Referenced by ATExecAddColumn(), ATExecAlterColumnType(), ATExecSetExpression(), BeginCopyFrom(), build_generation_expression(), ExecInitGenerated(), rewriteTargetListIU(), rewriteValuesRTE(), and slot_fill_defaults().
◆ build_generation_expression()
Definition at line 4521 of file rewriteHandler.c.
4522{
4525 Node *defexpr;
4527
4530
4535
4536 /*
4537 * If the column definition has a collation and it is different from the
4538 * collation of the generation expression, put a COLLATE clause around the
4539 * expression.
4540 */
4543 {
4545
4548 ce->location = -1;
4549
4551 }
4552
4553 return defexpr;
4554}
Node * build_column_default(Relation rel, int attrno)
Definition rewriteHandler.c:1231
Definition primnodes.h:1310
References Assert, build_column_default(), TupleDescData::constr, elog, ERROR, exprCollation(), fb(), TupleConstr::has_generated_virtual, makeNode, RelationGetDescr, RelationGetRelationName, and TupleDescAttr().
Referenced by createTableConstraints(), ExecRelGenVirtualNotNull(), expand_generated_columns_internal(), and expand_virtual_generated_columns().
◆ CopyAndAddInvertedQual()
|
static |
Definition at line 2323 of file rewriteHandler.c.
2327{
2328 /* Don't scribble on the passed qual (it's in the relcache!) */
2330 acquireLocksOnSubLinks_context context;
2331
2333
2334 /*
2335 * In case there are subqueries in the qual, acquire necessary locks and
2336 * fix any deleted JOIN RTE entries. (This is somewhat redundant with
2337 * rewriteRuleAction, but not entirely ... consider restructuring so that
2338 * we only need to process the qual this way once.)
2339 */
2341
2342 /* Fix references to OLD */
2344 /* Fix references to NEW */
2347 PRS2_NEW_VARNO,
2348 0,
2349 rt_fetch(rt_index,
2350 parsetree->rtable),
2351 parsetree->targetList,
2352 parsetree->resultRelation,
2353 (event == CMD_UPDATE) ?
2354 REPLACEVARS_CHANGE_VARNO :
2356 rt_index,
2357 &parsetree->hasSubLinks);
2358 /* And attach the fixed qual */
2360
2361 return parsetree;
2362}
Node * ReplaceVarsFromTargetList(Node *node, int target_varno, int sublevels_up, RangeTblEntry *target_rte, List *targetlist, int result_relation, ReplaceVarsNoMatchOption nomatch_option, int nomatch_varno, bool *outer_hasSubLinks)
Definition rewriteManip.c:1958
References acquireLocksOnSubLinks(), AddInvertedQual(), ChangeVarNodes(), CMD_INSERT, CMD_UPDATE, copyObject, fb(), acquireLocksOnSubLinks_context::for_execute, PRS2_NEW_VARNO, PRS2_OLD_VARNO, REPLACEVARS_CHANGE_VARNO, REPLACEVARS_SUBSTITUTE_NULL, ReplaceVarsFromTargetList(), rt_fetch, Query::rtable, and Query::targetList.
Referenced by fireRules().
◆ error_view_not_updatable()
| void error_view_not_updatable | ( | Relation | view, |
| CmdType | command, | ||
| List * | mergeActionList, | ||
| const char * | detail | ||
| ) |
Definition at line 3122 of file rewriteHandler.c.
3126{
3128
3129 switch (command)
3130 {
3135 RelationGetRelationName(view)),
3137 errhint("To enable inserting into the view, provide an INSTEAD OF INSERT trigger or an unconditional ON INSERT DO INSTEAD rule."));
3138 break;
3143 RelationGetRelationName(view)),
3145 errhint("To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule."));
3146 break;
3151 RelationGetRelationName(view)),
3153 errhint("To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an unconditional ON DELETE DO INSTEAD rule."));
3154 break;
3156
3157 /*
3158 * Note that the error hints here differ from above, since MERGE
3159 * doesn't support rules.
3160 */
3162 {
3164 {
3170 RelationGetRelationName(view)),
3172 errhint("To enable inserting into the view using MERGE, provide an INSTEAD OF INSERT trigger."));
3173 break;
3179 RelationGetRelationName(view)),
3182 break;
3188 RelationGetRelationName(view)),
3190 errhint("To enable deleting from the view using MERGE, provide an INSTEAD OF DELETE trigger."));
3191 break;
3193 break;
3194 default:
3196 break;
3197 }
3198 }
3199 break;
3200 default:
3202 break;
3203 }
3204}
Definition primnodes.h:2029
Definition reltrigger.h:48
References _, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_UPDATE, elog, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), ERROR, fb(), foreach_node, RelationGetRelationName, and RelationData::trigdesc.
Referenced by CheckValidResultRel(), RewriteQuery(), and rewriteTargetView().
◆ expand_generated_columns_in_expr()
Definition at line 4495 of file rewriteHandler.c.
4496{
4498
4500 {
4502
4504 /* eref needs to be set, but the actual name doesn't matter */
4508
4510 }
4511
4512 return node;
4513}
static Node * expand_generated_columns_internal(Node *node, Relation rel, int rt_index, RangeTblEntry *rte, int result_relation)
Definition rewriteHandler.c:4450
References TupleDescData::constr, expand_generated_columns_internal(), fb(), TupleConstr::has_generated_virtual, makeAlias(), makeNode, NIL, RelationGetDescr, RelationGetRelationName, RelationGetRelid, and RTE_RELATION.
Referenced by ATPrepAlterColumnType(), ATRewriteTable(), createTableConstraints(), ExecRelCheck(), get_relation_constraints(), pgoutput_row_filter_init(), QueueCheckConstraintValidation(), TransformPubWhereClauses(), and TriggerEnabled().
◆ expand_generated_columns_internal()
|
static |
Definition at line 4450 of file rewriteHandler.c.
4452{
4453 TupleDesc tupdesc;
4454
4455 tupdesc = RelationGetDescr(rel);
4457 {
4459
4461 {
4463
4465 {
4466 Node *defexpr;
4467 TargetEntry *te;
4468
4470 ChangeVarNodes(defexpr, 1, rt_index, 0);
4471
4473 tlist = lappend(tlist, te);
4474 }
4475 }
4476
4478
4480 result_relation,
4481 REPLACEVARS_CHANGE_VARNO, rt_index,
4482 NULL);
4483 }
4484
4485 return node;
4486}
Node * build_generation_expression(Relation rel, int attrno)
Definition rewriteHandler.c:4521
References Assert, build_generation_expression(), ChangeVarNodes(), TupleDescData::constr, fb(), TupleConstr::has_generated_virtual, i, lappend(), list_length(), makeTargetEntry(), TupleDescData::natts, NIL, RelationGetDescr, REPLACEVARS_CHANGE_VARNO, ReplaceVarsFromTargetList(), and TupleDescAttr().
Referenced by expand_generated_columns_in_expr().
◆ findDefaultOnlyColumns()
|
static |
Definition at line 1328 of file rewriteHandler.c.
1329{
1332
1334 {
1338
1340 {
1341 /* Populate the initial result bitmap from the first row */
1342 i = 0;
1344 {
1346
1347 i++;
1350 }
1351 }
1352 else
1353 {
1354 /* Update the result bitmap from this next row */
1355 i = 0;
1357 {
1359
1360 i++;
1363 }
1364 }
1365
1366 /*
1367 * If no column in the rows read so far contains only DEFAULT items,
1368 * we are done.
1369 */
1371 break;
1372 }
1373
1375}
Definition primnodes.h:2094
References bms_add_member(), bms_del_member(), bms_is_empty, fb(), i, IsA, and lfirst.
Referenced by rewriteTargetListIU().
◆ fireRIRonSubLink()
|
static |
Definition at line 1958 of file rewriteHandler.c.
1959{
1961 return false;
1963 {
1965
1966 /* Do what we came for */
1968 context->activeRIRs);
1969
1970 /*
1971 * Remember if any of the sublinks have row security.
1972 */
1974
1975 /* Fall through to process lefthand args of SubLink */
1976 }
1977
1978 /*
1979 * Do NOT recurse into Query nodes, because fireRIRrules already processed
1980 * subselects of subselects for us.
1981 */
1983}
static bool fireRIRonSubLink(Node *node, fireRIRonSubLink_context *context)
Definition rewriteHandler.c:1958
References fireRIRonSubLink_context::activeRIRs, expression_tree_walker, fb(), fireRIRonSubLink(), fireRIRrules(), fireRIRonSubLink_context::hasRowSecurity, IsA, and SubLink::subselect.
Referenced by fireRIRonSubLink(), and fireRIRrules().
◆ fireRIRrules()
Definition at line 1994 of file rewriteHandler.c.
1995{
1997 int rt_index;
1999
2000 /*
2001 * Expand SEARCH and CYCLE clauses in CTEs.
2002 *
2003 * This is just a convenient place to do this, since we are already
2004 * looking at each Query.
2005 */
2007 {
2009
2010 if (cte->search_clause || cte->cycle_clause)
2011 {
2012 cte = rewriteSearchAndCycle(cte);
2014 }
2015 }
2016
2017 /*
2018 * don't try to convert this into a foreach loop, because rtable list can
2019 * get changed each time through...
2020 */
2021 rt_index = 0;
2023 {
2025 Relation rel;
2026 List *locks;
2030
2031 ++rt_index;
2032
2034
2035 /*
2036 * A subquery RTE can't have associated rules, so there's nothing to
2037 * do to this level of the query, but we must recurse into the
2038 * subquery to expand any rule references in it.
2039 */
2041 {
2043
2044 /*
2045 * While we are here, make sure the query is marked as having row
2046 * security if any of its subqueries do.
2047 */
2048 parsetree->hasRowSecurity |= rte->subquery->hasRowSecurity;
2049
2050 continue;
2051 }
2052
2053 /*
2054 * Joins and other non-relation RTEs can be ignored completely.
2055 */
2057 continue;
2058
2059 /*
2060 * Always ignore RIR rules for materialized views referenced in
2061 * queries. (This does not prevent refreshing MVs, since they aren't
2062 * referenced in their own query definitions.)
2063 *
2064 * Note: in the future we might want to allow MVs to be conditionally
2065 * expanded as if they were regular views, if they are not scannable.
2066 * In that case this test would need to be postponed till after we've
2067 * opened the rel, so that we could check its state.
2068 */
2070 continue;
2071
2072 /*
2073 * In INSERT ... ON CONFLICT, ignore the EXCLUDED pseudo-relation;
2074 * even if it points to a view, we needn't expand it, and should not
2075 * because we want the RTE to remain of RTE_RELATION type. Otherwise,
2076 * it would get changed to RTE_SUBQUERY type, which is an
2077 * untested/unsupported situation.
2078 */
2081 continue;
2082
2083 /*
2084 * If the table is not referenced in the query, then we ignore it.
2085 * This prevents infinite expansion loop due to new rtable entries
2086 * inserted by expansion of a rule. A table is referenced if it is
2087 * part of the join set (a source table), or is referenced by any Var
2088 * nodes, or is the result table.
2089 */
2090 if (rt_index != parsetree->resultRelation &&
2092 continue;
2093
2094 /*
2095 * Also, if this is a new result relation introduced by
2096 * ApplyRetrieveRule, we don't want to do anything more with it.
2097 */
2098 if (rt_index == parsetree->resultRelation &&
2099 rt_index != origResultRelation)
2100 continue;
2101
2102 /*
2103 * We can use NoLock here since either the parser or
2104 * AcquireRewriteLocks should have locked the rel already.
2105 */
2107
2108 /*
2109 * Collect the RIR rules that we must apply
2110 */
2113 {
2114 locks = NIL;
2116 {
2119 continue;
2120
2122 }
2123
2124 /*
2125 * If we found any, apply them --- but first check for recursion!
2126 */
2128 {
2129 ListCell *l;
2130
2135 RelationGetRelationName(rel))));
2137
2138 foreach(l, locks)
2139 {
2141
2142 parsetree = ApplyRetrieveRule(parsetree,
2143 rule,
2144 rt_index,
2145 rel,
2146 activeRIRs);
2147 }
2148
2149 activeRIRs = list_delete_last(activeRIRs);
2150 }
2151 }
2152
2154 }
2155
2156 /* Recurse into subqueries in WITH */
2158 {
2160
2163
2164 /*
2165 * While we are here, make sure the query is marked as having row
2166 * security if any of its CTEs do.
2167 */
2169 }
2170
2171 /*
2172 * Recurse into sublink subqueries, too. But we already did the ones in
2173 * the rtable and cteList.
2174 */
2175 if (parsetree->hasSubLinks)
2176 {
2177 fireRIRonSubLink_context context;
2178
2179 context.activeRIRs = activeRIRs;
2181
2183 QTW_IGNORE_RC_SUBQUERIES);
2184
2185 /*
2186 * Make sure the query is marked as having row security if any of its
2187 * sublinks do.
2188 */
2189 parsetree->hasRowSecurity |= context.hasRowSecurity;
2190 }
2191
2192 /*
2193 * Apply any row-level security policies. We do this last because it
2194 * requires special recursion detection if the new quals have sublink
2195 * subqueries, and if we did it in the loop above query_tree_walker would
2196 * then recurse into those quals a second time.
2197 */
2198 rt_index = 0;
2200 {
2202 Relation rel;
2205 bool hasRowSecurity;
2207
2208 ++rt_index;
2209
2210 /* Only normal relations can have RLS policies */
2214 continue;
2215
2217
2218 /*
2219 * Fetch any new security quals that must be applied to this RTE.
2220 */
2223 &hasRowSecurity, &hasSubLinks);
2224
2226 {
2228 {
2229 acquireLocksOnSubLinks_context context;
2231
2232 /*
2233 * Recursively process the new quals, checking for infinite
2234 * recursion.
2235 */
2240 RelationGetRelationName(rel))));
2241
2243
2244 /*
2245 * get_row_security_policies just passed back securityQuals
2246 * and/or withCheckOptions, and there were SubLinks, make sure
2247 * we lock any relations which are referenced.
2248 *
2249 * These locks would normally be acquired by the parser, but
2250 * securityQuals and withCheckOptions are added post-parsing.
2251 */
2255 &context);
2256
2257 /*
2258 * Now that we have the locks on anything added by
2259 * get_row_security_policies, fire any RIR rules for them.
2260 */
2261 fire_context.activeRIRs = activeRIRs;
2263
2266
2269
2270 /*
2271 * We can ignore the value of fire_context.hasRowSecurity
2272 * since we only reach this code in cases where hasRowSecurity
2273 * is already true.
2274 */
2275 Assert(hasRowSecurity);
2276
2277 activeRIRs = list_delete_last(activeRIRs);
2278 }
2279
2280 /*
2281 * Add the new security barrier quals to the start of the RTE's
2282 * list so that they get applied before any existing barrier quals
2283 * (which would have come from a security-barrier view, and should
2284 * get lower priority than RLS conditions on the table itself).
2285 */
2287 rte->securityQuals);
2288
2290 parsetree->withCheckOptions);
2291 }
2292
2293 /*
2294 * Make sure the query is marked correctly if row-level security
2295 * applies, or if the new quals had sublinks.
2296 */
2297 if (hasRowSecurity)
2298 parsetree->hasRowSecurity = true;
2300 parsetree->hasSubLinks = true;
2301
2303 }
2304
2305 return parsetree;
2306}
static Query * ApplyRetrieveRule(Query *parsetree, RewriteRule *rule, int rt_index, Relation relation, List *activeRIRs)
Definition rewriteHandler.c:1714
bool rangeTableEntry_used(Node *node, int rt_index, int sublevels_up)
Definition rewriteManip.c:1058
CommonTableExpr * rewriteSearchAndCycle(CommonTableExpr *cte)
Definition rewriteSearchCycle.c:203
void get_row_security_policies(Query *root, RangeTblEntry *rte, int rt_index, List **securityQuals, List **withCheckOptions, bool *hasRowSecurity, bool *hasSubLinks)
Definition rowsecurity.c:98
Definition prs2lock.h:25
Definition prs2lock.h:41
Definition rewriteHandler.c:62
References acquireLocksOnSubLinks(), fireRIRonSubLink_context::activeRIRs, ApplyRetrieveRule(), Assert, CMD_SELECT, Query::cteList, CommonTableExpr::ctequery, ereport, errcode(), errmsg(), ERROR, OnConflictExpr::exclRelIndex, expression_tree_walker, fb(), fireRIRonSubLink(), fireRIRrules(), acquireLocksOnSubLinks_context::for_execute, get_row_security_policies(), fireRIRonSubLink_context::hasRowSecurity, i, lappend(), lappend_oid(), lfirst, lfirst_node, list_concat(), list_delete_last(), list_length(), list_member_oid(), NIL, NoLock, Query::onConflict, QTW_IGNORE_RC_SUBQUERIES, query_tree_walker, rangeTableEntry_used(), RelationData::rd_rules, RelationGetRelationName, RelationGetRelid, rewriteSearchAndCycle(), rt_fetch, Query::rtable, RTE_RELATION, RTE_SUBQUERY, rules, table_close(), and table_open().
Referenced by ApplyRetrieveRule(), fireRIRonSubLink(), fireRIRrules(), and QueryRewrite().
◆ fireRules()
|
static |
Definition at line 2394 of file rewriteHandler.c.
2401{
2403 ListCell *l;
2404
2405 foreach(l, locks)
2406 {
2411 ListCell *r;
2412
2413 /* Determine correct QuerySource value for actions */
2415 {
2418 else
2419 {
2422 }
2423 }
2424 else
2426
2428 {
2429 /*
2430 * If there are INSTEAD rules with qualifications, the original
2431 * query is still performed. But all the negated rule
2432 * qualifications of the INSTEAD rules are added so it does its
2433 * actions only in cases where the rule quals of all INSTEAD rules
2434 * are false. Think of it as the default action in a case. We save
2435 * this in *qual_product so RewriteQuery() can add it to the query
2436 * list after we mangled it up enough.
2437 *
2438 * If we have already found an unqualified INSTEAD rule, then
2439 * *qual_product won't be used, so don't bother building it.
2440 */
2442 {
2446 event_qual,
2447 rt_index,
2448 event);
2449 }
2450 }
2451
2452 /* Now process the rule's actions and add them to the result list */
2453 foreach(r, actions)
2454 {
2456
2458 continue;
2459
2461 event_qual, rt_index, event,
2462 returning_flag);
2463
2466
2468 }
2469 }
2470
2471 return results;
2472}
static Query * rewriteRuleAction(Query *parsetree, Query *rule_action, Node *rule_qual, int rt_index, CmdType event, bool *returning_flag)
Definition rewriteHandler.c:351
static Query * CopyAndAddInvertedQual(Query *parsetree, Node *rule_qual, int rt_index, CmdType event)
Definition rewriteHandler.c:2323
References CMD_NOTHING, CopyAndAddInvertedQual(), copyObject, fb(), lappend(), lfirst, NIL, QSRC_INSTEAD_RULE, QSRC_NON_INSTEAD_RULE, QSRC_QUAL_INSTEAD_RULE, and rewriteRuleAction().
Referenced by RewriteQuery().
◆ get_assignment_input()
Definition at line 1202 of file rewriteHandler.c.
1203{
1207 {
1209
1211 }
1213 {
1215
1218
1220 }
1221
1223}
Definition primnodes.h:1190
Definition primnodes.h:712
References FieldStore::arg, fb(), IsA, SubscriptingRef::refassgnexpr, and SubscriptingRef::refexpr.
Referenced by process_matched_tle().
◆ get_view_query()
Definition at line 2485 of file rewriteHandler.c.
2486{
2488
2490
2492 {
2494
2496 {
2497 /* A _RETURN rule should have only one action */
2500
2502 }
2503 }
2504
2507}
References Assert, CMD_SELECT, elog, ERROR, fb(), i, linitial, list_length(), RuleLock::numLocks, RelationData::rd_rel, RelationData::rd_rules, and RuleLock::rules.
Referenced by ATExecSetRelOptions(), LockViewRecurse(), relation_is_updatable(), and rewriteTargetView().
◆ markQueryForLocking()
|
static |
Definition at line 1894 of file rewriteHandler.c.
1897{
1899 return;
1901 {
1904
1906 {
1908
1909 applyLockingClause(qry, rti, strength, waitPolicy, pushedDown);
1910
1913 }
1915 {
1916 applyLockingClause(qry, rti, strength, waitPolicy, pushedDown);
1917 /* FOR UPDATE/SHARE of subquery is propagated to subquery's rels */
1919 strength, waitPolicy, true);
1920 }
1921 /* other RTE types are unaffected by FOR UPDATE */
1922 }
1924 {
1926 ListCell *l;
1927
1930 }
1932 {
1934
1937 }
1938 else
1941}
RTEPermissionInfo * getRTEPermissionInfo(List *rteperminfos, RangeTblEntry *rte)
Definition parse_relation.c:3958
void applyLockingClause(Query *qry, Index rtindex, LockClauseStrength strength, LockWaitPolicy waitPolicy, bool pushedDown)
Definition analyze.c:3640
Definition primnodes.h:2355
Definition primnodes.h:2327
Definition parsenodes.h:1344
References ACL_SELECT_FOR_UPDATE, applyLockingClause(), elog, ERROR, fb(), FromExpr::fromlist, getRTEPermissionInfo(), IsA, j, lfirst, markQueryForLocking(), nodeTag, rt_fetch, Query::rtable, RTE_RELATION, and RTE_SUBQUERY.
Referenced by ApplyRetrieveRule(), and markQueryForLocking().
◆ matchLocks()
|
static |
Definition at line 1639 of file rewriteHandler.c.
1644{
1647 int nlocks;
1649
1652
1654 {
1655 if (parsetree->resultRelation != varno)
1657 }
1658
1659 nlocks = rulelocks->numLocks;
1660
1662 {
1664
1667
1668 /*
1669 * Suppress ON INSERT/UPDATE/DELETE rules that are disabled or
1670 * configured to not fire during the current session's replication
1671 * role. ON SELECT rules will always be applied in order to keep views
1672 * working even in LOCAL or REPLICA role.
1673 */
1675 {
1677 {
1680 continue;
1681 }
1682 else /* ORIGIN or LOCAL ROLE */
1683 {
1686 continue;
1687 }
1688
1689 /* Non-SELECT rules are not supported for MERGE */
1694 RelationGetRelationName(relation)),
1696 }
1697
1699 {
1703 }
1704 }
1705
1707}
References CMD_MERGE, CMD_SELECT, CMD_UPDATE, Query::commandType, ereport, errcode(), errdetail(), errmsg(), ERROR, fb(), i, lappend(), NIL, rangeTableEntry_used(), RelationData::rd_rules, RelationGetRelationName, RULE_DISABLED, RULE_FIRES_ON_ORIGIN, RULE_FIRES_ON_REPLICA, SESSION_REPLICATION_ROLE_REPLICA, and SessionReplicationRole.
Referenced by RewriteQuery(), and rewriteValuesRTE().
◆ process_matched_tle()
|
static |
Definition at line 1049 of file rewriteHandler.c.
1052{
1053 TargetEntry *result;
1061
1063 {
1064 /*
1065 * Normal case where this is the first assignment to the attribute.
1066 */
1068 }
1069
1070 /*----------
1071 * Multiple assignments to same attribute. Allow only if all are
1072 * FieldStore or SubscriptingRef assignment operations. This is a bit
1073 * tricky because what we may actually be looking at is a nest of
1074 * such nodes; consider
1075 * UPDATE tab SET col.fld1.subfld1 = x, col.fld2.subfld2 = y
1076 * The two expressions produced by the parser will look like
1077 * FieldStore(col, fld1, FieldStore(placeholder, subfld1, x))
1078 * FieldStore(col, fld2, FieldStore(placeholder, subfld2, y))
1079 * However, we can ignore the substructure and just consider the top
1080 * FieldStore or SubscriptingRef from each assignment, because it works to
1081 * combine these as
1082 * FieldStore(FieldStore(col, fld1,
1083 * FieldStore(placeholder, subfld1, x)),
1084 * fld2, FieldStore(placeholder, subfld2, y))
1085 * Note the leftmost expression goes on the inside so that the
1086 * assignments appear to occur left-to-right.
1087 *
1088 * For FieldStore, instead of nesting we can generate a single
1089 * FieldStore with multiple target fields. We must nest when
1090 * SubscriptingRefs are involved though.
1091 *
1092 * As a further complication, the destination column might be a domain,
1093 * resulting in each assignment containing a CoerceToDomain node over a
1094 * FieldStore or SubscriptingRef. These should have matching target
1095 * domains, so we strip them and reconstitute a single CoerceToDomain over
1096 * the combined FieldStore/SubscriptingRef nodes. (Notice that this has
1097 * the result that the domain's checks are applied only after we do all
1098 * the field or element updates, not after each one. This is desirable.)
1099 *----------
1100 */
1103
1108 {
1109 /* we assume without checking that resulttypmod/resultcollid match */
1113 }
1114
1123 attrName)));
1124
1125 /*
1126 * Prior TLE could be a nest of assignments if we do this more than once.
1127 */
1129 for (;;)
1130 {
1132
1134 break; /* found the original Var reference */
1136 }
1141 attrName)));
1142
1143 /*
1144 * Looks OK to nest 'em.
1145 */
1147 {
1149
1151 {
1152 /* combine the two */
1154 fstore->newvals =
1157 fstore->fieldnums =
1160 }
1161 else
1162 {
1163 /* general case, just nest 'em */
1166 }
1168 }
1170 {
1172
1176 }
1177 else
1178 {
1181 }
1182
1184 {
1185 /* put back the CoerceToDomain */
1187
1191 }
1192
1195 return result;
1196}
TargetEntry * flatCopyTargetEntry(TargetEntry *src_tle)
Definition makefuncs.c:322
Definition primnodes.h:2051
References arg, FieldStore::arg, elog, equal(), ereport, errcode(), errmsg(), ERROR, TargetEntry::expr, exprType(), fb(), flatCopyTargetEntry(), get_assignment_input(), IsA, list_concat_copy(), makeNode, FieldStore::newvals, and SubscriptingRef::refexpr.
Referenced by rewriteTargetListIU().
◆ QueryRewrite()
Definition at line 4567 of file rewriteHandler.c.
4568{
4571 List *results;
4572 ListCell *l;
4576
4577 /*
4578 * This function is only applied to top-level original queries
4579 */
4581 Assert(parsetree->canSetTag);
4582
4583 /*
4584 * Step 1
4585 *
4586 * Apply all non-SELECT rules possibly getting 0 or many queries
4587 */
4589
4590 /*
4591 * Step 2
4592 *
4593 * Apply all the RIR rules on each query
4594 *
4595 * This is also a handy place to mark each query with the original queryId
4596 */
4597 results = NIL;
4599 {
4601
4603
4604 query->queryId = input_query_id;
4605
4606 results = lappend(results, query);
4607 }
4608
4609 /*
4610 * Step 3
4611 *
4612 * Determine which, if any, of the resulting queries is supposed to set
4613 * the command-result tag; and update the canSetTag fields accordingly.
4614 *
4615 * If the original query is still in the list, it sets the command tag.
4616 * Otherwise, the last INSTEAD query of the same kind as the original is
4617 * allowed to set the tag. (Note these rules can leave us with no query
4618 * setting the tag. The tcop code has to cope with this by setting up a
4619 * default tag based on the original un-rewritten query.)
4620 *
4621 * The Asserts verify that at most one query in the result list is marked
4622 * canSetTag. If we aren't checking asserts, we can fall out of the loop
4623 * as soon as we find the original query.
4624 */
4628
4629 foreach(l, results)
4630 {
4632
4634 {
4635 Assert(query->canSetTag);
4638#ifndef USE_ASSERT_CHECKING
4639 break;
4640#endif
4641 }
4642 else
4643 {
4644 Assert(!query->canSetTag);
4646 (query->querySource == QSRC_INSTEAD_RULE ||
4647 query->querySource == QSRC_QUAL_INSTEAD_RULE))
4648 lastInstead = query;
4649 }
4650 }
4651
4654
4655 return results;
4656}
static List * RewriteQuery(Query *parsetree, List *rewrite_events, int orig_rt_length, int num_ctes_processed)
Definition rewriteHandler.c:3883
References Assert, Query::commandType, fb(), fireRIRrules(), lappend(), lfirst, NIL, QSRC_INSTEAD_RULE, QSRC_ORIGINAL, QSRC_QUAL_INSTEAD_RULE, and RewriteQuery().
Referenced by ExecCreateTableAs(), ExplainOneUtility(), ExplainQuery(), PerformCursorOpen(), pg_rewrite_query(), and refresh_matview_datafill().
◆ relation_is_updatable()
| int relation_is_updatable | ( | Oid | reloid, |
| List * | outer_reloids, | ||
| bool | include_triggers, | ||
| Bitmapset * | include_cols | ||
| ) |
Definition at line 2867 of file rewriteHandler.c.
2871{
2872 int events = 0;
2873 Relation rel;
2875
2876#define ALL_EVENTS ((1 << CMD_INSERT) | (1 << CMD_UPDATE) | (1 << CMD_DELETE))
2877
2878 /* Since this function recurses, it could be driven to stack overflow */
2879 check_stack_depth();
2880
2882
2883 /*
2884 * If the relation doesn't exist, return zero rather than throwing an
2885 * error. This is helpful since scanning an information_schema view under
2886 * MVCC rules can result in referencing rels that have actually been
2887 * deleted already.
2888 */
2890 return 0;
2891
2892 /* If we detect a recursive view, report that it is not updatable */
2894 {
2896 return 0;
2897 }
2898
2899 /* If the relation is a table, it is always updatable */
2902 {
2905 }
2906
2907 /* Look for unconditional DO INSTEAD rules, and note supported events */
2910 {
2912
2914 {
2917 {
2919 }
2920 }
2921
2922 /* If we have rules for all events, we're done */
2924 {
2926 return events;
2927 }
2928 }
2929
2930 /* Similarly look for INSTEAD OF triggers, if they are to be included */
2932 {
2934
2936 {
2938 events |= (1 << CMD_INSERT);
2940 events |= (1 << CMD_UPDATE);
2942 events |= (1 << CMD_DELETE);
2943
2944 /* If we have triggers for all events, we're done */
2946 {
2948 return events;
2949 }
2950 }
2951 }
2952
2953 /* If this is a foreign table, check which update events it supports */
2955 {
2957
2959 events |= fdwroutine->IsForeignRelUpdatable(rel);
2960 else
2961 {
2962 /* Assume presence of executor functions is sufficient */
2964 events |= (1 << CMD_INSERT);
2966 events |= (1 << CMD_UPDATE);
2968 events |= (1 << CMD_DELETE);
2969 }
2970
2972 return events;
2973 }
2974
2975 /* Check if this is an automatically updatable view */
2977 {
2979
2981 {
2987
2988 /*
2989 * Determine which of the view's columns are updatable. If there
2990 * are none within the set of columns we are looking at, then the
2991 * view doesn't support INSERT/UPDATE, but it may still support
2992 * DELETE.
2993 */
2996
2999
3002 else
3004
3005 /*
3006 * The base relation must also support these update commands.
3007 * Tables are always updatable, but for any other kind of base
3008 * relation we must do a recursive check limited to the columns
3009 * referenced by the locally updatable columns in this view.
3010 */
3014
3017 {
3020 RelationGetRelid(rel));
3022 viewquery->targetList);
3024 outer_reloids,
3025 include_triggers,
3026 include_cols);
3028 }
3029 events |= auto_events;
3030 }
3031 }
3032
3033 /* If we reach here, the relation may support some update commands */
3035 return events;
3036}
Bitmapset * bms_int_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1108
FdwRoutine * GetFdwRoutineForRelation(Relation relation, bool makecopy)
Definition foreign.c:443
static const char * view_cols_are_auto_updatable(Query *viewquery, Bitmapset *required_cols, Bitmapset **updatable_cols, char **non_updatable_col)
Definition rewriteHandler.c:2784
int relation_is_updatable(Oid reloid, List *outer_reloids, bool include_triggers, Bitmapset *include_cols)
Definition rewriteHandler.c:2867
static Bitmapset * adjust_view_column_set(Bitmapset *cols, List *targetlist)
Definition rewriteHandler.c:3048
const char * view_query_is_auto_updatable(Query *viewquery, bool check_cols)
Definition rewriteHandler.c:2636
#define ALL_EVENTS
Relation try_relation_open(Oid relationId, LOCKMODE lockmode)
Definition relation.c:88
Definition fdwapi.h:205
IsForeignRelUpdatable_function IsForeignRelUpdatable
Definition fdwapi.h:240
References AccessShareLock, adjust_view_column_set(), ALL_EVENTS, Assert, bms_int_members(), bms_is_empty, check_stack_depth(), CMD_DELETE, CMD_INSERT, CMD_UPDATE, FdwRoutine::ExecForeignDelete, FdwRoutine::ExecForeignInsert, FdwRoutine::ExecForeignUpdate, fb(), get_view_query(), GetFdwRoutineForRelation(), i, FdwRoutine::IsForeignRelUpdatable, lappend_oid(), linitial, list_delete_last(), list_member_oid(), RelationData::rd_rel, RelationData::rd_rules, relation_close(), relation_is_updatable(), RelationGetRelid, rt_fetch, RTE_RELATION, RelationData::trigdesc, try_relation_open(), view_cols_are_auto_updatable(), and view_query_is_auto_updatable().
Referenced by pg_column_is_updatable(), pg_relation_is_updatable(), and relation_is_updatable().
◆ RewriteQuery()
|
static |
Definition at line 3883 of file rewriteHandler.c.
3885{
3887 bool instead = false;
3888 bool returning = false;
3893
3894 /*
3895 * First, recursively process any insert/update/delete/merge statements in
3896 * WITH clauses. (We have to do this first because the WITH clauses may
3897 * get copied into rule actions below.)
3898 *
3899 * Any new WITH clauses from rule actions are processed when we recurse
3900 * into product queries below. However, when recursing, we must take care
3901 * to avoid rewriting a CTE query more than once (because expanding
3902 * generated columns in the targetlist more than once would fail). Since
3903 * new CTEs from product queries are added to the start of the list (see
3904 * rewriteRuleAction), we just skip the last num_ctes_processed items.
3905 */
3907 {
3912
3913 /* Skip already-processed CTEs at the end of the list */
3915 break;
3916
3918 continue;
3919
3921
3922 /*
3923 * Currently we can only handle unconditional, single-statement DO
3924 * INSTEAD rules correctly; we have to get exactly one non-utility
3925 * Query out of the rewrite operation to stuff back into the CTE node.
3926 */
3928 {
3929 /* Must check it's not a utility command */
3936 {
3937 /*
3938 * Currently it could only be NOTIFY; this error message will
3939 * need work if we ever allow other utility commands in rules.
3940 */
3944 }
3945 /* WITH queries should never be canSetTag */
3946 Assert(!ctequery->canSetTag);
3947 /* Push the single Query back into the CTE node */
3949 }
3951 {
3955 }
3956 else
3957 {
3959
3960 /* examine queries to determine which error message to issue */
3962 {
3964
3968 errmsg("conditional DO INSTEAD rules are not supported for data-modifying statements in WITH")));
3973 }
3974
3977 errmsg("multi-statement DO INSTEAD rules are not supported for data-modifying statements in WITH")));
3978 }
3979 }
3981
3982 /*
3983 * If the statement is an insert, update, delete, or merge, adjust its
3984 * targetlist as needed, and then fire INSERT/UPDATE/DELETE rules on it.
3985 *
3986 * SELECT rules are handled later when we have all the queries that should
3987 * get executed. Also, utilities aren't rewritten at all (do we still
3988 * need that check?)
3989 */
3991 {
3992 int result_relation;
3995 List *locks;
4001
4002 result_relation = parsetree->resultRelation;
4003 Assert(result_relation != 0);
4006
4007 /*
4008 * We can use NoLock here since either the parser or
4009 * AcquireRewriteLocks should have locked the rel already.
4010 */
4012
4013 /*
4014 * Rewrite the targetlist as needed for the command type.
4015 */
4017 {
4020
4021 /*
4022 * Test if it's a multi-row INSERT ... VALUES (...), (...), ... by
4023 * looking for a VALUES RTE in the fromlist. For product queries,
4024 * we must ignore any already-processed VALUES RTEs from the
4025 * original query. These appear at the start of the rangetable.
4026 */
4028 {
4030
4032 {
4034 parsetree->rtable);
4035
4037 {
4038 /* should not find more than one VALUES RTE */
4041
4044 }
4045 }
4046 }
4047
4049 {
4051
4052 /* Process the main targetlist ... */
4054 parsetree->commandType,
4055 parsetree->override,
4056 rt_entry_relation,
4057 values_rte,
4058 values_rte_index,
4059 &unused_values_attrnos);
4060 /* ... and the VALUES expression lists */
4062 rt_entry_relation,
4063 unused_values_attrnos))
4065 }
4066 else
4067 {
4068 /* Process just the main targetlist */
4069 parsetree->targetList =
4071 parsetree->commandType,
4072 parsetree->override,
4073 rt_entry_relation,
4075 }
4076
4079 {
4082 CMD_UPDATE,
4083 parsetree->override,
4084 rt_entry_relation,
4086 }
4087 }
4089 {
4091 parsetree->targetList =
4093 parsetree->commandType,
4094 parsetree->override,
4095 rt_entry_relation,
4097 }
4099 {
4101
4102 /*
4103 * Rewrite each action targetlist separately
4104 */
4106 {
4108
4110 {
4113 break;
4116
4117 /*
4118 * MERGE actions do not permit multi-row INSERTs, so
4119 * there is no VALUES RTE to deal with here.
4120 */
4121 action->targetList =
4123 action->commandType,
4124 action->override,
4125 rt_entry_relation,
4127 break;
4128 default:
4130 break;
4131 }
4132 }
4133 }
4135 {
4136 /* Nothing to do here */
4137 }
4138 else
4140
4141 /*
4142 * Collect and apply the appropriate rules.
4143 */
4145 result_relation, parsetree, &hasUpdate);
4146
4149 result_relation,
4150 event,
4151 locks,
4152 &instead,
4153 &returning,
4154 &qual_product);
4155
4156 /*
4157 * If we have a VALUES RTE with any remaining untouched DEFAULT items,
4158 * and we got any product queries, finalize the VALUES RTE for each
4159 * product query (replacing the remaining DEFAULT items with NULLs).
4160 * We don't do this for the original query, because we know that it
4161 * must be an auto-insert on a view, and so should use the base
4162 * relation's defaults for any remaining DEFAULT items.
4163 */
4165 {
4166 ListCell *n;
4167
4168 /*
4169 * Each product query has its own copy of the VALUES RTE at the
4170 * same index in the rangetable, so we must finalize each one.
4171 *
4172 * Note that if the product query is an INSERT ... SELECT, then
4173 * the VALUES RTE will be at the same index in the SELECT part of
4174 * the product query rather than the top-level product query
4175 * itself.
4176 */
4178 {
4181
4185 {
4187
4189 {
4192
4194 src_rte->subquery &&
4198 }
4199 }
4200
4204
4206 }
4207 }
4208
4209 /*
4210 * If there was no unqualified INSTEAD rule, and the target relation
4211 * is a view without any INSTEAD OF triggers, see if the view can be
4212 * automatically updated. If so, we perform the necessary query
4213 * transformation here and add the resulting query to the
4214 * product_queries list, so that it gets recursively rewritten if
4215 * necessary. For MERGE, the view must be automatically updatable if
4216 * any of the merge actions lack a corresponding INSTEAD OF trigger.
4217 *
4218 * If the view cannot be automatically updated, we throw an error here
4219 * which is OK since the query would fail at runtime anyway. Throwing
4220 * the error here is preferable to the executor check since we have
4221 * more detailed information available about why the view isn't
4222 * updatable.
4223 */
4224 if (!instead &&
4227 parsetree->mergeActionList))
4228 {
4229 /*
4230 * If there were any qualified INSTEAD rules, don't allow the view
4231 * to be automatically updated (an unqualified INSTEAD rule or
4232 * INSTEAD OF trigger is required).
4233 */
4236 parsetree->commandType,
4237 parsetree->mergeActionList,
4239
4240 /*
4241 * Attempt to rewrite the query to automatically update the view.
4242 * This throws an error if the view can't be automatically
4243 * updated.
4244 */
4246
4247 /*
4248 * At this point product_queries contains any DO ALSO rule
4249 * actions. Add the rewritten query before or after those. This
4250 * must match the handling the original query would have gotten
4251 * below, if we allowed it to be included again.
4252 */
4255 else
4257
4258 /*
4259 * Set the "instead" flag, as if there had been an unqualified
4260 * INSTEAD, to prevent the original query from being included a
4261 * second time below. The transformation will have rewritten any
4262 * RETURNING list, so we can also set "returning" to forestall
4263 * throwing an error below.
4264 */
4265 instead = true;
4266 returning = true;
4268 }
4269
4270 /*
4271 * If we got any product queries, recursively rewrite them --- but
4272 * first check for recursion!
4273 */
4275 {
4276 ListCell *n;
4278
4280 {
4283 rev->event == event)
4288 }
4289
4292 rev->event = event;
4294
4296 {
4299
4300 /*
4301 * For an updatable view, pt might be the rewritten version of
4302 * the original query, in which case we pass on orig_rt_length
4303 * to finish processing any VALUES RTE it contained.
4304 *
4305 * Otherwise, we have a product query created by fireRules().
4306 * Any VALUES RTEs from the original query have been fully
4307 * processed, and must be skipped when we recurse.
4308 */
4310 pt == parsetree ?
4311 orig_rt_length :
4312 product_orig_rt_length,
4313 num_ctes_processed);
4315 }
4316
4318 }
4319
4320 /*
4321 * If there is an INSTEAD, and the original query has a RETURNING, we
4322 * have to have found a RETURNING in the rule(s), else fail. (Because
4323 * DefineQueryRewrite only allows RETURNING in unconditional INSTEAD
4324 * rules, there's no need to worry whether the substituted RETURNING
4325 * will actually be executed --- it must be.)
4326 */
4328 parsetree->returningList &&
4329 !returning)
4330 {
4331 switch (event)
4332 {
4339 break;
4346 break;
4353 break;
4354 default:
4356 (int) event);
4357 break;
4358 }
4359 }
4360
4361 /*
4362 * Updatable views are supported by ON CONFLICT, so don't prevent that
4363 * case from proceeding
4364 */
4367 !updatableview)
4370 errmsg("INSERT with ON CONFLICT clause cannot be used with table that has INSERT or UPDATE rules")));
4371
4373 }
4374
4375 /*
4376 * For INSERTs, the original query is done first; for UPDATE/DELETE, it is
4377 * done last. This is needed because update and delete rule actions might
4378 * not do anything if they are invoked after the update or delete is
4379 * performed. The command counter increment between the query executions
4380 * makes the deleted (and maybe the updated) tuples disappear so the scans
4381 * for them in the rule actions cannot find them.
4382 *
4383 * If we found any unqualified INSTEAD, the original query is not done at
4384 * all, in any form. Otherwise, we add the modified form if qualified
4385 * INSTEADs were found, else the unmodified form.
4386 */
4387 if (!instead)
4388 {
4390 {
4393 else
4395 }
4396 else
4397 {
4400 else
4402 }
4403 }
4404
4405 /*
4406 * If the original query has a CTE list, and we generated more than one
4407 * non-utility result query, we have to fail because we'll have copied the
4408 * CTE list into each result query. That would break the expectation of
4409 * single evaluation of CTEs. This could possibly be fixed by
4410 * restructuring so that a CTE list can be shared across multiple Query
4411 * and PlannableStatement nodes.
4412 */
4414 {
4416
4418 {
4420
4422 qcount++;
4423 }
4428 }
4429
4431}
bool view_has_instead_trigger(Relation view, CmdType event, List *mergeActionList)
Definition rewriteHandler.c:2524
static List * fireRules(Query *parsetree, int rt_index, CmdType event, List *locks, bool *instead_flag, bool *returning_flag, Query **qual_product)
Definition rewriteHandler.c:2394
static bool rewriteValuesRTE(Query *parsetree, RangeTblEntry *rte, int rti, Relation target_relation, Bitmapset *unused_cols)
Definition rewriteHandler.c:1416
static Query * rewriteTargetView(Query *parsetree, Relation view)
Definition rewriteHandler.c:3217
static void rewriteValuesRTEToNulls(Query *parsetree, RangeTblEntry *rte)
Definition rewriteHandler.c:1601
static List * matchLocks(CmdType event, Relation relation, int varno, Query *parsetree, bool *hasUpdate)
Definition rewriteHandler.c:1639
void error_view_not_updatable(Relation view, CmdType command, List *mergeActionList, const char *detail)
Definition rewriteHandler.c:3122
static List * rewriteTargetListIU(List *targetList, CmdType commandType, OverridingKind override, Relation target_relation, RangeTblEntry *values_rte, int values_rte_index, Bitmapset **unused_values_attrnos)
Definition rewriteHandler.c:775
Definition rewriteHandler.c:51
References OnConflictExpr::action, Assert, castNode, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_SELECT, CMD_UPDATE, CMD_UTILITY, Query::commandType, Query::cteList, CommonTableExpr::ctequery, elog, ereport, errcode(), errhint(), errmsg(), ERROR, error_view_not_updatable(), fb(), fireRules(), foreach_current_index, FromExpr::fromlist, gettext_noop, i, IsA, Query::jointree, lappend(), lcons(), lfirst, lfirst_node, linitial, linitial_node, list_concat(), list_delete_last(), list_length(), matchLocks(), Query::mergeActionList, NIL, NoLock, Query::onConflict, ONCONFLICT_UPDATE, OnConflictExpr::onConflictSet, OVERRIDING_NOT_SET, palloc_object, QSRC_NON_INSTEAD_RULE, QSRC_QUAL_INSTEAD_RULE, RelationGetRelationName, RelationGetRelid, Query::returningList, RewriteQuery(), rewriteTargetListIU(), rewriteTargetView(), rewriteValuesRTE(), rewriteValuesRTEToNulls(), rt_fetch, Query::rtable, RTE_RELATION, RTE_SUBQUERY, RTE_VALUES, table_close(), table_open(), Query::targetList, and view_has_instead_trigger().
Referenced by QueryRewrite(), and RewriteQuery().
◆ rewriteRuleAction()
|
static |
Definition at line 351 of file rewriteHandler.c.
357{
359 new_varno;
363 acquireLocksOnSubLinks_context context;
365
367
368 /*
369 * Make modifiable copies of rule action and qual (what we're passed are
370 * the stored versions in the relcache; don't touch 'em!).
371 */
374
375 /*
376 * Acquire necessary locks and fix any deleted JOIN RTE entries.
377 */
380
381 current_varno = rt_index;
384
385 /*
386 * Adjust rule action and qual to offset its varnos, so that we can merge
387 * its rtable with the main parsetree's rtable.
388 *
389 * If the rule action is an INSERT...SELECT, the OLD/NEW rtable entries
390 * will be in the SELECT part, and we have to modify that rather than the
391 * top-level INSERT (kluge!).
392 */
394
397 /* but references to OLD should point at original rt_index */
402
403 /*
404 * Mark any subquery RTEs in the rule action as LATERAL if they contain
405 * Vars referring to the current query level (references to NEW/OLD).
406 * Those really are lateral references, but we've historically not
407 * required users to mark such subqueries with LATERAL explicitly. But
408 * the planner will complain if such Vars exist in a non-LATERAL subquery,
409 * so we have to fix things up here.
410 */
412 {
414
418 }
419
420 /*
421 * Generate expanded rtable consisting of main parsetree's rtable plus
422 * rule action's rtable; this becomes the complete rtable for the rule
423 * action. Some of the entries may be unused after we finish rewriting,
424 * but we leave them all in place to avoid having to adjust the query's
425 * varnos. RT entries that are not referenced in the completed jointree
426 * will be ignored by the planner, so they do not affect query semantics.
427 *
428 * Also merge RTEPermissionInfo lists to ensure that all permissions are
429 * checked correctly.
430 *
431 * If the rule is INSTEAD, then the original query won't be executed at
432 * all, and so its rteperminfos must be preserved so that the executor
433 * will do the correct permissions checks on the relations referenced in
434 * it. This allows us to check that the caller has, say, insert-permission
435 * on a view, when the view is not semantically referenced at all in the
436 * resulting query.
437 *
438 * When a rule is not INSTEAD, the permissions checks done using the
439 * copied entries will be redundant with those done during execution of
440 * the original query, but we don't bother to treat that case differently.
441 *
442 * NOTE: because planner will destructively alter rtable and rteperminfos,
443 * we must ensure that rule action's lists are separate and shares no
444 * substructure with the main query's lists. Hence do a deep copy here
445 * for both.
446 */
447 {
450
451 /*
452 * RewriteQuery relies on the fact that RT entries from the original
453 * query appear at the start of the expanded rtable, so we put the
454 * action's original table at the end of the list.
455 */
460 }
461
462 /*
463 * There could have been some SubLinks in parsetree's rtable, in which
464 * case we'd better mark the sub_action correctly.
465 */
467 {
469 {
471
473 {
475 sub_action->hasSubLinks =
477 break;
479 sub_action->hasSubLinks =
481 break;
483 sub_action->hasSubLinks =
485 break;
487 sub_action->hasSubLinks =
489 break;
490 default:
491 /* other RTE types don't contain bare expressions */
492 break;
493 }
494 sub_action->hasSubLinks |=
497 break; /* no need to keep scanning rtable */
498 }
499 }
500
501 /*
502 * Also, we might have absorbed some RTEs with RLS conditions into the
503 * sub_action. If so, mark it as hasRowSecurity, whether or not those
504 * RTEs will be referenced after we finish rewriting. (Note: currently
505 * this is a no-op because RLS conditions aren't added till later, but it
506 * seems like good future-proofing to do this anyway.)
507 */
508 sub_action->hasRowSecurity |= parsetree->hasRowSecurity;
509
510 /*
511 * Each rule action's jointree should be the main parsetree's jointree
512 * plus that rule's jointree, but usually *without* the original rtindex
513 * that we're replacing (if present, which it won't be for INSERT). Note
514 * that if the rule action refers to OLD, its jointree will add a
515 * reference to rt_index. If the rule action doesn't refer to OLD, but
516 * either the rule_qual or the user query quals do, then we need to keep
517 * the original rtindex in the jointree to provide data for the quals. We
518 * don't want the original rtindex to be joined twice, however, so avoid
519 * keeping it if the rule action mentions it.
520 *
521 * As above, the action's jointree must not share substructure with the
522 * main parsetree's.
523 */
525 {
526 bool keeporig;
528
531 rt_index, 0)) &&
536 {
537 /*
538 * If sub_action is a setop, manipulating its jointree will do no
539 * good at all, because the jointree is dummy. (Perhaps someday
540 * we could push the joining and quals down to the member
541 * statements of the setop?)
542 */
547
548 sub_action->jointree->fromlist =
550
551 /*
552 * There could have been some SubLinks in newjointree, in which
553 * case we'd better mark the sub_action correctly.
554 */
556 sub_action->hasSubLinks =
558 }
559 }
560
561 /*
562 * If the original query has any CTEs, copy them into the rule action. But
563 * we don't need them for a utility action.
564 */
566 {
567 /*
568 * Annoying implementation restriction: because CTEs are identified by
569 * name within a cteList, we can't merge a CTE from the original query
570 * if it has the same name as any CTE in the rule action.
571 *
572 * This could possibly be fixed by using some sort of internally
573 * generated ID, instead of names, to link CTE RTEs to their CTEs.
574 * However, decompiling the results would be quite confusing; note the
575 * merge of hasRecursive flags below, which could change the apparent
576 * semantics of such redundantly-named CTEs.
577 */
579 {
582
584 {
586
591 cte->ctename)));
592 }
593 }
594
595 /*
596 * OK, it's safe to combine the CTE lists. Beware that RewriteQuery
597 * knows we concatenate the lists in this order.
598 */
601 /* ... and don't forget about the associated flags */
602 sub_action->hasRecursive |= parsetree->hasRecursive;
603 sub_action->hasModifyingCTE |= parsetree->hasModifyingCTE;
604
605 /*
606 * If rule_action is different from sub_action (i.e., the rule action
607 * is an INSERT...SELECT), then we might have just added some
608 * data-modifying CTEs that are not at the top query level. This is
609 * disallowed by the parser and we mustn't generate such trees here
610 * either, so throw an error.
611 *
612 * Conceivably such cases could be supported by attaching the original
613 * query's CTEs to rule_action not sub_action. But to do that, we'd
614 * have to increment ctelevelsup in RTEs and SubLinks copied from the
615 * original query. For now, it doesn't seem worth the trouble.
616 */
620 errmsg("INSERT ... SELECT rule actions are not supported for queries having data-modifying statements in WITH")));
621 }
622
623 /*
624 * Event Qualification forces copying of parsetree and splitting into two
625 * queries one w/rule_qual, one w/NOT rule_qual. Also add user query qual
626 * onto rule action
627 */
629
631
632 /*
633 * Rewrite new.attribute with right hand side of target-list entry for
634 * appropriate field name in insert/update.
635 *
636 * KLUGE ALERT: since ReplaceVarsFromTargetList returns a mutated copy, we
637 * can't just apply it to sub_action; we have to remember to update the
638 * sublink inside rule_action, too.
639 */
642 {
645 new_varno,
646 0,
648 parsetree->targetList,
649 sub_action->resultRelation,
651 REPLACEVARS_CHANGE_VARNO :
653 current_varno,
654 NULL);
657 else
659 }
660
661 /*
662 * If rule_action has a RETURNING clause, then either throw it away if the
663 * triggering query has no RETURNING clause, or rewrite it to emit what
664 * the triggering query's RETURNING clause asks for. Throw an error if
665 * more than one rule has a RETURNING clause.
666 */
670 {
678 parsetree->resultRelation,
679 0,
680 rt_fetch(parsetree->resultRelation,
681 parsetree->rtable),
683 rule_action->resultRelation,
685 0,
686 &rule_action->hasSubLinks);
687
688 /* use triggering query's aliases for OLD and NEW in RETURNING list */
689 rule_action->returningOldAlias = parsetree->returningOldAlias;
690 rule_action->returningNewAlias = parsetree->returningNewAlias;
691
692 /*
693 * There could have been some SubLinks in parsetree's returningList,
694 * in which case we'd better mark the rule_action correctly.
695 */
697 rule_action->hasSubLinks =
699 }
700
702}
static List * adjustJoinTreeList(Query *parsetree, bool removert, int rt_index)
Definition rewriteHandler.c:713
void OffsetVarNodes(Node *node, int offset, int sublevels_up)
Definition rewriteManip.c:476
void CombineRangeTables(List **dst_rtable, List **dst_perminfos, List *src_rtable, List *src_perminfos)
Definition rewriteManip.c:347
Query * getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr)
Definition rewriteManip.c:1090
References acquireLocksOnSubLinks(), AcquireRewriteLocks(), AddQual(), adjustJoinTreeList(), Assert, ChangeVarNodes(), checkExprHasSubLink(), CMD_INSERT, CMD_UPDATE, CMD_UTILITY, CombineRangeTables(), contain_vars_of_level(), copyObject, Query::cteList, CommonTableExpr::ctename, ereport, errcode(), errmsg(), ERROR, fb(), acquireLocksOnSubLinks_context::for_execute, getInsertSelectQuery(), Query::jointree, lfirst, list_concat(), list_length(), NIL, OffsetVarNodes(), PRS2_NEW_VARNO, PRS2_OLD_VARNO, FromExpr::quals, rangeTableEntry_used(), REPLACEVARS_CHANGE_VARNO, REPLACEVARS_REPORT_ERROR, REPLACEVARS_SUBSTITUTE_NULL, ReplaceVarsFromTargetList(), Query::returningList, rt_fetch, Query::rtable, RTE_FUNCTION, RTE_RELATION, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, and Query::targetList.
Referenced by fireRules().
◆ rewriteTargetListIU()
|
static |
Definition at line 775 of file rewriteHandler.c.
782{
788 next_junk_attrno,
789 numattrs;
792
793 /*
794 * We process the normal (non-junk) attributes by scanning the input tlist
795 * once and transferring TLEs into an array, then scanning the array to
796 * build an output tlist. This avoids O(N^2) behavior for large numbers
797 * of attributes.
798 *
799 * Junk attributes are tossed into a separate list during the same tlist
800 * scan, then appended to the reconstructed tlist.
801 */
805
807 {
809
811 {
812 /* Normal attr: stash it into new_tles[] */
817
818 /* We can (and must) ignore deleted attributes */
820 continue;
821
822 /* Merge with any prior assignment to same attribute */
827 }
828 else
829 {
830 /*
831 * Copy all resjunk tlist entries to junk_tlist, and assign them
832 * resnos above the last real resno.
833 *
834 * Typical junk entries include ORDER BY or GROUP BY expressions
835 * (are these actually possible in an INSERT or UPDATE?), system
836 * attribute references, etc.
837 */
838
839 /* Get the resno right, but don't copy unnecessarily */
841 {
844 }
846 next_junk_attrno++;
847 }
848 }
849
851 {
854
856
857 /* We can (and must) ignore deleted attributes */
859 continue;
860
861 /*
862 * Handle the two cases where we need to insert a default expression:
863 * it's an INSERT and there's no tlist entry for the column, or the
864 * tlist entry is a DEFAULT placeholder node.
865 */
868
870 {
872
873 /* Source attribute number for values that come from a VALUES RTE */
875 {
877
879 values_attrno = var->varattno;
880 }
881
882 /*
883 * Can only insert DEFAULT into GENERATED ALWAYS identity columns,
884 * unless either OVERRIDING USER VALUE or OVERRIDING SYSTEM VALUE
885 * is specified.
886 */
888 {
892 {
893 /*
894 * If this column's values come from a VALUES RTE, test
895 * whether it contains only SetToDefault items. Since the
896 * VALUES list might be quite large, we arrange to only
897 * scan it once.
898 */
900 {
903
906 }
907
916 }
917 }
918
919 /*
920 * Although inserting into a GENERATED BY DEFAULT identity column
921 * is allowed, apply the default if OVERRIDING USER VALUE is
922 * specified.
923 */
927
928 /*
929 * Can only insert DEFAULT into generated columns. (The
930 * OVERRIDING clause does not apply to generated columns, so we
931 * don't consider it here.)
932 */
934 {
935 /*
936 * If this column's values come from a VALUES RTE, test
937 * whether it contains only SetToDefault items, as above.
938 */
940 {
943
946 }
947
955 }
956
957 /*
958 * For an INSERT from a VALUES RTE, return the attribute numbers
959 * of any VALUES columns that will no longer be used (due to the
960 * targetlist entry being replaced by a default expression).
961 */
964 values_attrno);
965 }
966
967 /*
968 * Updates to identity and generated columns follow the same rules as
969 * above, except that UPDATE doesn't admit OVERRIDING clauses. Also,
970 * the source can't be a VALUES RTE, so we needn't consider that.
971 */
973 {
982
990 }
991
993 {
994 /*
995 * virtual generated column stores a null value; stored generated
996 * column will be fixed in executor
997 */
999 }
1001 {
1003
1005
1006 /*
1007 * If there is no default (ie, default is effectively NULL), we
1008 * can omit the tlist entry in the INSERT case, since the planner
1009 * can insert a NULL for itself, and there's no point in spending
1010 * any more rewriter cycles on the entry. But in the UPDATE case
1011 * we've got to explicitly set the column to NULL.
1012 */
1014 {
1017 else
1019 att_tup->atttypmod,
1020 att_tup->attcollation,
1021 att_tup->attlen,
1022 att_tup->attbyval);
1023 }
1024
1027 attrno,
1029 false);
1030 }
1031
1034 }
1035
1037
1039}
Node * coerce_null_to_domain(Oid typid, int32 typmod, Oid collation, int typlen, bool typbyval)
Definition parse_coerce.c:1272
static TargetEntry * process_matched_tle(TargetEntry *src_tle, TargetEntry *prior_tle, const char *attrName)
Definition rewriteHandler.c:1049
static Bitmapset * findDefaultOnlyColumns(RangeTblEntry *rte)
Definition rewriteHandler.c:1328
References bms_add_member(), bms_is_member(), build_column_default(), CMD_INSERT, CMD_UPDATE, coerce_null_to_domain(), elog, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, fb(), findDefaultOnlyColumns(), flatCopyTargetEntry(), IsA, lappend(), lfirst, list_concat(), makeTargetEntry(), NameStr, NIL, OVERRIDING_SYSTEM_VALUE, OVERRIDING_USER_VALUE, palloc0(), pfree(), process_matched_tle(), pstrdup(), RelationGetNumberOfAttributes, TargetEntry::resno, TupleDescAttr(), Var::varattno, and Var::varno.
Referenced by RewriteQuery().
◆ rewriteTargetView()
Definition at line 3217 of file rewriteHandler.c.
3218{
3234
3235 /*
3236 * Get the Query from the view's ON SELECT rule. We're going to munge the
3237 * Query to change the view's base relation into the target relation,
3238 * along with various other changes along the way, so we need to make a
3239 * copy of it (get_view_query() returns a pointer into the relcache, so we
3240 * have to treat it as read-only).
3241 */
3243
3244 /* Locate RTE and perminfo describing the view in the outer query */
3247
3248 /*
3249 * Are we doing INSERT/UPDATE, or MERGE containing INSERT/UPDATE? If so,
3250 * various additional checks on the view columns need to be applied, and
3251 * any view CHECK OPTIONs need to be enforced.
3252 */
3253 insert_or_update =
3256
3258 {
3260 {
3263 {
3265 break;
3266 }
3267 }
3268 }
3269
3270 /* Check if the expansion of non-system views are restricted */
3276 RelationGetRelationName(view))));
3277
3278 /*
3279 * The view must be updatable, else fail.
3280 *
3281 * If we are doing INSERT/UPDATE (or MERGE containing INSERT/UPDATE), we
3282 * also check that there is at least one updatable column.
3283 */
3284 auto_update_detail =
3286
3288 error_view_not_updatable(view,
3289 parsetree->commandType,
3290 parsetree->mergeActionList,
3291 auto_update_detail);
3292
3293 /*
3294 * For INSERT/UPDATE (or MERGE containing INSERT/UPDATE) the modified
3295 * columns must all be updatable.
3296 */
3298 {
3301
3302 /*
3303 * Compute the set of modified columns as those listed in the result
3304 * RTE's insertedCols and/or updatedCols sets plus those that are
3305 * targets of the query's targetlist(s). We must consider the query's
3306 * targetlist because rewriteTargetListIU may have added additional
3307 * targetlist entries for view defaults, and these must also be
3308 * updatable. But rewriteTargetListIU can also remove entries if they
3309 * are DEFAULT markers and the column's default is NULL, so
3310 * considering only the targetlist would also be wrong.
3311 */
3313 view_perminfo->updatedCols);
3314
3316 {
3318
3322 }
3323
3325 {
3327 {
3329
3333 }
3334 }
3335
3337 {
3340 {
3342 {
3346 }
3347 }
3348 }
3349
3351 modified_cols,
3352 NULL,
3353 &non_updatable_col);
3355 {
3356 /*
3357 * This is a different error, caused by an attempt to update a
3358 * non-updatable column in an otherwise updatable view.
3359 */
3361 {
3366 non_updatable_col,
3367 RelationGetRelationName(view)),
3369 break;
3374 non_updatable_col,
3375 RelationGetRelationName(view)),
3377 break;
3382 non_updatable_col,
3383 RelationGetRelationName(view)),
3385 break;
3386 default:
3389 break;
3390 }
3391 }
3392 }
3393
3394 /*
3395 * For MERGE, there must not be any INSTEAD OF triggers on an otherwise
3396 * updatable view. The caller already checked that there isn't a full set
3397 * of INSTEAD OF triggers, so this is to guard against having a partial
3398 * set (mixing auto-update and trigger-update actions in a single command
3399 * isn't supported).
3400 */
3402 {
3404 {
3410 RelationGetRelationName(view)),
3411 errdetail("MERGE is not supported for views with INSTEAD OF triggers for some actions but not all."),
3412 errhint("To enable merging into the view, either provide a full set of INSTEAD OF triggers or drop the existing INSTEAD OF triggers."));
3413 }
3414 }
3415
3416 /*
3417 * If we get here, view_query_is_auto_updatable() has verified that the
3418 * view contains a single base relation.
3419 */
3422
3427
3428 /*
3429 * Up to now, the base relation hasn't been touched at all in our query.
3430 * We need to acquire lock on it before we try to do anything with it.
3431 * (The subsequent recursive call of RewriteQuery will suppose that we
3432 * already have the right lock!) Since it will become the query target
3433 * relation, RowExclusiveLock is always the right thing.
3434 */
3436
3437 /*
3438 * While we have the relation open, update the RTE's relkind, just in case
3439 * it changed since this view was made (cf. AcquireRewriteLocks).
3440 */
3442
3443 /*
3444 * If the view query contains any sublink subqueries then we need to also
3445 * acquire locks on any relations they refer to. We know that there won't
3446 * be any subqueries in the range table or CTEs, so we can skip those, as
3447 * in AcquireRewriteLocks.
3448 */
3450 {
3451 acquireLocksOnSubLinks_context context;
3452
3455 QTW_IGNORE_RC_SUBQUERIES);
3456 }
3457
3458 /*
3459 * Create a new target RTE describing the base relation, and add it to the
3460 * outer query's rangetable. (What's happening in the next few steps is
3461 * very much like what the planner would do to "pull up" the view into the
3462 * outer query. Perhaps someday we should refactor things enough so that
3463 * we can share code with the planner.)
3464 *
3465 * Be sure to set rellockmode to the correct thing for the target table.
3466 * Since we copied the whole viewquery above, we can just scribble on
3467 * base_rte instead of copying it.
3468 */
3471
3474
3475 /*
3476 * INSERTs never inherit. For UPDATE/DELETE/MERGE, we use the view
3477 * query's inheritance flag for the base relation.
3478 */
3481
3482 /*
3483 * Adjust the view's targetlist Vars to reference the new target RTE, ie
3484 * make their varnos be new_rt_index instead of base_rt_index. There can
3485 * be no Vars for other rels in the tlist, so this is sufficient to pull
3486 * up the tlist expressions for use in the outer query. The tlist will
3487 * provide the replacement expressions used by ReplaceVarsFromTargetList
3488 * below.
3489 */
3491
3493 base_rt_index,
3494 new_rt_index,
3495 0);
3496
3497 /*
3498 * If the view has "security_invoker" set, mark the new target relation
3499 * for the permissions checks that we want to enforce against the query
3500 * caller. Otherwise we want to enforce them against the view owner.
3501 *
3502 * At the relation level, require the same INSERT/UPDATE/DELETE
3503 * permissions that the query caller needs against the view. We drop the
3504 * ACL_SELECT bit that is presumably in new_perminfo->requiredPerms
3505 * initially.
3506 *
3507 * Note: the original view's RTEPermissionInfo remains in the query's
3508 * rteperminfos so that the executor still performs appropriate
3509 * permissions checks for the query caller's use of the view.
3510 *
3511 * Disregard the perminfo in viewquery->rteperminfos that the base_rte
3512 * would currently be pointing at, because we'd like it to point now to a
3513 * new one that will be filled below. Must set perminfoindex to 0 to not
3514 * trip over the Assert in addRTEPermissionInfo().
3515 */
3516 new_rte->perminfoindex = 0;
3520 else
3523
3524 /*
3525 * Now for the per-column permissions bits.
3526 *
3527 * Initially, new_perminfo (base_perminfo) contains selectedCols
3528 * permission check bits for all base-rel columns referenced by the view,
3529 * but since the view is a SELECT query its insertedCols/updatedCols is
3530 * empty. We set insertedCols and updatedCols to include all the columns
3531 * the outer query is trying to modify, adjusting the column numbers as
3532 * needed. But we leave selectedCols as-is, so the view owner must have
3533 * read permission for all columns used in the view definition, even if
3534 * some of them are not read by the outer query. We could try to limit
3535 * selectedCols to only columns used in the transformed query, but that
3536 * does not correspond to what happens in ordinary SELECT usage of a view:
3537 * all referenced columns must have read permission, even if optimization
3538 * finds that some of them can be discarded during query transformation.
3539 * The flattening we're doing here is an optional optimization, too. (If
3540 * you are unpersuaded and want to change this, note that applying
3541 * adjust_view_column_set to view_perminfo->selectedCols is clearly *not*
3542 * the right answer, since that neglects base-rel columns used in the
3543 * view's WHERE quals.)
3544 *
3545 * This step needs the modified view targetlist, so we have to do things
3546 * in this order.
3547 */
3550
3552
3553 new_perminfo->insertedCols =
3555
3556 new_perminfo->updatedCols =
3558
3559 /*
3560 * Move any security barrier quals from the view RTE onto the new target
3561 * RTE. Any such quals should now apply to the new target RTE and will
3562 * not reference the original view RTE in the rewritten query.
3563 */
3566
3567 /*
3568 * Now update all Vars in the outer query that reference the view to
3569 * reference the appropriate column of the base relation instead.
3570 */
3571 parsetree = (Query *)
3573 parsetree->resultRelation,
3574 0,
3575 view_rte,
3576 view_targetlist,
3577 new_rt_index,
3578 REPLACEVARS_REPORT_ERROR,
3579 0,
3580 NULL);
3581
3582 /*
3583 * Update all other RTI references in the query that point to the view
3584 * (for example, parsetree->resultRelation itself) to point to the new
3585 * base relation instead. Vars will not be affected since none of them
3586 * reference parsetree->resultRelation any longer.
3587 */
3589 parsetree->resultRelation,
3590 new_rt_index,
3591 0);
3593
3594 /*
3595 * For INSERT/UPDATE we must also update resnos in the targetlist to refer
3596 * to columns of the base relation, since those indicate the target
3597 * columns to be affected. Similarly, for MERGE we must update the resnos
3598 * in the merge action targetlists of any INSERT/UPDATE actions.
3599 *
3600 * Note that this destroys the resno ordering of the targetlists, but that
3601 * will be fixed when we recurse through RewriteQuery, which will invoke
3602 * rewriteTargetListIU again on the updated targetlists.
3603 */
3605 {
3607 {
3610
3612 continue;
3613
3617 else
3619 tle->resno);
3620 }
3621
3623 {
3626 {
3628 {
3630
3632 continue;
3633
3637 else
3639 tle->resno);
3640 }
3641 }
3642 }
3643 }
3644
3645 /*
3646 * For INSERT .. ON CONFLICT .. DO UPDATE, we must also update assorted
3647 * stuff in the onConflict data structure.
3648 */
3651 {
3653 new_exclRelIndex;
3657
3658 /*
3659 * Like the INSERT/UPDATE code above, update the resnos in the
3660 * auxiliary UPDATE targetlist to refer to columns of the base
3661 * relation.
3662 */
3664 {
3667
3669 continue;
3670
3674 else
3676 tle->resno);
3677 }
3678
3679 /*
3680 * Also, create a new RTE for the EXCLUDED pseudo-relation, using the
3681 * query's new base rel (which may well have a different column list
3682 * from the view, hence we need a new column alias list). This should
3683 * match transformOnConflictClause. In particular, note that the
3684 * relkind is set to composite to signal that we're not dealing with
3685 * an actual relation.
3686 */
3688
3690 base_rel,
3691 RowExclusiveLock,
3693 false, false);
3696 /* Ignore the RTEPermissionInfo that would've been added. */
3697 new_exclRte->perminfoindex = 0;
3698
3702
3703 /*
3704 * Replace the targetlist for the EXCLUDED pseudo-relation with a new
3705 * one, representing the columns from the new base relation.
3706 */
3709
3710 /*
3711 * Update all Vars in the ON CONFLICT clause that refer to the old
3712 * EXCLUDED pseudo-relation. We want to use the column mappings
3713 * defined in the view targetlist, but we need the outputs to refer to
3714 * the new EXCLUDED pseudo-relation rather than the new target RTE.
3715 * Also notice that "EXCLUDED.*" will be expanded using the view's
3716 * rowtype, which seems correct.
3717 */
3719
3721 new_exclRelIndex, 0);
3722
3725 old_exclRelIndex,
3726 0,
3727 view_rte,
3728 tmp_tlist,
3729 new_rt_index,
3730 REPLACEVARS_REPORT_ERROR,
3731 0,
3732 &parsetree->hasSubLinks);
3733 }
3734
3735 /*
3736 * For UPDATE/DELETE/MERGE, pull up any WHERE quals from the view. We
3737 * know that any Vars in the quals must reference the one base relation,
3738 * so we need only adjust their varnos to reference the new target (just
3739 * the same as we did with the view targetlist).
3740 *
3741 * If it's a security-barrier view, its WHERE quals must be applied before
3742 * quals from the outer query, so we attach them to the RTE as security
3743 * barrier quals rather than adding them to the main WHERE clause.
3744 *
3745 * For INSERT, the view's quals can be ignored in the main query.
3746 */
3749 {
3751
3752 /*
3753 * Even though we copied viewquery already at the top of this
3754 * function, we must duplicate the viewqual again here, because we may
3755 * need to use the quals again below for a WithCheckOption clause.
3756 */
3758
3760
3762 {
3763 /*
3764 * The view's quals go in front of existing barrier quals: those
3765 * would have come from an outer level of security-barrier view,
3766 * and so must get evaluated later.
3767 *
3768 * Note: the parsetree has been mutated, so the new_rte pointer is
3769 * stale and needs to be re-computed.
3770 */
3773
3774 /*
3775 * Do not set parsetree->hasRowSecurity, because these aren't RLS
3776 * conditions (they aren't affected by enabling/disabling RLS).
3777 */
3778
3779 /*
3780 * Make sure that the query is marked correctly if the added qual
3781 * has sublinks.
3782 */
3783 if (!parsetree->hasSubLinks)
3785 }
3786 else
3788 }
3789
3790 /*
3791 * For INSERT/UPDATE (or MERGE containing INSERT/UPDATE), if the view has
3792 * the WITH CHECK OPTION, or any parent view specified WITH CASCADED CHECK
3793 * OPTION, add the quals from the view to the query's withCheckOptions
3794 * list.
3795 */
3797 {
3800
3801 /*
3802 * If the parent view has a cascaded check option, treat this view as
3803 * if it also had a cascaded check option.
3804 *
3805 * New WithCheckOptions are added to the start of the list, so if
3806 * there is a cascaded check option, it will be the first item in the
3807 * list.
3808 */
3810 {
3813
3815 {
3817 cascaded = true;
3818 }
3819 }
3820
3821 /*
3822 * Add the new WithCheckOption to the start of the list, so that
3823 * checks on inner views are run before checks on outer views, as
3824 * required by the SQL standard.
3825 *
3826 * If the new check is CASCADED, we need to add it even if this view
3827 * has no quals, since there may be quals on child views. A LOCAL
3828 * check can be omitted if this view has no quals.
3829 */
3831 {
3833
3839 wco->cascaded = cascaded;
3840
3842 parsetree->withCheckOptions);
3843
3845 {
3848
3849 /*
3850 * For INSERT, make sure that the query is marked correctly if
3851 * the added qual has sublinks. This can be skipped for
3852 * UPDATE/MERGE, since the same qual will have already been
3853 * added above, and the check will already have been done.
3854 */
3855 if (!parsetree->hasSubLinks &&
3858 }
3859 }
3860 }
3861
3863
3864 return parsetree;
3865}
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
Definition parse_relation.c:1580
RTEPermissionInfo * addRTEPermissionInfo(List **rteperminfos, RangeTblEntry *rte)
Definition parse_relation.c:3929
List * BuildOnConflictExcludedTargetlist(Relation targetrel, Index exclRelIndex)
Definition analyze.c:1281
Definition primnodes.h:2371
Definition parse_node.h:293
Definition parsenodes.h:1426
References _, acquireLocksOnSubLinks(), OnConflictExpr::action, AddQual(), addRangeTableEntryForRelation(), addRTEPermissionInfo(), adjust_view_column_set(), Assert, bms_add_member(), bms_is_empty, bms_union(), BuildOnConflictExcludedTargetlist(), ChangeVarNodes(), checkExprHasSubLink(), CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_UPDATE, Query::commandType, copyObject, elog, ereport, errcode(), errdetail(), errdetail_internal(), errhint(), errmsg(), ERROR, error_view_not_updatable(), OnConflictExpr::exclRelIndex, OnConflictExpr::exclRelTlist, fb(), FirstLowInvalidHeapAttributeNumber, FirstNormalObjectId, acquireLocksOnSubLinks_context::for_execute, foreach_node, get_tle_by_resno(), get_view_query(), getRTEPermissionInfo(), InvalidOid, IsA, lappend(), lcons(), lfirst, linitial, linitial_node, list_length(), make_parsestate(), makeAlias(), makeNode, Query::mergeActionList, NIL, NoLock, Query::onConflict, ONCONFLICT_UPDATE, OnConflictExpr::onConflictSet, pstrdup(), QTW_IGNORE_RC_SUBQUERIES, query_tree_walker, RelationData::rd_rel, RelationGetRelationName, RelationGetRelid, RelationHasCascadedCheckOption, RelationHasCheckOption, RelationHasSecurityInvoker, RelationIsSecurityView, REPLACEVARS_REPORT_ERROR, ReplaceVarsFromTargetList(), restrict_nonsystem_relation_kind, RESTRICT_RELKIND_VIEW, RowExclusiveLock, rt_fetch, Query::rtable, RTE_RELATION, table_close(), table_open(), Query::targetList, unlikely, view_cols_are_auto_updatable(), view_has_instead_trigger(), view_query_is_auto_updatable(), and WCO_VIEW_CHECK.
Referenced by RewriteQuery().
◆ rewriteValuesRTE()
|
static |
Definition at line 1416 of file rewriteHandler.c.
1419{
1426
1427 /* Steps below are not sensible for non-INSERT queries */
1430
1431 /*
1432 * Rebuilding all the lists is a pretty expensive proposition in a big
1433 * VALUES list, and it's a waste of time if there aren't any DEFAULT
1434 * placeholders. So first scan to see if there are any.
1435 */
1437 return true; /* nothing to do */
1438
1439 /*
1440 * Scan the targetlist for entries referring to the VALUES RTE, and note
1441 * the target attributes. As noted above, we should only need to do this
1442 * for targetlist entries containing simple Vars --- nothing else in the
1443 * VALUES RTE should contain DEFAULT items (except possibly for unused
1444 * columns), and we complain if such a thing does occur.
1445 */
1448
1450 {
1452
1454 {
1456
1457 if (var->varno == rti)
1458 {
1460
1463 }
1464 }
1465 }
1466
1467 /*
1468 * Check if the target relation is an auto-updatable view, in which case
1469 * unresolved defaults will be left untouched rather than being set to
1470 * NULL.
1471 */
1475 {
1476 List *locks;
1478 bool found;
1479 ListCell *l;
1480
1481 /* Look for an unconditional DO INSTEAD rule */
1483 parsetree->resultRelation, parsetree, &hasUpdate);
1484
1485 found = false;
1486 foreach(l, locks)
1487 {
1489
1492 {
1493 found = true;
1494 break;
1495 }
1496 }
1497
1498 /*
1499 * If we didn't find an unconditional DO INSTEAD rule, assume that the
1500 * view is auto-updatable. If it isn't, rewriteTargetView() will
1501 * throw an error.
1502 */
1503 if (!found)
1505 }
1506
1510 {
1515
1517
1518 i = 0;
1520 {
1523
1525 {
1528
1529 /*
1530 * If this column isn't used, just replace the DEFAULT with
1531 * NULL (attrno will be 0 in this case because the targetlist
1532 * entry will have been replaced by the default expression).
1533 */
1535 {
1537
1540 def->typeMod,
1541 def->collation));
1542 continue;
1543 }
1544
1549
1552 else
1554
1555 /*
1556 * If there is no default (ie, default is effectively NULL),
1557 * we've got to explicitly set the column to NULL, unless the
1558 * target relation is an auto-updatable view.
1559 */
1561 {
1563 {
1564 /* Leave the value untouched */
1567 continue;
1568 }
1569
1571 att_tup->atttypmod,
1572 att_tup->attcollation,
1573 att_tup->attlen,
1574 att_tup->attbyval);
1575 }
1577 }
1578 else
1580 }
1582 }
1584
1586
1588}
Const * makeNullConst(Oid consttype, int32 consttypmod, Oid constcollid)
Definition makefuncs.c:388
References Assert, bms_is_member(), build_column_default(), CMD_INSERT, coerce_null_to_domain(), Query::commandType, elog, ERROR, fb(), i, IsA, lappend(), lfirst, linitial, list_length(), makeNullConst(), matchLocks(), NIL, palloc0(), pfree(), RTE_VALUES, searchForDefault(), Query::targetList, TupleDescAttr(), SetToDefault::typeId, Var::varattno, Var::varno, and view_has_instead_trigger().
Referenced by RewriteQuery().
◆ rewriteValuesRTEToNulls()
|
static |
Definition at line 1601 of file rewriteHandler.c.
1602{
1605
1608 {
1612
1614 {
1616
1618 {
1620
1622 def->typeMod,
1623 def->collation));
1624 }
1625 else
1627 }
1629 }
1631}
References fb(), IsA, lappend(), lfirst, makeNullConst(), NIL, and SetToDefault::typeId.
Referenced by RewriteQuery().
◆ searchForDefault()
|
static |
Definition at line 1302 of file rewriteHandler.c.
1303{
1305
1307 {
1310
1312 {
1314
1316 return true;
1317 }
1318 }
1319 return false;
1320}
References fb(), IsA, and lfirst.
Referenced by rewriteValuesRTE().
◆ view_col_is_auto_updatable()
|
static |
Definition at line 2588 of file rewriteHandler.c.
2589{
2591
2592 /*
2593 * For now, the only updatable columns we support are those that are Vars
2594 * referring to user columns of the underlying base relation.
2595 *
2596 * The view targetlist may contain resjunk columns (e.g., a view defined
2597 * like "SELECT * FROM t ORDER BY a+b" is auto-updatable) but such columns
2598 * are not auto-updatable, and in fact should never appear in the outer
2599 * query's targetlist.
2600 */
2603
2605 var->varno != rtr->rtindex ||
2606 var->varlevelsup != 0)
2607 return gettext_noop("View columns that are not columns of their base relation are not updatable.");
2608
2609 if (var->varattno < 0)
2611
2612 if (var->varattno == 0)
2614
2616}
References fb(), gettext_noop, IsA, Var::varattno, Var::varlevelsup, and Var::varno.
Referenced by view_cols_are_auto_updatable(), and view_query_is_auto_updatable().
◆ view_cols_are_auto_updatable()
|
static |
Definition at line 2784 of file rewriteHandler.c.
2788{
2791 ListCell *cell;
2792
2793 /*
2794 * The caller should have verified that this view is auto-updatable and so
2795 * there should be a single base relation.
2796 */
2799
2800 /* Initialize the optional return values */
2805
2806 /* Test each view column for updatability */
2809 {
2812
2813 col++;
2815
2817 {
2818 /* The column is updatable */
2821 }
2823 {
2824 /* The required column is not updatable */
2828 }
2829 }
2830
2832}
static const char * view_col_is_auto_updatable(RangeTblRef *rtr, TargetEntry *tle)
Definition rewriteHandler.c:2588
References Assert, bms_add_member(), bms_is_member(), fb(), FirstLowInvalidHeapAttributeNumber, lfirst, linitial_node, list_length(), and view_col_is_auto_updatable().
Referenced by relation_is_updatable(), and rewriteTargetView().
◆ view_has_instead_trigger()
Definition at line 2524 of file rewriteHandler.c.
2525{
2527
2528 switch (event)
2529 {
2532 return true;
2533 break;
2536 return true;
2537 break;
2540 return true;
2541 break;
2544 {
2546 {
2549 return false;
2550 break;
2553 return false;
2554 break;
2557 return false;
2558 break;
2560 /* No trigger required */
2561 break;
2562 default:
2564 break;
2565 }
2566 }
2567 return true; /* no actions without an INSTEAD OF trigger */
2568 default:
2570 break;
2571 }
2572 return false;
2573}
References CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_UPDATE, elog, ERROR, fb(), foreach_node, and RelationData::trigdesc.
Referenced by CheckValidResultRel(), RewriteQuery(), rewriteTargetView(), and rewriteValuesRTE().
◆ view_query_is_auto_updatable()
Definition at line 2636 of file rewriteHandler.c.
2637{
2640
2641 /*----------
2642 * Check if the view is simply updatable. According to SQL-92 this means:
2643 * - No DISTINCT clause.
2644 * - Each TLE is a column reference, and each column appears at most once.
2645 * - FROM contains exactly one base relation.
2646 * - No GROUP BY or HAVING clauses.
2647 * - No set operations (UNION, INTERSECT or EXCEPT).
2648 * - No sub-queries in the WHERE clause that reference the target table.
2649 *
2650 * We ignore that last restriction since it would be complex to enforce
2651 * and there isn't any actual benefit to disallowing sub-queries. (The
2652 * semantic issues that the standard is presumably concerned about don't
2653 * arise in Postgres, since any such sub-query will not see any updates
2654 * executed by the outer query anyway, thanks to MVCC snapshotting.)
2655 *
2656 * We also relax the second restriction by supporting part of SQL:1999
2657 * feature T111, which allows for a mix of updatable and non-updatable
2658 * columns, provided that an INSERT or UPDATE doesn't attempt to assign to
2659 * a non-updatable column.
2660 *
2661 * In addition we impose these constraints, involving features that are
2662 * not part of SQL-92:
2663 * - No CTEs (WITH clauses).
2664 * - No OFFSET or LIMIT clauses (this matches a SQL:2008 restriction).
2665 * - No system columns (including whole-row references) in the tlist.
2666 * - No window functions in the tlist.
2667 * - No set-returning functions in the tlist.
2668 *
2669 * Note that we do these checks without recursively expanding the view.
2670 * If the base relation is a view, we'll recursively deal with it later.
2671 *----------
2672 */
2675
2678
2681
2683 return gettext_noop("Views containing UNION, INTERSECT, or EXCEPT are not automatically updatable.");
2684
2687
2690
2691 /*
2692 * We must not allow window functions or set returning functions in the
2693 * targetlist. Otherwise we might end up inserting them into the quals of
2694 * the main query. We must also check for aggregates in the targetlist in
2695 * case they appear without a GROUP BY.
2696 *
2697 * These restrictions ensure that each row of the view corresponds to a
2698 * unique row in the underlying base relation.
2699 */
2702
2705
2707 return gettext_noop("Views that return set-returning functions are not automatically updatable.");
2708
2709 /*
2710 * The view query should select from a single base relation, which must be
2711 * a table or another view.
2712 */
2714 return gettext_noop("Views that do not select from a single table or view are not automatically updatable.");
2715
2718 return gettext_noop("Views that do not select from a single table or view are not automatically updatable.");
2719
2726 return gettext_noop("Views that do not select from a single table or view are not automatically updatable.");
2727
2730
2731 /*
2732 * Check that the view has at least one updatable column. This is required
2733 * for INSERT/UPDATE but not for DELETE.
2734 */
2736 {
2737 ListCell *cell;
2738 bool found;
2739
2740 found = false;
2742 {
2744
2746 {
2747 found = true;
2748 break;
2749 }
2750 }
2751
2752 if (!found)
2754 }
2755
2757}
References fb(), gettext_noop, IsA, lfirst, linitial, list_length(), NIL, rt_fetch, RTE_RELATION, and view_col_is_auto_updatable().
Referenced by ATExecSetRelOptions(), DefineView(), relation_is_updatable(), and rewriteTargetView().
