Loading...
Searching...
No Matches
analyzejoins.c File Reference
#include "postgres.h"#include "catalog/pg_class.h"#include "nodes/nodeFuncs.h"#include "optimizer/joininfo.h"#include "optimizer/optimizer.h"#include "optimizer/pathnode.h"#include "optimizer/paths.h"#include "optimizer/placeholder.h"#include "optimizer/planmain.h"#include "optimizer/restrictinfo.h"#include "parser/parse_agg.h"#include "rewrite/rewriteManip.h"#include "utils/lsyscache.h"
Include dependency graph for analyzejoins.c:
Go to the source code of this file.
Data Structures | |
| struct | SelfJoinCandidate |
Variables | |
| bool | enable_self_join_elimination |
Function Documentation
◆ add_non_redundant_clauses()
|
static |
Definition at line 1873 of file analyzejoins.c.
1877{
1879 {
1881
1883
1885 {
1887 /* Can't compare trivially different clauses */
1888 continue;
1889
1890 if (src == rinfo ||
1891 (rinfo->parent_ec != NULL &&
1892 src->parent_ec == rinfo->parent_ec) ||
1893 restrict_infos_logically_equal(rinfo, src))
1894 {
1896 break;
1897 }
1898 }
1901 }
1902}
static bool restrict_infos_logically_equal(RestrictInfo *a, RestrictInfo *b)
Definition analyzejoins.c:1847
void distribute_restrictinfo_to_rels(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition initsplan.c:3629
Definition pathnodes.h:2895
References Assert, bms_equal(), bms_is_member(), distribute_restrictinfo_to_rels(), fb(), foreach_node, restrict_infos_logically_equal(), and root.
Referenced by remove_self_join_rel().
◆ distinct_col_search()
|
static |
Definition at line 1486 of file analyzejoins.c.
References fb(), and foreach_ptr.
Referenced by query_is_distinct_for().
◆ innerrel_is_unique()
| bool innerrel_is_unique | ( | PlannerInfo * | root, |
| Relids | joinrelids, | ||
| Relids | outerrelids, | ||
| RelOptInfo * | innerrel, | ||
| JoinType | jointype, | ||
| List * | restrictlist, | ||
| bool | force_cache | ||
| ) |
Definition at line 1524 of file analyzejoins.c.
1531{
1534}
bool innerrel_is_unique_ext(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache, List **extra_clauses)
Definition analyzejoins.c:1546
References fb(), innerrel_is_unique_ext(), and root.
Referenced by add_paths_to_joinrel(), and reduce_unique_semijoins().
◆ innerrel_is_unique_ext()
| bool innerrel_is_unique_ext | ( | PlannerInfo * | root, |
| Relids | joinrelids, | ||
| Relids | outerrelids, | ||
| RelOptInfo * | innerrel, | ||
| JoinType | jointype, | ||
| List * | restrictlist, | ||
| bool | force_cache, | ||
| List ** | extra_clauses | ||
| ) |
Definition at line 1546 of file analyzejoins.c.
1554{
1560
1561 /* Certainly can't prove uniqueness when there are no joinclauses */
1563 return false;
1564
1565 /*
1566 * Make a quick check to eliminate cases in which we will surely be unable
1567 * to prove uniqueness of the innerrel.
1568 */
1570 return false;
1571
1572 /*
1573 * Query the cache to see if we've managed to prove that innerrel is
1574 * unique for any subset of this outerrel. For non-self-join search, we
1575 * don't need an exact match, as extra outerrels can't make the innerrel
1576 * any less unique (or more formally, the restrictlist for a join to a
1577 * superset outerrel must be a superset of the conditions we successfully
1578 * used before). For self-join search, we require an exact match of
1579 * outerrels because we need extra clauses to be valid for our case. Also,
1580 * for self-join checking we've filtered the clauses list. Thus, we can
1581 * match only the result cached for a self-join search for another
1582 * self-join check.
1583 */
1585 {
1587
1590 uniqueRelInfo->self_join))
1591 {
1592 if (extra_clauses)
1593 *extra_clauses = uniqueRelInfo->extra_clauses;
1594 return true; /* Success! */
1595 }
1596 }
1597
1598 /*
1599 * Conversely, we may have already determined that this outerrel, or some
1600 * superset thereof, cannot prove this innerrel to be unique.
1601 */
1603 {
1605
1607 return false;
1608 }
1609
1610 /* No cached information, so try to make the proof. */
1612 jointype, restrictlist,
1614 {
1615 /*
1616 * Cache the positive result for future probes, being sure to keep it
1617 * in the planner_cxt even if we are working in GEQO.
1618 *
1619 * Note: one might consider trying to isolate the minimal subset of
1620 * the outerrels that proved the innerrel unique. But it's not worth
1621 * the trouble, because the planner builds up joinrels incrementally
1622 * and so we'll see the minimally sufficient outerrels before any
1623 * supersets of them anyway.
1624 */
1628 uniqueRelInfo->self_join = self_join;
1631 uniqueRelInfo);
1633
1634 if (extra_clauses)
1635 *extra_clauses = outer_exprs;
1636 return true; /* Success! */
1637 }
1638 else
1639 {
1640 /*
1641 * None of the join conditions for outerrel proved innerrel unique, so
1642 * we can safely reject this outerrel or any subset of it in future
1643 * checks.
1644 *
1645 * However, in normal planning mode, caching this knowledge is totally
1646 * pointless; it won't be queried again, because we build up joinrels
1647 * from smaller to larger. It's only useful when using GEQO or
1648 * another planner extension that attempts planning multiple times.
1649 *
1650 * Also, allow callers to override that heuristic and force caching;
1651 * that's useful for reduce_unique_semijoins, which calls here before
1652 * the normal join search starts.
1653 */
1655 {
1657 innerrel->non_unique_for_rels =
1659 bms_copy(outerrelids));
1661 }
1662
1663 return false;
1664 }
1665}
static bool is_innerrel_unique_for(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, List **extra_clauses)
Definition analyzejoins.c:1673
static bool rel_supports_distinctness(PlannerInfo *root, RelOptInfo *rel)
Definition analyzejoins.c:1118
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:138
Definition bitmapset.h:50
Definition pg_list.h:54
Definition memnodes.h:118
Definition pathnodes.h:3832
Definition pg_list.h:46
References bms_copy(), bms_equal(), bms_is_subset(), fb(), is_innerrel_unique_for(), lappend(), lfirst, makeNode, MemoryContextSwitchTo(), NIL, RelOptInfo::non_unique_for_rels, rel_supports_distinctness(), root, and RelOptInfo::unique_for_rels.
Referenced by innerrel_is_unique(), and remove_self_joins_one_group().
◆ is_innerrel_unique_for()
|
static |
Definition at line 1673 of file analyzejoins.c.
1680{
1683
1684 /*
1685 * Search for mergejoinable clauses that constrain the inner rel against
1686 * the outer rel. If an operator is mergejoinable then it behaves like
1687 * equality for some btree opclass, so it's what we want. The
1688 * mergejoinability test also eliminates clauses containing volatile
1689 * functions, which we couldn't depend on.
1690 */
1692 {
1694
1695 /*
1696 * As noted above, if it's a pushed-down clause and we're at an outer
1697 * join, we can't use it.
1698 */
1701 continue;
1702
1703 /* Ignore if it's not a mergejoinable clause */
1706 continue; /* not mergejoinable */
1707
1708 /*
1709 * Check if the clause has the form "outer op inner" or "inner op
1710 * outer", and if so mark which side is inner.
1711 */
1713 innerrel->relids))
1714 continue; /* no good for these input relations */
1715
1716 /* OK, add to the list */
1718 }
1719
1720 /* Let rel_is_distinct_for() do the hard work */
1722}
static bool rel_is_distinct_for(PlannerInfo *root, RelOptInfo *rel, List *clause_list, List **extra_clauses)
Definition analyzejoins.c:1178
static bool clause_sides_match_join(RestrictInfo *rinfo, Relids outerrelids, Relids innerrelids)
Definition restrictinfo.h:73
References clause_sides_match_join(), fb(), IS_OUTER_JOIN, lappend(), lfirst, NIL, rel_is_distinct_for(), RelOptInfo::relids, RINFO_IS_PUSHED_DOWN, and root.
Referenced by innerrel_is_unique_ext().
◆ join_is_removable()
|
static |
Definition at line 162 of file analyzejoins.c.
163{
165 RelOptInfo *innerrel;
169 ListCell *l;
171
172 /*
173 * Must be a left join to a single baserel, else we aren't going to be
174 * able to do anything with it.
175 */
177 return false;
178
180 return false;
181
182 /*
183 * Never try to eliminate a left join to the query result rel. Although
184 * the case is syntactically impossible in standard SQL, MERGE will build
185 * a join tree that looks exactly like that.
186 */
188 return false;
189
191
192 /*
193 * Before we go to the effort of checking whether any innerrel variables
194 * are needed above the join, make a quick check to eliminate cases in
195 * which we will surely be unable to prove uniqueness of the innerrel.
196 */
198 return false;
199
200 /* Compute the relid set for the join we are considering */
205
206 /*
207 * We can't remove the join if any inner-rel attributes are used above the
208 * join. Here, "above" the join includes pushed-down conditions, so we
209 * should reject if attr_needed includes the OJ's own relid; therefore,
210 * compare to inputrelids not joinrelids.
211 *
212 * As a micro-optimization, it seems better to start with max_attr and
213 * count down rather than starting with min_attr and counting up, on the
214 * theory that the system attributes are somewhat less likely to be wanted
215 * and should be tested last.
216 */
218 attroff >= 0;
219 attroff--)
220 {
222 return false;
223 }
224
225 /*
226 * Similarly check that the inner rel isn't needed by any PlaceHolderVars
227 * that will be used above the join. The PHV case is a little bit more
228 * complicated, because PHVs may have been assigned a ph_eval_at location
229 * that includes the innerrel, yet their contained expression might not
230 * actually reference the innerrel (it could be just a constant, for
231 * instance). If such a PHV is due to be evaluated above the join then it
232 * needn't prevent join removal.
233 */
235 {
237
239 return false; /* it references innerrel laterally */
241 continue; /* it definitely doesn't reference innerrel */
243 continue; /* PHV is not used above the join */
245 return false; /* it has to be evaluated below the join */
246
247 /*
248 * We need to be sure there will still be a place to evaluate the PHV
249 * if we remove the join, ie that ph_eval_at wouldn't become empty.
250 */
252 return false; /* there isn't any other place to eval PHV */
253 /* Check contained expression last, since this is a bit expensive */
255 innerrel->relids))
256 return false; /* contained expression references innerrel */
257 }
258
259 /*
260 * Search for mergejoinable clauses that constrain the inner rel against
261 * either the outer rel or a pseudoconstant. If an operator is
262 * mergejoinable then it behaves like equality for some btree opclass, so
263 * it's what we want. The mergejoinability test also eliminates clauses
264 * containing volatile functions, which we couldn't depend on.
265 */
267 {
269
270 /*
271 * If the current join commutes with some other outer join(s) via
272 * outer join identity 3, there will be multiple clones of its join
273 * clauses in the joininfo list. We want to consider only the
274 * has_clone form of such clauses. Processing more than one form
275 * would be wasteful, and also some of the others would confuse the
276 * RINFO_IS_PUSHED_DOWN test below.
277 */
279 continue; /* ignore it */
280
281 /*
282 * If it's not a join clause for this outer join, we can't use it.
283 * Note that if the clause is pushed-down, then it is logically from
284 * above the outer join, even if it references no other rels (it might
285 * be from WHERE, for example).
286 */
288 continue; /* ignore; not useful here */
289
290 /* Ignore if it's not a mergejoinable clause */
293 continue; /* not mergejoinable */
294
295 /*
296 * Check if the clause has the form "outer op inner" or "inner op
297 * outer", and if so mark which side is inner.
298 */
300 innerrel->relids))
301 continue; /* no good for these input relations */
302
303 /* OK, add to list */
305 }
306
307 /*
308 * Now that we have the relevant equality join clauses, try to prove the
309 * innerrel distinct.
310 */
312 return true;
313
314 /*
315 * Some day it would be nice to check for other methods of establishing
316 * distinctness.
317 */
318 return false;
319}
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition bitmapset.c:843
Definition nodes.h:133
Definition pathnodes.h:3419
Definition pathnodes.h:1010
References Assert, bms_add_member(), bms_copy(), bms_get_singleton_member(), bms_is_member(), bms_is_subset(), bms_overlap(), bms_union(), clause_sides_match_join(), fb(), find_base_rel(), JOIN_LEFT, RelOptInfo::joininfo, SpecialJoinInfo::jointype, lappend(), lfirst, RelOptInfo::max_attr, RelOptInfo::min_attr, SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, NIL, SpecialJoinInfo::ojrelid, pull_varnos(), rel_is_distinct_for(), rel_supports_distinctness(), RelOptInfo::relids, RINFO_IS_PUSHED_DOWN, and root.
Referenced by remove_useless_joins().
◆ match_unique_clauses()
|
static |
Definition at line 2294 of file analyzejoins.c.
2296{
2298 {
2299 Expr *clause;
2302 bool matched = false;
2303
2305
2306 /* Only filters like f(R.x1,...,R.xN) == expr we should consider. */
2308 bms_is_empty(rinfo->right_relids));
2309
2312 replace_relid_callback);
2313
2315 get_leftop(clause);
2317 get_rightop(clause);
2318
2319 /*
2320 * Compare these left and right sides with the corresponding sides of
2321 * the outer's filters. If no one is detected - return immediately.
2322 */
2324 {
2327
2329 /* Don't consider clauses that aren't similar to 'F(X)=G(Y)' */
2330 continue;
2331
2333
2338
2340 {
2341 matched = true;
2342 break;
2343 }
2344 }
2345
2346 if (!matched)
2347 return false;
2348 }
2349
2350 return true;
2351}
static bool replace_relid_callback(Node *node, ChangeVarNodes_context *context)
Definition analyzejoins.c:1917
void ChangeVarNodesExtended(Node *node, int rt_index, int new_index, int sublevels_up, ChangeVarNodes_callback callback)
Definition rewriteManip.c:665
Definition primnodes.h:190
References Assert, RelOptInfo::baserestrictinfo, bms_is_empty, ChangeVarNodesExtended(), copyObject, equal(), fb(), foreach_node, get_leftop(), get_rightop(), is_opclause(), NIL, RelOptInfo::relid, and replace_relid_callback().
Referenced by remove_self_joins_one_group().
◆ query_is_distinct_for()
Definition at line 1328 of file analyzejoins.c.
1329{
1330 ListCell *l;
1332
1333 /*
1334 * DISTINCT (including DISTINCT ON) guarantees uniqueness if all the
1335 * columns in the DISTINCT clause appear in colnos and operator semantics
1336 * match. This is true even if there are SRFs in the DISTINCT columns or
1337 * elsewhere in the tlist.
1338 */
1340 {
1342 {
1345 query->targetList);
1346
1352 break; /* exit early if no match */
1353 }
1355 return true;
1356 }
1357
1358 /*
1359 * Otherwise, a set-returning function in the query's targetlist can
1360 * result in returning duplicate rows, despite any grouping that might
1361 * occur before tlist evaluation. (If all tlist SRFs are within GROUP BY
1362 * columns, it would be safe because they'd be expanded before grouping.
1363 * But it doesn't currently seem worth the effort to check for that.)
1364 */
1365 if (query->hasTargetSRFs)
1366 return false;
1367
1368 /*
1369 * Similarly, GROUP BY without GROUPING SETS guarantees uniqueness if all
1370 * the grouped columns appear in colnos and operator semantics match.
1371 */
1373 {
1375 {
1378 query->targetList);
1379
1385 break; /* exit early if no match */
1386 }
1388 return true;
1389 }
1391 {
1392 List *gsets;
1393
1394 /*
1395 * If we have grouping sets with expressions, we probably don't have
1396 * uniqueness and analysis would be hard. Punt.
1397 */
1399 return false;
1400
1401 /*
1402 * If we have no groupClause (therefore no grouping expressions), we
1403 * might have one or many empty grouping sets. If there's just one,
1404 * or if the DISTINCT clause is used on the GROUP BY, then we're
1405 * returning only one row and are certainly unique. But otherwise, we
1406 * know we're certainly not unique.
1407 */
1409 return true;
1410
1412
1414 }
1415 else
1416 {
1417 /*
1418 * If we have no GROUP BY, but do have aggregates or HAVING, then the
1419 * result is at most one row so it's surely unique, for any operators.
1420 */
1422 return true;
1423 }
1424
1425 /*
1426 * UNION, INTERSECT, EXCEPT guarantee uniqueness of the whole output row,
1427 * except with ALL.
1428 */
1430 {
1432
1434
1436 {
1438
1439 /* We're good if all the nonjunk output columns are in colnos */
1442 {
1445
1447 continue; /* ignore resjunk columns */
1448
1449 /* non-resjunk columns should have grouping clauses */
1453
1459 break; /* exit early if no match */
1460 }
1462 return true;
1463 }
1464 }
1465
1466 /*
1467 * XXX Are there any other cases in which we can easily see the result
1468 * must be distinct?
1469 *
1470 * If you do add more smarts to this function, be sure to update
1471 * query_supports_distinctness() to match.
1472 */
1473
1474 return false;
1475}
static DistinctColInfo * distinct_col_search(int colno, List *distinct_cols)
Definition analyzejoins.c:1486
bool collations_agree_on_equality(Oid coll1, Oid coll2)
Definition lsyscache.c:954
bool equality_ops_are_compatible(Oid opno1, Oid opno2)
Definition lsyscache.c:841
List * expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
Definition parse_agg.c:2019
Definition parsenodes.h:2398
Definition parsenodes.h:1554
Definition primnodes.h:2263
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition tlist.c:376
References Assert, castNode, collations_agree_on_equality(), distinct_col_search(), Query::distinctClause, equality_ops_are_compatible(), expand_grouping_sets(), exprCollation(), fb(), get_sortgroupclause_tle(), Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, lfirst, list_head(), list_length(), lnext(), SETOP_NONE, Query::setOperations, and Query::targetList.
Referenced by rel_is_distinct_for().
◆ query_supports_distinctness()
Definition at line 1281 of file analyzejoins.c.
1282{
1283 /* SRFs break distinctness except with DISTINCT, see below */
1285 return false;
1286
1287 /* check for features we can prove distinctness with */
1291 query->hasAggs ||
1292 query->havingQual ||
1293 query->setOperations)
1294 return true;
1295
1296 return false;
1297}
References Query::distinctClause, Query::groupClause, Query::groupingSets, Query::havingQual, NIL, and Query::setOperations.
Referenced by rel_supports_distinctness().
◆ reduce_unique_semijoins()
| void reduce_unique_semijoins | ( | PlannerInfo * | root | ) |
Definition at line 1042 of file analyzejoins.c.
1043{
1045
1046 /*
1047 * Scan the join_info_list to find semijoins.
1048 */
1050 {
1053 RelOptInfo *innerrel;
1055 List *restrictlist;
1056
1057 /*
1058 * Must be a semijoin to a single baserel, else we aren't going to be
1059 * able to do anything with it.
1060 */
1062 continue;
1063
1065 continue;
1066
1068
1069 /*
1070 * Before we trouble to run generate_join_implied_equalities, make a
1071 * quick check to eliminate cases in which we will surely be unable to
1072 * prove uniqueness of the innerrel.
1073 */
1075 continue;
1076
1077 /* Compute the relid set for the join we are considering */
1080
1081 /*
1082 * Since we're only considering a single-rel RHS, any join clauses it
1083 * has must be clauses linking it to the semijoin's min_lefthand. We
1084 * can also consider EC-derived join clauses.
1085 */
1086 restrictlist =
1088 joinrelids,
1089 sjinfo->min_lefthand,
1090 innerrel,
1091 NULL),
1092 innerrel->joininfo);
1093
1094 /* Test whether the innerrel is unique for those clauses. */
1098 continue;
1099
1100 /* OK, remove the SpecialJoinInfo from the list. */
1102 }
1103}
bool innerrel_is_unique(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
Definition analyzejoins.c:1524
List * generate_join_implied_equalities(PlannerInfo *root, Relids join_relids, Relids outer_relids, RelOptInfo *inner_rel, SpecialJoinInfo *sjinfo)
Definition equivclass.c:1549
Definition pathnodes.h:3222
References Assert, bms_get_singleton_member(), bms_union(), fb(), find_base_rel(), foreach_delete_current, generate_join_implied_equalities(), innerrel_is_unique(), JOIN_SEMI, RelOptInfo::joininfo, SpecialJoinInfo::jointype, lfirst, list_concat(), SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, SpecialJoinInfo::ojrelid, rel_supports_distinctness(), and root.
Referenced by query_planner().
◆ rel_is_distinct_for()
|
static |
Definition at line 1178 of file analyzejoins.c.
1180{
1181 /*
1182 * We could skip a couple of tests here if we assume all callers checked
1183 * rel_supports_distinctness first, but it doesn't seem worth taking any
1184 * risk for.
1185 */
1187 return false;
1189 {
1190 /*
1191 * Examine the indexes to see if we have a matching unique index.
1192 * relation_has_unique_index_for automatically adds any usable
1193 * restriction clauses for the rel, so we needn't do that here.
1194 */
1196 return true;
1197 }
1199 {
1203 ListCell *l;
1204
1205 /*
1206 * Build the argument list for query_is_distinct_for: a list of
1207 * DistinctColInfo entries, each holding an output column number that
1208 * the query needs to be distinct over, the equality operator that the
1209 * column needs to be distinct according to, and that operator's input
1210 * collation. The collation matters because the subquery's own
1211 * DISTINCT / GROUP BY / set-op proves uniqueness under its own
1212 * collation, which need not agree with the operator's.
1213 *
1214 * (XXX we are not considering restriction clauses attached to the
1215 * subquery; is that worth doing?)
1216 */
1218 {
1220 OpExpr *opexpr;
1221 Var *var;
1223
1224 /*
1225 * The caller's mergejoinability test should have selected only
1226 * OpExprs. The operator might be a cross-type operator and thus
1227 * not exactly the same operator the subquery would consider;
1228 * that's all right since query_is_distinct_for can resolve such
1229 * cases.
1230 */
1232
1233 /* caller identified the inner side for us */
1234 if (rinfo->outer_is_left)
1236 else
1238
1239 /*
1240 * We may ignore any RelabelType node above the operand. (There
1241 * won't be more than one, since eval_const_expressions() has been
1242 * applied already.)
1243 */
1246
1247 /*
1248 * If inner side isn't a Var referencing a subquery output column,
1249 * this clause doesn't help us.
1250 */
1253 continue;
1254
1258 dcinfo->collid = opexpr->inputcollid;
1260 }
1261
1263 return true;
1264 }
1265 return false;
1266}
bool query_is_distinct_for(Query *query, List *distinct_cols)
Definition analyzejoins.c:1328
bool relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel, List *restrictlist, List **extra_clauses)
Definition indxpath.c:4144
Definition primnodes.h:831
Definition parsenodes.h:121
Definition primnodes.h:1198
Definition primnodes.h:263
References castNode, RestrictInfo::clause, fb(), get_leftop(), get_rightop(), IsA, lappend(), lfirst_node, NIL, OpExpr::opno, palloc(), query_is_distinct_for(), relation_has_unique_index_for(), RelOptInfo::relid, RELOPT_BASEREL, RelOptInfo::reloptkind, root, RTE_RELATION, RTE_SUBQUERY, RelOptInfo::rtekind, Var::varattno, Var::varlevelsup, and Var::varno.
Referenced by is_innerrel_unique_for(), and join_is_removable().
◆ rel_supports_distinctness()
|
static |
Definition at line 1118 of file analyzejoins.c.
1119{
1120 /* We only know about baserels ... */
1122 return false;
1124 {
1125 /*
1126 * For a plain relation, we only know how to prove uniqueness by
1127 * reference to unique indexes. Make sure there's at least one
1128 * suitable unique index. It must be immediately enforced, and not a
1129 * partial index. (Keep these conditions in sync with
1130 * relation_has_unique_index_for!)
1131 */
1133
1135 {
1137
1139 return true;
1140 }
1141 }
1143 {
1145
1146 /* Check if the subquery has any qualities that support distinctness */
1148 return true;
1149 }
1150 /* We have no proof rules for any other rtekinds. */
1151 return false;
1152}
bool query_supports_distinctness(Query *query)
Definition analyzejoins.c:1281
Definition pathnodes.h:1347
Definition preproc-array_of_struct.c:43
References fb(), RelOptInfo::indexlist, lfirst, NIL, query_supports_distinctness(), RelOptInfo::relid, RELOPT_BASEREL, RelOptInfo::reloptkind, root, RTE_RELATION, RTE_SUBQUERY, and RelOptInfo::rtekind.
Referenced by innerrel_is_unique_ext(), join_is_removable(), and reduce_unique_semijoins().
◆ remove_leftjoinrel_from_query()
|
static |
Definition at line 330 of file analyzejoins.c.
332{
338 ListCell *l;
339
340 /* Compute the relid set for the join we are considering */
342 Assert(ojrelid != 0);
344
346
347 /*
348 * Remove any joinquals referencing the rel from the joininfo lists.
349 *
350 * In some cases, a joinqual has to be put back after deleting its
351 * reference to the target rel. This can occur for pseudoconstant and
352 * outerjoin-delayed quals, which can get marked as requiring the rel in
353 * order to force them to be evaluated at or above the join. We can't
354 * just discard them, though. Only quals that logically belonged to the
355 * outer join being discarded should be removed from the query.
356 *
357 * We might encounter a qual that is a clone of a deletable qual with some
358 * outer-join relids added (see deconstruct_distribute_oj_quals). To
359 * ensure we get rid of such clones as well, add the relids of all OJs
360 * commutable with this one to the set we test against for
361 * pushed-down-ness.
362 */
364 sjinfo->commute_above_r);
366 sjinfo->commute_below_l);
367
368 /*
369 * We must make a copy of the rel's old joininfo list before starting the
370 * loop, because otherwise remove_join_clause_from_rels would destroy the
371 * list while we're scanning it.
372 */
375 {
377
379
381 {
382 /*
383 * There might be references to relid or ojrelid in the
384 * RestrictInfo's relid sets, as a consequence of PHVs having had
385 * ph_eval_at sets that include those. We already checked above
386 * that any such PHV is safe (and updated its ph_eval_at), so we
387 * can just drop those references.
388 */
389 remove_rel_from_restrictinfo(rinfo, relid, ojrelid);
390
391 /*
392 * Cross-check that the clause itself does not reference the
393 * target rel or join.
394 */
395#ifdef USE_ASSERT_CHECKING
396 {
399
402 }
403#endif
404 /* Now throw it back into the joininfo lists */
406 }
407 }
408
409 /*
410 * There may be references to the rel in root->fkey_list, but if so,
411 * match_foreign_keys_to_quals() will get rid of them.
412 */
413
414 /*
415 * Now remove the rel from the baserel array to prevent it from being
416 * referenced again. (We can't do this earlier because
417 * remove_join_clause_from_rels will touch it.)
418 */
421
422 /* And nuke the RelOptInfo, just in case there's another access path */
423 pfree(rel);
424
425 /*
426 * Now repeat construction of attr_needed bits coming from all other
427 * sources.
428 */
433}
static void remove_rel_from_query(PlannerInfo *root, int relid, int subst, SpecialJoinInfo *sjinfo, Relids joinrelids)
Definition analyzejoins.c:453
static void remove_rel_from_restrictinfo(RestrictInfo *rinfo, int relid, int ojrelid)
Definition analyzejoins.c:717
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1036
void rebuild_eclass_attr_needed(PlannerInfo *root)
Definition equivclass.c:2573
void rebuild_lateral_attr_needed(PlannerInfo *root)
Definition initsplan.c:1245
void rebuild_joinclause_attr_needed(PlannerInfo *root)
Definition initsplan.c:3961
void remove_join_clause_from_rels(PlannerInfo *root, RestrictInfo *restrictinfo, Relids join_relids)
Definition joininfo.c:161
void rebuild_placeholder_attr_needed(PlannerInfo *root)
Definition placeholder.c:329
References Assert, bms_add_member(), bms_add_members(), bms_is_member(), bms_union(), RestrictInfo::clause, SpecialJoinInfo::commute_above_r, SpecialJoinInfo::commute_below_l, distribute_restrictinfo_to_rels(), fb(), find_base_rel(), RelOptInfo::joininfo, lfirst, list_copy(), SpecialJoinInfo::min_lefthand, SpecialJoinInfo::min_righthand, SpecialJoinInfo::ojrelid, pfree(), pull_varnos(), rebuild_eclass_attr_needed(), rebuild_joinclause_attr_needed(), rebuild_lateral_attr_needed(), rebuild_placeholder_attr_needed(), remove_join_clause_from_rels(), remove_rel_from_query(), remove_rel_from_restrictinfo(), RestrictInfo::required_relids, RINFO_IS_PUSHED_DOWN, and root.
Referenced by remove_useless_joins().
◆ remove_rel_from_eclass()
|
static |
Definition at line 795 of file analyzejoins.c.
797{
799
800 /*
801 * Strip the removed rel/join from PlaceHolderVars in member expressions.
802 * This is needed even when the EC's relids don't mention the removed rel.
803 * Plain Vars and Consts can't contain a PlaceHolderVar, so skip them.
804 */
806 {
808 {
812 }
813 }
814
817 return;
818
819 /* Fix up the EC's overall relids */
822
823 /*
824 * We don't expect any EC child members to exist at this point. Ensure
825 * that's the case, otherwise, we might be getting asked to do something
826 * this function hasn't been coded for.
827 */
829
830 /*
831 * Fix up the member expressions. Any non-const member that ends with
832 * empty em_relids must be a Var or PHV of the removed relation. We don't
833 * need it anymore, so we can drop it.
834 */
836 {
838
841 {
843 /* em_relids is likely to be shared with some RestrictInfo */
849 }
850 }
851
852 /* Fix up the source clauses, in case we can re-use them later */
854 {
856
857 remove_rel_from_restrictinfo(rinfo, relid, ojrelid);
858 }
859
860 /*
861 * Rather than expend code on fixing up any already-derived clauses, just
862 * drop them. (At this point, any such clauses would be base restriction
863 * clauses, which we'd not need anymore anyway.)
864 */
865 ec_clear_derived_clauses(ec);
866}
static Node * remove_rel_from_phvs(Node *node, int relid, int ojrelid)
Definition analyzejoins.c:928
void ec_clear_derived_clauses(EquivalenceClass *ec)
Definition equivclass.c:3830
Definition primnodes.h:328
Definition pathnodes.h:1715
References Assert, bms_copy(), bms_del_member(), bms_is_empty, bms_is_member(), EquivalenceClass::ec_childmembers, ec_clear_derived_clauses(), EquivalenceClass::ec_members, EquivalenceClass::ec_relids, EquivalenceClass::ec_sources, fb(), foreach_delete_current, foreach_node, IsA, lfirst, remove_rel_from_phvs(), remove_rel_from_restrictinfo(), and root.
Referenced by remove_rel_from_query().
◆ remove_rel_from_joinlist()
Definition at line 988 of file analyzejoins.c.
989{
992
994 {
996
998 {
1000
1001 if (varno == relid)
1002 (*nremoved)++;
1003 else
1005 }
1007 {
1008 /* Recurse to handle subproblem */
1010
1012 relid, nremoved);
1013 /* Avoid including empty sub-lists in the result */
1016 }
1017 else
1018 {
1021 }
1022 }
1023
1025}
static List * remove_rel_from_joinlist(List *joinlist, int relid, int *nremoved)
Definition analyzejoins.c:988
Definition primnodes.h:2320
References elog, ERROR, fb(), IsA, lappend(), lfirst, NIL, nodeTag, remove_rel_from_joinlist(), and result.
Referenced by remove_rel_from_joinlist(), remove_useless_joins(), and remove_useless_self_joins().
◆ remove_rel_from_phvs()
Definition at line 928 of file analyzejoins.c.
929{
931
933}
static Node * remove_rel_from_phvs_mutator(Node *node, Relids removable)
Definition analyzejoins.c:936
References bms_add_member(), bms_make_singleton(), fb(), and remove_rel_from_phvs_mutator().
Referenced by remove_rel_from_eclass(), and remove_rel_from_restrictinfo_phvs().
◆ remove_rel_from_phvs_mutator()
Definition at line 936 of file analyzejoins.c.
937{
941 {
944
945 /* Upper-level PlaceHolderVars should be long gone at this point */
947
948 /* Copy the PlaceHolderVar and mutate what's below ... */
950 expression_tree_mutator(node,
952 removable);
953
954 /*
955 * ... then strip the removed rels from its relid sets.
956 *
957 * If stripping would empty phrels, the PHV is evaluated only at the
958 * removed relation(s); it then belongs to an EquivalenceMember that
959 * the caller drops immediately afterwards. Leave such a PHV
960 * untouched rather than build one with empty phrels, which the rest
961 * of the planner assumes never occurs.
962 */
965 {
968 removable);
969 }
970
972 }
975 removable);
976}
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:347
Definition pathnodes.h:3116
References Assert, bms_difference(), bms_is_empty, expression_tree_mutator, fb(), IsA, and remove_rel_from_phvs_mutator().
Referenced by remove_rel_from_phvs(), and remove_rel_from_phvs_mutator().
◆ remove_rel_from_query()
|
static |
Definition at line 453 of file analyzejoins.c.
456{
458 Index rti;
459 ListCell *l;
463
467
468 /*
469 * Update all_baserels and related relid sets.
470 */
473
475 {
478 }
479
480 /*
481 * Likewise remove references from SpecialJoinInfo data structures.
482 *
483 * This is relevant in case the relation we're deleting is part of the
484 * relid sets of special joins: those sets have to be adjusted. If we are
485 * removing an outer join, the RHS of the target outer join will be made
486 * empty here, but that's OK since the caller will delete that
487 * SpecialJoinInfo entirely.
488 */
490 {
492
493 /*
494 * initsplan.c is fairly cavalier about allowing SpecialJoinInfos'
495 * lefthand/righthand relid sets to be shared with other data
496 * structures. Ensure that we don't modify the original relid sets.
497 * (The commute_xxx sets are always per-SpecialJoinInfo though.)
498 */
503
504 /* Now adjust relid bit in the sets: */
509
511 {
512 /* Remove ojrelid bit from the sets: */
517 /* relid cannot appear in these fields, but ojrelid can: */
522 }
523 else
524 {
525 /*
526 * For self-join removal, replace relid references in
527 * semi_rhs_exprs.
528 */
530 0, replace_relid_callback);
531 }
532 }
533
534 /*
535 * Likewise remove references from PlaceHolderVar data structures,
536 * removing any no-longer-needed placeholders entirely. We only remove
537 * PHVs for left-join removal. With self-join elimination, PHVs already
538 * get moved to the remaining relation, where they might still be needed.
539 * It might also happen that we skip the removal of some PHVs that could
540 * be removed. However, the overhead of extra PHVs is small compared to
541 * the complexity of analysis needed to remove them.
542 *
543 * Removal is a bit trickier than it might seem: we can remove PHVs that
544 * are used at the target rel and/or in the join qual, but not those that
545 * are used at join partner rels or above the join. It's not that easy to
546 * distinguish PHVs used at partner rels from those used in the join qual,
547 * since they will both have ph_needed sets that are subsets of
548 * joinrelids. However, a PHV used at a partner rel could not have the
549 * target rel in ph_eval_at, so we check that while deciding whether to
550 * remove or just update the PHV. There is no corresponding test in
551 * join_is_removable because it doesn't need to distinguish those cases.
552 */
554 {
556
558
563 {
565 l);
567 }
568 else
569 {
571
576
577 /* Reduce ph_needed to contain only "relation 0"; see below */
580 else
582
587
588 /*
589 * For self-join removal, update Var nodes within the PHV's
590 * expression to reference the replacement relid, and adjust
591 * ph_lateral for the relid substitution. (For left-join removal,
592 * we're removing rather than replacing, and any surviving PHV
593 * shouldn't reference the removed rel in its expression. Also,
594 * relid can't appear in ph_lateral for outer joins.)
595 */
597 {
599 replace_relid_callback);
601
602 /*
603 * ph_lateral might contain rels mentioned in ph_eval_at after
604 * the replacement, remove them.
605 */
607 /* ph_lateral might or might not be empty */
608 }
609
611 }
612 }
613
614 /*
615 * Likewise remove references from EquivalenceClasses.
616 *
617 * For self-join removal, the caller has already updated the
618 * EquivalenceClasses, so we can skip this step.
619 */
621 {
623 {
625
627 }
628 }
629
630 /*
631 * Finally, we must prepare for the caller to recompute per-Var
632 * attr_needed and per-PlaceHolderVar ph_needed relid sets. These have to
633 * be known accurately, else we may fail to remove other now-removable
634 * joins. Because the caller removes the join clause(s) associated with
635 * the removed join, Vars that were formerly needed may no longer be.
636 *
637 * The actual reconstruction of these relid sets is performed by the
638 * specific caller. Here, we simply clear out the existing attr_needed
639 * sets (we already did this above for ph_needed) to ensure they are
640 * rebuilt from scratch. We can cheat to one small extent: we can avoid
641 * re-examining the targetlist and HAVING qual by preserving "relation 0"
642 * bits from the existing relid sets. This is safe because we'd never
643 * remove such references.
644 *
645 * Additionally, if we are performing self-join elimination, we must
646 * replace references to the removed relid with subst within the
647 * lateral_vars lists.
648 *
649 * Also, for left-join removal, we strip the removed rel and join from any
650 * PlaceHolderVar embedded in the surviving rels' restriction clauses and
651 * join clauses; we needn't bother with the rel being removed, nor when
652 * the query has no PlaceHolderVars.
653 */
655 {
658
659 /* there may be empty slots corresponding to non-baserel RTEs */
661 continue;
662
664
666 attroff >= 0;
667 attroff--)
668 {
671 else
673 }
674
677 subst, 0, replace_relid_callback);
678
680 {
682 remove_rel_from_restrictinfo_phvs(rinfo, relid, ojrelid);
683
684 /*
685 * Join clauses need the same treatment, but there's no value in
686 * processing any join clause more than once. So it's slightly
687 * annoying that we have to find them via the per-base-relation
688 * joininfo lists. Avoid duplicate processing by tracking the
689 * rinfo_serial numbers of join clauses we've already seen. (This
690 * doesn't work for is_clone clauses, so we must waste effort on
691 * them.)
692 */
694 {
695 if (!rinfo->is_clone) /* else serial number is not unique */
696 {
698 continue; /* saw it already */
700 rinfo->rinfo_serial);
701 }
702 remove_rel_from_restrictinfo_phvs(rinfo, relid, ojrelid);
703 }
704 }
705 }
706}
static void remove_rel_from_restrictinfo_phvs(RestrictInfo *rinfo, int relid, int ojrelid)
Definition analyzejoins.c:877
static void remove_rel_from_eclass(PlannerInfo *root, EquivalenceClass *ec, int relid, int ojrelid)
Definition analyzejoins.c:795
Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid)
Definition rewriteManip.c:760
Definition pathnodes.h:1654
References adjust_relid_set(), Assert, bms_add_member(), bms_copy(), bms_del_member(), bms_difference(), bms_is_empty, bms_is_member(), bms_is_subset(), bms_make_singleton(), ChangeVarNodesExtended(), fb(), foreach_delete_current, foreach_node, lfirst, SpecialJoinInfo::min_lefthand, SpecialJoinInfo::ojrelid, remove_rel_from_eclass(), remove_rel_from_restrictinfo_phvs(), replace_relid_callback(), and root.
Referenced by remove_leftjoinrel_from_query(), and remove_self_join_rel().
◆ remove_rel_from_restrictinfo()
|
static |
Definition at line 717 of file analyzejoins.c.
718{
719 /*
720 * initsplan.c is fairly cavalier about allowing RestrictInfos to share
721 * relid sets with other RestrictInfos, and SpecialJoinInfos too. Make
722 * sure this RestrictInfo has its own relid sets before we modify them.
723 * (In present usage, clause_relids is probably not shared, but
724 * required_relids could be; let's not assume anything.)
725 */
726 rinfo->clause_relids = bms_copy(rinfo->clause_relids);
727 rinfo->clause_relids = bms_del_member(rinfo->clause_relids, relid);
728 rinfo->clause_relids = bms_del_member(rinfo->clause_relids, ojrelid);
729 /* Likewise for required_relids */
733 /* Likewise for incompatible_relids */
737 /* Likewise for outer_relids */
741 /* Likewise for left_relids */
742 rinfo->left_relids = bms_copy(rinfo->left_relids);
743 rinfo->left_relids = bms_del_member(rinfo->left_relids, relid);
744 rinfo->left_relids = bms_del_member(rinfo->left_relids, ojrelid);
745 /* Likewise for right_relids */
746 rinfo->right_relids = bms_copy(rinfo->right_relids);
747 rinfo->right_relids = bms_del_member(rinfo->right_relids, relid);
748 rinfo->right_relids = bms_del_member(rinfo->right_relids, ojrelid);
749
750 /* If it's an OR, recurse to clean up sub-clauses */
752 {
754
757 {
759
760 /* OR arguments should be ANDs or sub-RestrictInfos */
762 {
765
767 {
769
771 }
772 }
773 else
774 {
776
778 }
779 }
780 }
781}
bool restriction_is_or_clause(RestrictInfo *restrictinfo)
Definition restrictinfo.c:407
Definition primnodes.h:949
References Assert, bms_copy(), bms_del_member(), castNode, fb(), RestrictInfo::incompatible_relids, is_andclause(), is_orclause(), lfirst, lfirst_node, RestrictInfo::outer_relids, remove_rel_from_restrictinfo(), RestrictInfo::required_relids, and restriction_is_or_clause().
Referenced by remove_leftjoinrel_from_query(), remove_rel_from_eclass(), and remove_rel_from_restrictinfo().
◆ remove_rel_from_restrictinfo_phvs()
|
static |
Definition at line 877 of file analyzejoins.c.
878{
881
882 /* If it's an OR, recurse to clean up sub-clauses */
884 {
886
889 {
891
892 /* OR arguments should be ANDs or sub-RestrictInfos */
894 {
897
899 {
901
903 }
904 }
905 else
906 {
908
910 }
911 }
912 }
913}
References Assert, castNode, RestrictInfo::clause, fb(), is_andclause(), is_orclause(), lfirst, lfirst_node, remove_rel_from_phvs(), remove_rel_from_restrictinfo_phvs(), and restriction_is_or_clause().
Referenced by remove_rel_from_query(), and remove_rel_from_restrictinfo_phvs().
◆ remove_self_join_rel()
|
static |
Definition at line 2041 of file analyzejoins.c.
2044{
2050
2053
2054 /*
2055 * Replace the index of the removing table with the keeping one. The
2056 * technique of removing/distributing restrictinfo is used here to attach
2057 * just appeared (for keeping relation) join clauses and avoid adding
2058 * duplicates of those that already exist in the joininfo list.
2059 */
2062 {
2065 0, replace_relid_callback);
2066
2069 else
2071 }
2072
2073 /*
2074 * Concatenate restrictlist to the list of base restrictions of the
2075 * removing table just to simplify the replacement procedure: all of them
2076 * weren't connected to any keeping relations and need to be added to some
2077 * rels.
2078 */
2080 restrictlist);
2082 {
2084 0, replace_relid_callback);
2085
2088 else
2090 }
2091
2092 /*
2093 * Now, add all non-redundant clauses to the keeping relation.
2094 */
2099
2102
2103 /*
2104 * Arrange equivalence classes, mentioned removing a table, with the
2105 * keeping one: varno of removing table should be replaced in members and
2106 * sources lists. Also, remove duplicated elements if this replacement
2107 * procedure created them.
2108 */
2109 i = -1;
2111 {
2113
2116 }
2117
2118 /*
2119 * Transfer the targetlist and attr_needed flags.
2120 */
2121
2123 {
2125
2127 replace_relid_callback);
2130 }
2131
2133 {
2135
2139 toRemove->attr_needed[attno]);
2140 }
2141
2142 /*
2143 * If the removed relation has a row mark, transfer it to the remaining
2144 * one.
2145 *
2146 * If both rels have row marks, just keep the one corresponding to the
2147 * remaining relation because we verified earlier that they have the same
2148 * strength.
2149 */
2151 {
2153 {
2155
2157 }
2158 else
2159 {
2160 /* Shouldn't have inheritance children here. */
2162
2164 }
2165 }
2166
2167 /*
2168 * Replace varno in all the query structures, except nodes RangeTblRef
2169 * otherwise later remove_rel_from_joinlist will yield errors.
2170 */
2172 0, replace_relid_callback);
2173
2174 /* Replace links in the planner info */
2176
2177 /* Replace varno in the fully-processed targetlist */
2180
2181 /*
2182 * No need to touch all_result_relids or leaf_result_relids: at this point
2183 * those sets contain only parse->resultRelation; inheritance children
2184 * have not been added yet; that happens later in add_other_rels_to_query.
2185 * And remove_self_joins_recurse rejects parse->resultRelation as an SJE
2186 * candidate to preserve the EPQ mechanism. So toRemove->relid cannot be
2187 * a member.
2188 */
2191
2192 /*
2193 * There may be references to the rel in root->fkey_list, but if so,
2194 * match_foreign_keys_to_quals() will get rid of them.
2195 */
2196
2197 /*
2198 * Finally, remove the rel from the baserel array to prevent it from being
2199 * referenced again. (We can't do this earlier because
2200 * remove_join_clause_from_rels will touch it.)
2201 */
2204
2205 /* And nuke the RelOptInfo, just in case there's another access path. */
2207
2208
2209 /*
2210 * Now repeat construction of attr_needed bits coming from all other
2211 * sources.
2212 */
2217}
static void add_non_redundant_clauses(PlannerInfo *root, List *rinfo_candidates, List **keep_rinfo_list, Index removed_relid)
Definition analyzejoins.c:1873
static void update_eclasses(EquivalenceClass *ec, int from, int to)
Definition analyzejoins.c:1747
References add_non_redundant_clauses(), adjust_relid_set(), Assert, bms_add_member(), bms_add_members(), bms_is_member(), bms_membership(), BMS_MULTIPLE, bms_next_member(), ChangeVarNodesExtended(), fb(), foreach_node, i, lappend(), lfirst, list_concat(), list_copy(), list_delete_ptr(), list_free(), list_member(), list_nth(), NIL, pfree(), rebuild_eclass_attr_needed(), rebuild_joinclause_attr_needed(), rebuild_lateral_attr_needed(), rebuild_placeholder_attr_needed(), remove_join_clause_from_rels(), remove_rel_from_query(), replace_relid_callback(), root, and update_eclasses().
Referenced by remove_self_joins_one_group().
◆ remove_self_joins_one_group()
|
static |
Definition at line 2360 of file analyzejoins.c.
2361{
2363 int k; /* Index of kept relation */
2364 int r = -1; /* Index of removed relation */
2365
2367 {
2369
2370 k = r;
2371
2373 {
2376 List *restrictlist;
2384
2385 /* A sanity check: the relations have the same Oid. */
2387 root->simple_rte_array[r]->relid);
2388
2389 /*
2390 * It is impossible to eliminate the join of two relations if they
2391 * belong to different rules of order. Otherwise, the planner
2392 * can't find any variants of the correct query plan.
2393 */
2395 {
2397
2402 {
2404 break;
2405 }
2406 }
2408 continue;
2409
2410 /*
2411 * Check Row Marks equivalence. We can't remove the join if the
2412 * relations have row marks of different strength (e.g., one is
2413 * locked FOR UPDATE, and another just has ROW_MARK_REFERENCE for
2414 * EvalPlanQual rechecking).
2415 */
2417 {
2419
2421 {
2424 }
2426 {
2429 }
2430
2432 break;
2433 }
2435 continue;
2436
2437 /*
2438 * We only deal with base rels here, so their relids bitset
2439 * contains only one member -- their relid.
2440 */
2443
2444 /*
2445 * PHVs should not impose any constraints on removing self-joins.
2446 */
2447
2448 /*
2449 * At this stage, joininfo lists of inner and outer can contain
2450 * only clauses required for a superior outer join that can't
2451 * influence this optimization. So, we can avoid to call the
2452 * build_joinrel_restrictlist() routine.
2453 */
2455 rrel->relids,
2458 continue;
2459
2460 /*
2461 * Process restrictlist to separate the self-join quals from the
2462 * other quals. e.g., "x = x" goes to selfjoinquals and "a = b" to
2463 * otherjoinquals.
2464 */
2467
2470
2471 /*
2472 * To enable SJE for the only degenerate case without any self
2473 * join clauses at all, add baserestrictinfo to this list. The
2474 * degenerate case works only if both sides have the same clause.
2475 * So doesn't matter which side to add.
2476 */
2478
2479 /*
2480 * Determine if the rrel can duplicate outer rows. We must bypass
2481 * the unique rel cache here since we're possibly using a subset
2482 * of join quals. We can use 'force_cache' == true when all join
2483 * quals are self-join quals. Otherwise, we could end up putting
2484 * false negatives in the cache.
2485 */
2489 &uclauses))
2490 continue;
2491
2492 /*
2493 * 'uclauses' is the copy of outer->baserestrictinfo that are
2494 * associated with an index. We proved by matching selfjoinquals
2495 * to a unique index that the outer relation has at most one
2496 * matching row for each inner row. Sometimes that is not enough.
2497 * e.g. "WHERE s1.b = s2.b AND s1.a = 1 AND s2.a = 2" when the
2498 * unique index is (a,b). Having non-empty uclauses, we must
2499 * validate that the inner baserestrictinfo contains the same
2500 * expressions, or we won't match the same row on each side of the
2501 * join.
2502 */
2504 continue;
2505
2506 /*
2507 * Remove rrel RelOptInfo from the planner structures and the
2508 * corresponding row mark.
2509 */
2511
2513
2514 /* We have removed the outer relation, try the next one. */
2515 break;
2516 }
2517 }
2518
2520}
static bool match_unique_clauses(PlannerInfo *root, RelOptInfo *outer, List *uclauses, Index relid)
Definition analyzejoins.c:2294
static void split_selfjoin_quals(PlannerInfo *root, List *joinquals, List **selfjoinquals, List **otherjoinquals, int from, int to)
Definition analyzejoins.c:2229
static void remove_self_join_rel(PlannerInfo *root, PlanRowMark *kmark, PlanRowMark *rmark, RelOptInfo *toKeep, RelOptInfo *toRemove, List *restrictlist)
Definition analyzejoins.c:2041
Definition plannodes.h:1608
References Assert, bms_add_member(), bms_is_member(), bms_next_member(), fb(), generate_join_implied_equalities(), innerrel_is_unique_ext(), JOIN_INNER, lfirst, list_concat(), list_length(), match_unique_clauses(), NIL, remove_self_join_rel(), result, root, split_selfjoin_quals(), SpecialJoinInfo::syn_lefthand, and SpecialJoinInfo::syn_righthand.
Referenced by remove_self_joins_recurse().
◆ remove_self_joins_recurse()
|
static |
Definition at line 2527 of file analyzejoins.c.
2528{
2535
2536 /* Collect indexes of base relations of the join tree */
2538 {
2540
2542 {
2545
2546 /*
2547 * We only consider ordinary relations as candidates to be
2548 * removed, and these relations should not have TABLESAMPLE
2549 * clauses specified. Removing a relation with TABLESAMPLE clause
2550 * could potentially change the syntax of the query. Because of
2551 * UPDATE/DELETE EPQ mechanism, currently Query->resultRelation or
2552 * Query->mergeTargetRelation associated rel cannot be eliminated.
2553 */
2557 varno != root->parse->resultRelation &&
2558 varno != root->parse->mergeTargetRelation)
2559 {
2561 relids = bms_add_member(relids, varno);
2562 }
2563 }
2565 {
2566 /* Recursively go inside the sub-joinlist */
2568 toRemove);
2569 }
2570 else
2573 }
2574
2576
2577 /* Need at least two relations for the join */
2580
2581 /*
2582 * In order to find relations with the same oid we first build an array of
2583 * candidates and then sort it by oid.
2584 */
2586 i = -1;
2587 j = 0;
2589 {
2592 j++;
2593 }
2594
2596 self_join_candidates_cmp);
2597
2598 /*
2599 * Iteratively form a group of relation indexes with the same oid and
2600 * launch the routine that detects self-joins in this group and removes
2601 * excessive range table entries.
2602 *
2603 * At the end of the iteration, exclude the group from the overall relids
2604 * list. So each next iteration of the cycle will involve less and less
2605 * value of relids.
2606 */
2607 i = 0;
2609 {
2611 {
2613 {
2614 /* Create a group of relation indexes with the same oid */
2617
2619 {
2621 i++;
2622 }
2623 relids = bms_del_members(relids, group);
2624
2625 /*
2626 * Try to remove self-joins from a group of identical entries.
2627 * Make the next attempt iteratively - if something is deleted
2628 * from a group, changes in clauses and equivalence classes
2629 * can give us a chance to find more candidates.
2630 */
2631 do
2632 {
2640 bms_free(group);
2641 }
2642 else
2643 {
2644 /* Single relation, just remove it from the set */
2647 }
2648 }
2649 }
2650
2652
2654}
static int self_join_candidates_cmp(const void *a, const void *b)
Definition analyzejoins.c:2660
static Relids remove_self_joins_one_group(PlannerInfo *root, Relids relids)
Definition analyzejoins.c:2360
static Relids remove_self_joins_recurse(PlannerInfo *root, List *joinlist, Relids toRemove)
Definition analyzejoins.c:2527
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1280
Definition parsenodes.h:1140
Definition analyzejoins.c:49
References Assert, bms_add_member(), bms_add_members(), bms_del_member(), bms_del_members(), bms_free(), bms_is_empty, bms_is_member(), bms_membership(), BMS_MULTIPLE, bms_next_member(), bms_num_members(), bms_overlap(), elog, ERROR, fb(), i, IsA, j, lfirst, nodeTag, palloc_array, qsort, remove_self_joins_one_group(), remove_self_joins_recurse(), root, RTE_RELATION, and self_join_candidates_cmp().
Referenced by remove_self_joins_recurse(), and remove_useless_self_joins().
◆ remove_useless_joins()
| List * remove_useless_joins | ( | PlannerInfo * | root, |
| List * | joinlist | ||
| ) |
Definition at line 97 of file analyzejoins.c.
98{
100
101 /*
102 * We are only interested in relations that are left-joined to, so we can
103 * scan the join_info_list to find them easily.
104 */
105restart:
107 {
111
112 /* Skip if not removable */
114 continue;
115
116 /*
117 * Currently, join_is_removable can only succeed when the sjinfo's
118 * righthand is a single baserel. Remove that rel from the query and
119 * joinlist.
120 */
122
124
125 /* We verify that exactly one reference gets removed from joinlist */
126 nremoved = 0;
130
131 /*
132 * We can delete this SpecialJoinInfo from the list too, since it's no
133 * longer of interest. (Since we'll restart the foreach loop
134 * immediately, we don't bother with foreach_delete_current.)
135 */
137
138 /*
139 * Restart the scan. This is necessary to ensure we find all
140 * removable joins independently of ordering of the join_info_list
141 * (note that removal of attr_needed bits may make a join appear
142 * removable that did not before).
143 */
144 goto restart;
145 }
146
148}
static void remove_leftjoinrel_from_query(PlannerInfo *root, int relid, SpecialJoinInfo *sjinfo)
Definition analyzejoins.c:330
static bool join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo)
Definition analyzejoins.c:162
References bms_singleton_member(), elog, ERROR, fb(), join_is_removable(), lfirst, list_delete_cell(), SpecialJoinInfo::min_righthand, remove_leftjoinrel_from_query(), remove_rel_from_joinlist(), and root.
Referenced by query_planner().
◆ remove_useless_self_joins()
| List * remove_useless_self_joins | ( | PlannerInfo * | root, |
| List * | joinlist | ||
| ) |
Definition at line 2707 of file analyzejoins.c.
2708{
2710 int relid = -1;
2711
2715
2716 /*
2717 * Merge pairs of relations participated in self-join. Remove unnecessary
2718 * range table entries.
2719 */
2721
2723 {
2724 /* At the end, remove orphaned relation links */
2726 {
2728
2732 }
2733 }
2734
2736}
References bms_next_member(), elog, enable_self_join_elimination, ERROR, fb(), IsA, linitial, list_length(), NIL, remove_rel_from_joinlist(), remove_self_joins_recurse(), root, and unlikely.
Referenced by query_planner().
◆ replace_relid_callback()
|
static |
Definition at line 1917 of file analyzejoins.c.
1918{
1920 {
1921 return true;
1922 }
1924 {
1926 int relid = -1;
1928 (rinfo->required_relids == rinfo->clause_relids);
1931
1932 /*
1933 * Recurse down into clauses if the target relation is present in
1934 * clause_relids or required_relids. We must check required_relids
1935 * because the relation not present in clause_relids might still be
1936 * present somewhere in orclause.
1937 */
1940 {
1942
1945
1947 context->rt_index,
1948 context->new_index);
1949
1950 /*
1951 * Incrementally adjust num_base_rels based on the change of
1952 * clause_relids, which could contain both base relids and
1953 * outer-join relids. This operation is legal until we remove
1954 * only baserels.
1955 */
1956 rinfo->num_base_rels -= bms_num_members(rinfo->clause_relids) -
1958
1959 rinfo->clause_relids = new_clause_relids;
1960 rinfo->left_relids =
1962 rinfo->right_relids =
1964 }
1965
1967 rinfo->required_relids = rinfo->clause_relids;
1968 else
1969 rinfo->required_relids =
1971
1972 rinfo->outer_relids =
1974 rinfo->incompatible_relids =
1976
1977 if (rinfo->mergeopfamilies &&
1978 bms_get_singleton_member(rinfo->clause_relids, &relid) &&
1979 clause_relids_is_multiple &&
1981 {
1984
1987
1988 /*
1989 * For self-join elimination, changing varnos could transform
1990 * "t1.a = t2.a" into "t1.a = t1.a". That is always true as long
1991 * as "t1.a" is not null. We use equal() to check for such a
1992 * case, and then we replace the qual with a check for not null
1993 * (NullTest).
1994 */
1996 {
1998
2002 ntest->location = -1;
2004 rinfo->mergeopfamilies = NIL;
2005 rinfo->left_em = NULL;
2006 rinfo->right_em = NULL;
2007 }
2009 }
2010 return true;
2011 }
2012
2013 return false;
2014}
bool ChangeVarNodesWalkExpression(Node *node, ChangeVarNodes_context *context)
Definition rewriteManip.c:745
Definition primnodes.h:1984
References adjust_relid_set(), Assert, bms_get_singleton_member(), bms_is_member(), bms_membership(), BMS_MULTIPLE, bms_num_members(), ChangeVarNodesWalkExpression(), RestrictInfo::clause, equal(), fb(), get_leftop(), get_rightop(), RestrictInfo::incompatible_relids, IS_NOT_NULL, IsA, makeNode, ChangeVarNodes_context::new_index, NIL, RestrictInfo::outer_relids, RestrictInfo::required_relids, and ChangeVarNodes_context::rt_index.
Referenced by match_unique_clauses(), remove_rel_from_query(), remove_self_join_rel(), split_selfjoin_quals(), and update_eclasses().
◆ restrict_infos_logically_equal()
|
static |
Definition at line 1847 of file analyzejoins.c.
1848{
1851
1855
1857}
References a, b, equal(), fb(), and result.
Referenced by add_non_redundant_clauses().
◆ self_join_candidates_cmp()
Definition at line 2660 of file analyzejoins.c.
2661{
2664
2667 else
2668 return 0;
2669}
References a, b, fb(), and SelfJoinCandidate::reloid.
Referenced by remove_self_joins_recurse().
◆ split_selfjoin_quals()
|
static |
Definition at line 2229 of file analyzejoins.c.
2231{
2234
2236 {
2237 OpExpr *expr;
2240
2241 /* In general, clause looks like F(arg1) = G(arg2) */
2242 if (!rinfo->mergeopfamilies ||
2243 bms_num_members(rinfo->clause_relids) != 2 ||
2246 {
2248 continue;
2249 }
2250
2251 expr = (OpExpr *) rinfo->clause;
2252
2254 {
2256 continue;
2257 }
2258
2261
2266
2267 /*
2268 * Quite an expensive operation, narrowing the use case. For example,
2269 * when we have cast of the same var to different (but compatible)
2270 * types.
2271 */
2273 bms_singleton_member(rinfo->right_relids),
2274 bms_singleton_member(rinfo->left_relids), 0,
2275 replace_relid_callback);
2276
2279 else
2281 }
2282
2285}
References arg, OpExpr::args, bms_membership(), bms_num_members(), BMS_SINGLETON, bms_singleton_member(), ChangeVarNodesExtended(), copyObject, equal(), fb(), foreach_node, get_leftop(), get_rightop(), IsA, lappend(), list_length(), NIL, and replace_relid_callback().
Referenced by remove_self_joins_one_group().
◆ update_eclasses()
|
static |
Definition at line 1747 of file analyzejoins.c.
1748{
1751
1752 /*
1753 * We don't expect any EC child members to exist at this point. Ensure
1754 * that's the case, otherwise, we might be getting asked to do something
1755 * this function hasn't been coded for.
1756 */
1758
1760 {
1762
1764 {
1766 continue;
1767 }
1768
1771
1772 /* We only process inner joins */
1774 replace_relid_callback);
1775
1777 {
1779 continue;
1780
1782 {
1784 break;
1785 }
1786 }
1787
1790 }
1791
1794
1795 ec_clear_derived_clauses(ec);
1796
1797 /* Update EC source expressions */
1799 {
1801
1803 {
1805 continue;
1806 }
1807
1809 replace_relid_callback);
1810
1811 /*
1812 * After switching the clause to the remaining relation, check it for
1813 * redundancy with existing ones. We don't have to check for
1814 * redundancy with derived clauses, because we've just deleted them.
1815 */
1817 {
1819 continue;
1820
1822 {
1824 break;
1825 }
1826 }
1827
1830 }
1831
1835}
References adjust_relid_set(), Assert, bms_is_member(), ChangeVarNodesExtended(), EquivalenceClass::ec_childmembers, ec_clear_derived_clauses(), EquivalenceClass::ec_members, EquivalenceClass::ec_relids, EquivalenceClass::ec_sources, equal(), fb(), foreach_node, lappend(), list_free(), NIL, and replace_relid_callback().
Referenced by remove_self_join_rel().
Variable Documentation
◆ enable_self_join_elimination
| bool enable_self_join_elimination |
Definition at line 54 of file analyzejoins.c.
Referenced by remove_useless_self_joins().
