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 1706 of file analyzejoins.c.
1710{
1712 {
1714
1716
1718 {
1720 /* Can't compare trivially different clauses */
1721 continue;
1722
1723 if (src == rinfo ||
1724 (rinfo->parent_ec != NULL &&
1725 src->parent_ec == rinfo->parent_ec) ||
1726 restrict_infos_logically_equal(rinfo, src))
1727 {
1729 break;
1730 }
1731 }
1734 }
1735}
static bool restrict_infos_logically_equal(RestrictInfo *a, RestrictInfo *b)
Definition analyzejoins.c:1680
void distribute_restrictinfo_to_rels(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition initsplan.c:3578
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 1319 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 1357 of file analyzejoins.c.
1364{
1367}
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:1379
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 1379 of file analyzejoins.c.
1387{
1393
1394 /* Certainly can't prove uniqueness when there are no joinclauses */
1396 return false;
1397
1398 /*
1399 * Make a quick check to eliminate cases in which we will surely be unable
1400 * to prove uniqueness of the innerrel.
1401 */
1403 return false;
1404
1405 /*
1406 * Query the cache to see if we've managed to prove that innerrel is
1407 * unique for any subset of this outerrel. For non-self-join search, we
1408 * don't need an exact match, as extra outerrels can't make the innerrel
1409 * any less unique (or more formally, the restrictlist for a join to a
1410 * superset outerrel must be a superset of the conditions we successfully
1411 * used before). For self-join search, we require an exact match of
1412 * outerrels because we need extra clauses to be valid for our case. Also,
1413 * for self-join checking we've filtered the clauses list. Thus, we can
1414 * match only the result cached for a self-join search for another
1415 * self-join check.
1416 */
1418 {
1420
1423 uniqueRelInfo->self_join))
1424 {
1425 if (extra_clauses)
1426 *extra_clauses = uniqueRelInfo->extra_clauses;
1427 return true; /* Success! */
1428 }
1429 }
1430
1431 /*
1432 * Conversely, we may have already determined that this outerrel, or some
1433 * superset thereof, cannot prove this innerrel to be unique.
1434 */
1436 {
1438
1440 return false;
1441 }
1442
1443 /* No cached information, so try to make the proof. */
1445 jointype, restrictlist,
1447 {
1448 /*
1449 * Cache the positive result for future probes, being sure to keep it
1450 * in the planner_cxt even if we are working in GEQO.
1451 *
1452 * Note: one might consider trying to isolate the minimal subset of
1453 * the outerrels that proved the innerrel unique. But it's not worth
1454 * the trouble, because the planner builds up joinrels incrementally
1455 * and so we'll see the minimally sufficient outerrels before any
1456 * supersets of them anyway.
1457 */
1461 uniqueRelInfo->self_join = self_join;
1464 uniqueRelInfo);
1466
1467 if (extra_clauses)
1468 *extra_clauses = outer_exprs;
1469 return true; /* Success! */
1470 }
1471 else
1472 {
1473 /*
1474 * None of the join conditions for outerrel proved innerrel unique, so
1475 * we can safely reject this outerrel or any subset of it in future
1476 * checks.
1477 *
1478 * However, in normal planning mode, caching this knowledge is totally
1479 * pointless; it won't be queried again, because we build up joinrels
1480 * from smaller to larger. It's only useful when using GEQO or
1481 * another planner extension that attempts planning multiple times.
1482 *
1483 * Also, allow callers to override that heuristic and force caching;
1484 * that's useful for reduce_unique_semijoins, which calls here before
1485 * the normal join search starts.
1486 */
1488 {
1490 innerrel->non_unique_for_rels =
1492 bms_copy(outerrelids));
1494 }
1495
1496 return false;
1497 }
1498}
static bool is_innerrel_unique_for(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, List **extra_clauses)
Definition analyzejoins.c:1506
static bool rel_supports_distinctness(PlannerInfo *root, RelOptInfo *rel)
Definition analyzejoins.c:951
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
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 1506 of file analyzejoins.c.
1513{
1516
1517 /*
1518 * Search for mergejoinable clauses that constrain the inner rel against
1519 * the outer rel. If an operator is mergejoinable then it behaves like
1520 * equality for some btree opclass, so it's what we want. The
1521 * mergejoinability test also eliminates clauses containing volatile
1522 * functions, which we couldn't depend on.
1523 */
1525 {
1527
1528 /*
1529 * As noted above, if it's a pushed-down clause and we're at an outer
1530 * join, we can't use it.
1531 */
1534 continue;
1535
1536 /* Ignore if it's not a mergejoinable clause */
1539 continue; /* not mergejoinable */
1540
1541 /*
1542 * Check if the clause has the form "outer op inner" or "inner op
1543 * outer", and if so mark which side is inner.
1544 */
1546 innerrel->relids))
1547 continue; /* no good for these input relations */
1548
1549 /* OK, add to the list */
1551 }
1552
1553 /* Let rel_is_distinct_for() do the hard work */
1555}
static bool rel_is_distinct_for(PlannerInfo *root, RelOptInfo *rel, List *clause_list, List **extra_clauses)
Definition analyzejoins.c:1011
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 158 of file analyzejoins.c.
159{
161 RelOptInfo *innerrel;
165 ListCell *l;
167
168 /*
169 * Must be a left join to a single baserel, else we aren't going to be
170 * able to do anything with it.
171 */
173 return false;
174
176 return false;
177
178 /*
179 * Never try to eliminate a left join to the query result rel. Although
180 * the case is syntactically impossible in standard SQL, MERGE will build
181 * a join tree that looks exactly like that.
182 */
184 return false;
185
187
188 /*
189 * Before we go to the effort of checking whether any innerrel variables
190 * are needed above the join, make a quick check to eliminate cases in
191 * which we will surely be unable to prove uniqueness of the innerrel.
192 */
194 return false;
195
196 /* Compute the relid set for the join we are considering */
201
202 /*
203 * We can't remove the join if any inner-rel attributes are used above the
204 * join. Here, "above" the join includes pushed-down conditions, so we
205 * should reject if attr_needed includes the OJ's own relid; therefore,
206 * compare to inputrelids not joinrelids.
207 *
208 * As a micro-optimization, it seems better to start with max_attr and
209 * count down rather than starting with min_attr and counting up, on the
210 * theory that the system attributes are somewhat less likely to be wanted
211 * and should be tested last.
212 */
214 attroff >= 0;
215 attroff--)
216 {
218 return false;
219 }
220
221 /*
222 * Similarly check that the inner rel isn't needed by any PlaceHolderVars
223 * that will be used above the join. The PHV case is a little bit more
224 * complicated, because PHVs may have been assigned a ph_eval_at location
225 * that includes the innerrel, yet their contained expression might not
226 * actually reference the innerrel (it could be just a constant, for
227 * instance). If such a PHV is due to be evaluated above the join then it
228 * needn't prevent join removal.
229 */
231 {
233
235 return false; /* it references innerrel laterally */
237 continue; /* it definitely doesn't reference innerrel */
239 continue; /* PHV is not used above the join */
241 return false; /* it has to be evaluated below the join */
242
243 /*
244 * We need to be sure there will still be a place to evaluate the PHV
245 * if we remove the join, ie that ph_eval_at wouldn't become empty.
246 */
248 return false; /* there isn't any other place to eval PHV */
249 /* Check contained expression last, since this is a bit expensive */
251 innerrel->relids))
252 return false; /* contained expression references innerrel */
253 }
254
255 /*
256 * Search for mergejoinable clauses that constrain the inner rel against
257 * either the outer rel or a pseudoconstant. If an operator is
258 * mergejoinable then it behaves like equality for some btree opclass, so
259 * it's what we want. The mergejoinability test also eliminates clauses
260 * containing volatile functions, which we couldn't depend on.
261 */
263 {
265
266 /*
267 * If the current join commutes with some other outer join(s) via
268 * outer join identity 3, there will be multiple clones of its join
269 * clauses in the joininfo list. We want to consider only the
270 * has_clone form of such clauses. Processing more than one form
271 * would be wasteful, and also some of the others would confuse the
272 * RINFO_IS_PUSHED_DOWN test below.
273 */
275 continue; /* ignore it */
276
277 /*
278 * If it's not a join clause for this outer join, we can't use it.
279 * Note that if the clause is pushed-down, then it is logically from
280 * above the outer join, even if it references no other rels (it might
281 * be from WHERE, for example).
282 */
284 continue; /* ignore; not useful here */
285
286 /* Ignore if it's not a mergejoinable clause */
289 continue; /* not mergejoinable */
290
291 /*
292 * Check if the clause has the form "outer op inner" or "inner op
293 * outer", and if so mark which side is inner.
294 */
296 innerrel->relids))
297 continue; /* no good for these input relations */
298
299 /* OK, add to list */
301 }
302
303 /*
304 * Now that we have the relevant equality join clauses, try to prove the
305 * innerrel distinct.
306 */
308 return true;
309
310 /*
311 * Some day it would be nice to check for other methods of establishing
312 * distinctness.
313 */
314 return false;
315}
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition bitmapset.c:708
Definition nodes.h:135
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 2127 of file analyzejoins.c.
2129{
2131 {
2132 Expr *clause;
2135 bool matched = false;
2136
2138
2139 /* Only filters like f(R.x1,...,R.xN) == expr we should consider. */
2141 bms_is_empty(rinfo->right_relids));
2142
2145 replace_relid_callback);
2146
2148 get_leftop(clause);
2150 get_rightop(clause);
2151
2152 /*
2153 * Compare these left and right sides with the corresponding sides of
2154 * the outer's filters. If no one is detected - return immediately.
2155 */
2157 {
2160
2162 /* Don't consider clauses that aren't similar to 'F(X)=G(Y)' */
2163 continue;
2164
2166
2171
2173 {
2174 matched = true;
2175 break;
2176 }
2177 }
2178
2179 if (!matched)
2180 return false;
2181 }
2182
2183 return true;
2184}
static bool replace_relid_callback(Node *node, ChangeVarNodes_context *context)
Definition analyzejoins.c:1750
void ChangeVarNodesExtended(Node *node, int rt_index, int new_index, int sublevels_up, ChangeVarNodes_callback callback)
Definition rewriteManip.c:678
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 1161 of file analyzejoins.c.
1162{
1163 ListCell *l;
1165
1166 /*
1167 * DISTINCT (including DISTINCT ON) guarantees uniqueness if all the
1168 * columns in the DISTINCT clause appear in colnos and operator semantics
1169 * match. This is true even if there are SRFs in the DISTINCT columns or
1170 * elsewhere in the tlist.
1171 */
1173 {
1175 {
1178 query->targetList);
1179
1185 break; /* exit early if no match */
1186 }
1188 return true;
1189 }
1190
1191 /*
1192 * Otherwise, a set-returning function in the query's targetlist can
1193 * result in returning duplicate rows, despite any grouping that might
1194 * occur before tlist evaluation. (If all tlist SRFs are within GROUP BY
1195 * columns, it would be safe because they'd be expanded before grouping.
1196 * But it doesn't currently seem worth the effort to check for that.)
1197 */
1198 if (query->hasTargetSRFs)
1199 return false;
1200
1201 /*
1202 * Similarly, GROUP BY without GROUPING SETS guarantees uniqueness if all
1203 * the grouped columns appear in colnos and operator semantics match.
1204 */
1206 {
1208 {
1211 query->targetList);
1212
1218 break; /* exit early if no match */
1219 }
1221 return true;
1222 }
1224 {
1225 List *gsets;
1226
1227 /*
1228 * If we have grouping sets with expressions, we probably don't have
1229 * uniqueness and analysis would be hard. Punt.
1230 */
1232 return false;
1233
1234 /*
1235 * If we have no groupClause (therefore no grouping expressions), we
1236 * might have one or many empty grouping sets. If there's just one,
1237 * or if the DISTINCT clause is used on the GROUP BY, then we're
1238 * returning only one row and are certainly unique. But otherwise, we
1239 * know we're certainly not unique.
1240 */
1242 return true;
1243
1245
1247 }
1248 else
1249 {
1250 /*
1251 * If we have no GROUP BY, but do have aggregates or HAVING, then the
1252 * result is at most one row so it's surely unique, for any operators.
1253 */
1255 return true;
1256 }
1257
1258 /*
1259 * UNION, INTERSECT, EXCEPT guarantee uniqueness of the whole output row,
1260 * except with ALL.
1261 */
1263 {
1265
1267
1269 {
1271
1272 /* We're good if all the nonjunk output columns are in colnos */
1275 {
1278
1280 continue; /* ignore resjunk columns */
1281
1282 /* non-resjunk columns should have grouping clauses */
1286
1292 break; /* exit early if no match */
1293 }
1295 return true;
1296 }
1297 }
1298
1299 /*
1300 * XXX Are there any other cases in which we can easily see the result
1301 * must be distinct?
1302 *
1303 * If you do add more smarts to this function, be sure to update
1304 * query_supports_distinctness() to match.
1305 */
1306
1307 return false;
1308}
static DistinctColInfo * distinct_col_search(int colno, List *distinct_cols)
Definition analyzejoins.c:1319
bool collations_agree_on_equality(Oid coll1, Oid coll2)
Definition lsyscache.c:886
bool equality_ops_are_compatible(Oid opno1, Oid opno2)
Definition lsyscache.c:773
List * expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
Definition parse_agg.c:2019
Definition parsenodes.h:2359
Definition parsenodes.h:1554
Definition primnodes.h:2275
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 1114 of file analyzejoins.c.
1115{
1116 /* SRFs break distinctness except with DISTINCT, see below */
1118 return false;
1119
1120 /* check for features we can prove distinctness with */
1124 query->hasAggs ||
1125 query->havingQual ||
1126 query->setOperations)
1127 return true;
1128
1129 return false;
1130}
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 875 of file analyzejoins.c.
876{
878
879 /*
880 * Scan the join_info_list to find semijoins.
881 */
883 {
886 RelOptInfo *innerrel;
888 List *restrictlist;
889
890 /*
891 * Must be a semijoin to a single baserel, else we aren't going to be
892 * able to do anything with it.
893 */
895 continue;
896
898 continue;
899
901
902 /*
903 * Before we trouble to run generate_join_implied_equalities, make a
904 * quick check to eliminate cases in which we will surely be unable to
905 * prove uniqueness of the innerrel.
906 */
908 continue;
909
910 /* Compute the relid set for the join we are considering */
913
914 /*
915 * Since we're only considering a single-rel RHS, any join clauses it
916 * has must be clauses linking it to the semijoin's min_lefthand. We
917 * can also consider EC-derived join clauses.
918 */
919 restrictlist =
921 joinrelids,
922 sjinfo->min_lefthand,
923 innerrel,
924 NULL),
925 innerrel->joininfo);
926
927 /* Test whether the innerrel is unique for those clauses. */
931 continue;
932
933 /* OK, remove the SpecialJoinInfo from the list. */
935 }
936}
bool innerrel_is_unique(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
Definition analyzejoins.c:1357
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 1011 of file analyzejoins.c.
1013{
1014 /*
1015 * We could skip a couple of tests here if we assume all callers checked
1016 * rel_supports_distinctness first, but it doesn't seem worth taking any
1017 * risk for.
1018 */
1020 return false;
1022 {
1023 /*
1024 * Examine the indexes to see if we have a matching unique index.
1025 * relation_has_unique_index_for automatically adds any usable
1026 * restriction clauses for the rel, so we needn't do that here.
1027 */
1029 return true;
1030 }
1032 {
1036 ListCell *l;
1037
1038 /*
1039 * Build the argument list for query_is_distinct_for: a list of
1040 * DistinctColInfo entries, each holding an output column number that
1041 * the query needs to be distinct over, the equality operator that the
1042 * column needs to be distinct according to, and that operator's input
1043 * collation. The collation matters because the subquery's own
1044 * DISTINCT / GROUP BY / set-op proves uniqueness under its own
1045 * collation, which need not agree with the operator's.
1046 *
1047 * (XXX we are not considering restriction clauses attached to the
1048 * subquery; is that worth doing?)
1049 */
1051 {
1053 OpExpr *opexpr;
1054 Var *var;
1056
1057 /*
1058 * The caller's mergejoinability test should have selected only
1059 * OpExprs. The operator might be a cross-type operator and thus
1060 * not exactly the same operator the subquery would consider;
1061 * that's all right since query_is_distinct_for can resolve such
1062 * cases.
1063 */
1065
1066 /* caller identified the inner side for us */
1067 if (rinfo->outer_is_left)
1069 else
1071
1072 /*
1073 * We may ignore any RelabelType node above the operand. (There
1074 * won't be more than one, since eval_const_expressions() has been
1075 * applied already.)
1076 */
1079
1080 /*
1081 * If inner side isn't a Var referencing a subquery output column,
1082 * this clause doesn't help us.
1083 */
1086 continue;
1087
1091 dcinfo->collid = opexpr->inputcollid;
1093 }
1094
1096 return true;
1097 }
1098 return false;
1099}
bool query_is_distinct_for(Query *query, List *distinct_cols)
Definition analyzejoins.c:1161
bool relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel, List *restrictlist, List **extra_clauses)
Definition indxpath.c:4144
Definition primnodes.h:847
Definition parsenodes.h:118
Definition primnodes.h:1217
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 951 of file analyzejoins.c.
952{
953 /* We only know about baserels ... */
955 return false;
957 {
958 /*
959 * For a plain relation, we only know how to prove uniqueness by
960 * reference to unique indexes. Make sure there's at least one
961 * suitable unique index. It must be immediately enforced, and not a
962 * partial index. (Keep these conditions in sync with
963 * relation_has_unique_index_for!)
964 */
966
968 {
970
972 return true;
973 }
974 }
976 {
978
979 /* Check if the subquery has any qualities that support distinctness */
981 return true;
982 }
983 /* We have no proof rules for any other rtekinds. */
984 return false;
985}
bool query_supports_distinctness(Query *query)
Definition analyzejoins.c:1114
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 326 of file analyzejoins.c.
328{
334 ListCell *l;
335
336 /* Compute the relid set for the join we are considering */
338 Assert(ojrelid != 0);
340
342
343 /*
344 * Remove any joinquals referencing the rel from the joininfo lists.
345 *
346 * In some cases, a joinqual has to be put back after deleting its
347 * reference to the target rel. This can occur for pseudoconstant and
348 * outerjoin-delayed quals, which can get marked as requiring the rel in
349 * order to force them to be evaluated at or above the join. We can't
350 * just discard them, though. Only quals that logically belonged to the
351 * outer join being discarded should be removed from the query.
352 *
353 * We might encounter a qual that is a clone of a deletable qual with some
354 * outer-join relids added (see deconstruct_distribute_oj_quals). To
355 * ensure we get rid of such clones as well, add the relids of all OJs
356 * commutable with this one to the set we test against for
357 * pushed-down-ness.
358 */
360 sjinfo->commute_above_r);
362 sjinfo->commute_below_l);
363
364 /*
365 * We must make a copy of the rel's old joininfo list before starting the
366 * loop, because otherwise remove_join_clause_from_rels would destroy the
367 * list while we're scanning it.
368 */
371 {
373
375
377 {
378 /*
379 * There might be references to relid or ojrelid in the
380 * RestrictInfo's relid sets, as a consequence of PHVs having had
381 * ph_eval_at sets that include those. We already checked above
382 * that any such PHV is safe (and updated its ph_eval_at), so we
383 * can just drop those references.
384 */
385 remove_rel_from_restrictinfo(rinfo, relid, ojrelid);
386
387 /*
388 * Cross-check that the clause itself does not reference the
389 * target rel or join.
390 */
391#ifdef USE_ASSERT_CHECKING
392 {
395
398 }
399#endif
400 /* Now throw it back into the joininfo lists */
402 }
403 }
404
405 /*
406 * There may be references to the rel in root->fkey_list, but if so,
407 * match_foreign_keys_to_quals() will get rid of them.
408 */
409
410 /*
411 * Now remove the rel from the baserel array to prevent it from being
412 * referenced again. (We can't do this earlier because
413 * remove_join_clause_from_rels will touch it.)
414 */
417
418 /* And nuke the RelOptInfo, just in case there's another access path */
419 pfree(rel);
420
421 /*
422 * Now repeat construction of attr_needed bits coming from all other
423 * sources.
424 */
429}
static void remove_rel_from_query(PlannerInfo *root, int relid, int subst, SpecialJoinInfo *sjinfo, Relids joinrelids)
Definition analyzejoins.c:449
static void remove_rel_from_restrictinfo(RestrictInfo *rinfo, int relid, int ojrelid)
Definition analyzejoins.c:682
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:901
void rebuild_eclass_attr_needed(PlannerInfo *root)
Definition equivclass.c:2573
void rebuild_lateral_attr_needed(PlannerInfo *root)
Definition initsplan.c:1194
void rebuild_joinclause_attr_needed(PlannerInfo *root)
Definition initsplan.c:3910
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 758 of file analyzejoins.c.
759{
761
762 /* Fix up the EC's overall relids */
765
766 /*
767 * We don't expect any EC child members to exist at this point. Ensure
768 * that's the case, otherwise, we might be getting asked to do something
769 * this function hasn't been coded for.
770 */
772
773 /*
774 * Fix up the member expressions. Any non-const member that ends with
775 * empty em_relids must be a Var or PHV of the removed relation. We don't
776 * need it anymore, so we can drop it.
777 */
779 {
781
784 {
786 /* em_relids is likely to be shared with some RestrictInfo */
792 }
793 }
794
795 /* Fix up the source clauses, in case we can re-use them later */
797 {
799
800 remove_rel_from_restrictinfo(rinfo, relid, ojrelid);
801 }
802
803 /*
804 * Rather than expend code on fixing up any already-derived clauses, just
805 * drop them. (At this point, any such clauses would be base restriction
806 * clauses, which we'd not need anymore anyway.)
807 */
808 ec_clear_derived_clauses(ec);
809}
void ec_clear_derived_clauses(EquivalenceClass *ec)
Definition equivclass.c:3830
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, lfirst, and remove_rel_from_restrictinfo().
Referenced by remove_rel_from_query().
◆ remove_rel_from_joinlist()
Definition at line 821 of file analyzejoins.c.
822{
825
827 {
829
831 {
833
834 if (varno == relid)
835 (*nremoved)++;
836 else
838 }
840 {
841 /* Recurse to handle subproblem */
843
845 relid, nremoved);
846 /* Avoid including empty sub-lists in the result */
849 }
850 else
851 {
854 }
855 }
856
858}
static List * remove_rel_from_joinlist(List *joinlist, int relid, int *nremoved)
Definition analyzejoins.c:821
Definition primnodes.h:2332
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_query()
|
static |
Definition at line 449 of file analyzejoins.c.
452{
454 Index rti;
455 ListCell *l;
458
462
463 /*
464 * Update all_baserels and related relid sets.
465 */
468
470 {
473 }
474
475 /*
476 * Likewise remove references from SpecialJoinInfo data structures.
477 *
478 * This is relevant in case the relation we're deleting is part of the
479 * relid sets of special joins: those sets have to be adjusted. If we are
480 * removing an outer join, the RHS of the target outer join will be made
481 * empty here, but that's OK since the caller will delete that
482 * SpecialJoinInfo entirely.
483 */
485 {
487
488 /*
489 * initsplan.c is fairly cavalier about allowing SpecialJoinInfos'
490 * lefthand/righthand relid sets to be shared with other data
491 * structures. Ensure that we don't modify the original relid sets.
492 * (The commute_xxx sets are always per-SpecialJoinInfo though.)
493 */
498
499 /* Now adjust relid bit in the sets: */
504
506 {
507 /* Remove ojrelid bit from the sets: */
512 /* relid cannot appear in these fields, but ojrelid can: */
517 }
518 else
519 {
520 /*
521 * For self-join removal, replace relid references in
522 * semi_rhs_exprs.
523 */
525 0, replace_relid_callback);
526 }
527 }
528
529 /*
530 * Likewise remove references from PlaceHolderVar data structures,
531 * removing any no-longer-needed placeholders entirely. We only remove
532 * PHVs for left-join removal. With self-join elimination, PHVs already
533 * get moved to the remaining relation, where they might still be needed.
534 * It might also happen that we skip the removal of some PHVs that could
535 * be removed. However, the overhead of extra PHVs is small compared to
536 * the complexity of analysis needed to remove them.
537 *
538 * Removal is a bit trickier than it might seem: we can remove PHVs that
539 * are used at the target rel and/or in the join qual, but not those that
540 * are used at join partner rels or above the join. It's not that easy to
541 * distinguish PHVs used at partner rels from those used in the join qual,
542 * since they will both have ph_needed sets that are subsets of
543 * joinrelids. However, a PHV used at a partner rel could not have the
544 * target rel in ph_eval_at, so we check that while deciding whether to
545 * remove or just update the PHV. There is no corresponding test in
546 * join_is_removable because it doesn't need to distinguish those cases.
547 */
549 {
551
553
558 {
560 l);
562 }
563 else
564 {
566
571
572 /* Reduce ph_needed to contain only "relation 0"; see below */
575 else
577
582
583 /*
584 * For self-join removal, update Var nodes within the PHV's
585 * expression to reference the replacement relid, and adjust
586 * ph_lateral for the relid substitution. (For left-join removal,
587 * we're removing rather than replacing, and any surviving PHV
588 * shouldn't reference the removed rel in its expression. Also,
589 * relid can't appear in ph_lateral for outer joins.)
590 */
592 {
594 replace_relid_callback);
596
597 /*
598 * ph_lateral might contain rels mentioned in ph_eval_at after
599 * the replacement, remove them.
600 */
602 /* ph_lateral might or might not be empty */
603 }
604
606 }
607 }
608
609 /*
610 * Likewise remove references from EquivalenceClasses.
611 *
612 * For self-join removal, the caller has already updated the
613 * EquivalenceClasses, so we can skip this step.
614 */
616 {
618 {
620
623 remove_rel_from_eclass(ec, relid, ojrelid);
624 }
625 }
626
627 /*
628 * Finally, we must prepare for the caller to recompute per-Var
629 * attr_needed and per-PlaceHolderVar ph_needed relid sets. These have to
630 * be known accurately, else we may fail to remove other now-removable
631 * joins. Because the caller removes the join clause(s) associated with
632 * the removed join, Vars that were formerly needed may no longer be.
633 *
634 * The actual reconstruction of these relid sets is performed by the
635 * specific caller. Here, we simply clear out the existing attr_needed
636 * sets (we already did this above for ph_needed) to ensure they are
637 * rebuilt from scratch. We can cheat to one small extent: we can avoid
638 * re-examining the targetlist and HAVING qual by preserving "relation 0"
639 * bits from the existing relid sets. This is safe because we'd never
640 * remove such references.
641 *
642 * Additionally, if we are performing self-join elimination, we must
643 * replace references to the removed relid with subst within the
644 * lateral_vars lists.
645 */
647 {
650
651 /* there may be empty slots corresponding to non-baserel RTEs */
653 continue;
654
656
658 attroff >= 0;
659 attroff--)
660 {
663 else
665 }
666
669 subst, 0, replace_relid_callback);
670 }
671}
static void remove_rel_from_eclass(EquivalenceClass *ec, int relid, int ojrelid)
Definition analyzejoins.c:758
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:346
Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid)
Definition rewriteManip.c:773
Definition pathnodes.h:1654
Definition pathnodes.h:3116
References adjust_relid_set(), Assert, bms_copy(), bms_del_member(), bms_difference(), bms_is_empty, bms_is_member(), bms_is_subset(), bms_make_singleton(), ChangeVarNodesExtended(), EquivalenceClass::ec_relids, fb(), foreach_delete_current, lfirst, SpecialJoinInfo::min_lefthand, SpecialJoinInfo::ojrelid, remove_rel_from_eclass(), replace_relid_callback(), and root.
Referenced by remove_leftjoinrel_from_query(), and remove_self_join_rel().
◆ remove_rel_from_restrictinfo()
|
static |
Definition at line 682 of file analyzejoins.c.
683{
684 /*
685 * initsplan.c is fairly cavalier about allowing RestrictInfos to share
686 * relid sets with other RestrictInfos, and SpecialJoinInfos too. Make
687 * sure this RestrictInfo has its own relid sets before we modify them.
688 * (In present usage, clause_relids is probably not shared, but
689 * required_relids could be; let's not assume anything.)
690 */
691 rinfo->clause_relids = bms_copy(rinfo->clause_relids);
692 rinfo->clause_relids = bms_del_member(rinfo->clause_relids, relid);
693 rinfo->clause_relids = bms_del_member(rinfo->clause_relids, ojrelid);
694 /* Likewise for required_relids */
698 /* Likewise for incompatible_relids */
702 /* Likewise for outer_relids */
706 /* Likewise for left_relids */
707 rinfo->left_relids = bms_copy(rinfo->left_relids);
708 rinfo->left_relids = bms_del_member(rinfo->left_relids, relid);
709 rinfo->left_relids = bms_del_member(rinfo->left_relids, ojrelid);
710 /* Likewise for right_relids */
711 rinfo->right_relids = bms_copy(rinfo->right_relids);
712 rinfo->right_relids = bms_del_member(rinfo->right_relids, relid);
713 rinfo->right_relids = bms_del_member(rinfo->right_relids, ojrelid);
714
715 /* If it's an OR, recurse to clean up sub-clauses */
717 {
719
722 {
724
725 /* OR arguments should be ANDs or sub-RestrictInfos */
727 {
730
732 {
734
736 }
737 }
738 else
739 {
741
743 }
744 }
745 }
746}
bool restriction_is_or_clause(RestrictInfo *restrictinfo)
Definition restrictinfo.c:407
Definition primnodes.h:968
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_self_join_rel()
|
static |
Definition at line 1874 of file analyzejoins.c.
1877{
1883
1886
1887 /*
1888 * Replace the index of the removing table with the keeping one. The
1889 * technique of removing/distributing restrictinfo is used here to attach
1890 * just appeared (for keeping relation) join clauses and avoid adding
1891 * duplicates of those that already exist in the joininfo list.
1892 */
1895 {
1898 0, replace_relid_callback);
1899
1902 else
1904 }
1905
1906 /*
1907 * Concatenate restrictlist to the list of base restrictions of the
1908 * removing table just to simplify the replacement procedure: all of them
1909 * weren't connected to any keeping relations and need to be added to some
1910 * rels.
1911 */
1913 restrictlist);
1915 {
1917 0, replace_relid_callback);
1918
1921 else
1923 }
1924
1925 /*
1926 * Now, add all non-redundant clauses to the keeping relation.
1927 */
1932
1935
1936 /*
1937 * Arrange equivalence classes, mentioned removing a table, with the
1938 * keeping one: varno of removing table should be replaced in members and
1939 * sources lists. Also, remove duplicated elements if this replacement
1940 * procedure created them.
1941 */
1942 i = -1;
1944 {
1946
1949 }
1950
1951 /*
1952 * Transfer the targetlist and attr_needed flags.
1953 */
1954
1956 {
1958
1960 replace_relid_callback);
1963 }
1964
1966 {
1968
1972 toRemove->attr_needed[attno]);
1973 }
1974
1975 /*
1976 * If the removed relation has a row mark, transfer it to the remaining
1977 * one.
1978 *
1979 * If both rels have row marks, just keep the one corresponding to the
1980 * remaining relation because we verified earlier that they have the same
1981 * strength.
1982 */
1984 {
1986 {
1988
1990 }
1991 else
1992 {
1993 /* Shouldn't have inheritance children here. */
1995
1997 }
1998 }
1999
2000 /*
2001 * Replace varno in all the query structures, except nodes RangeTblRef
2002 * otherwise later remove_rel_from_joinlist will yield errors.
2003 */
2005 0, replace_relid_callback);
2006
2007 /* Replace links in the planner info */
2009
2010 /* Replace varno in the fully-processed targetlist */
2013
2014 /*
2015 * No need to touch all_result_relids or leaf_result_relids: at this point
2016 * those sets contain only parse->resultRelation; inheritance children
2017 * have not been added yet; that happens later in add_other_rels_to_query.
2018 * And remove_self_joins_recurse rejects parse->resultRelation as an SJE
2019 * candidate to preserve the EPQ mechanism. So toRemove->relid cannot be
2020 * a member.
2021 */
2024
2025 /*
2026 * There may be references to the rel in root->fkey_list, but if so,
2027 * match_foreign_keys_to_quals() will get rid of them.
2028 */
2029
2030 /*
2031 * Finally, remove the rel from the baserel array to prevent it from being
2032 * referenced again. (We can't do this earlier because
2033 * remove_join_clause_from_rels will touch it.)
2034 */
2037
2038 /* And nuke the RelOptInfo, just in case there's another access path. */
2040
2041
2042 /*
2043 * Now repeat construction of attr_needed bits coming from all other
2044 * sources.
2045 */
2050}
static void add_non_redundant_clauses(PlannerInfo *root, List *rinfo_candidates, List **keep_rinfo_list, Index removed_relid)
Definition analyzejoins.c:1706
static void update_eclasses(EquivalenceClass *ec, int from, int to)
Definition analyzejoins.c:1580
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 2193 of file analyzejoins.c.
2194{
2196 int k; /* Index of kept relation */
2197 int r = -1; /* Index of removed relation */
2198
2200 {
2202
2203 k = r;
2204
2206 {
2209 List *restrictlist;
2217
2218 /* A sanity check: the relations have the same Oid. */
2220 root->simple_rte_array[r]->relid);
2221
2222 /*
2223 * It is impossible to eliminate the join of two relations if they
2224 * belong to different rules of order. Otherwise, the planner
2225 * can't find any variants of the correct query plan.
2226 */
2228 {
2230
2235 {
2237 break;
2238 }
2239 }
2241 continue;
2242
2243 /*
2244 * Check Row Marks equivalence. We can't remove the join if the
2245 * relations have row marks of different strength (e.g., one is
2246 * locked FOR UPDATE, and another just has ROW_MARK_REFERENCE for
2247 * EvalPlanQual rechecking).
2248 */
2250 {
2252
2254 {
2257 }
2259 {
2262 }
2263
2265 break;
2266 }
2268 continue;
2269
2270 /*
2271 * We only deal with base rels here, so their relids bitset
2272 * contains only one member -- their relid.
2273 */
2276
2277 /*
2278 * PHVs should not impose any constraints on removing self-joins.
2279 */
2280
2281 /*
2282 * At this stage, joininfo lists of inner and outer can contain
2283 * only clauses required for a superior outer join that can't
2284 * influence this optimization. So, we can avoid to call the
2285 * build_joinrel_restrictlist() routine.
2286 */
2288 rrel->relids,
2291 continue;
2292
2293 /*
2294 * Process restrictlist to separate the self-join quals from the
2295 * other quals. e.g., "x = x" goes to selfjoinquals and "a = b" to
2296 * otherjoinquals.
2297 */
2300
2303
2304 /*
2305 * To enable SJE for the only degenerate case without any self
2306 * join clauses at all, add baserestrictinfo to this list. The
2307 * degenerate case works only if both sides have the same clause.
2308 * So doesn't matter which side to add.
2309 */
2311
2312 /*
2313 * Determine if the rrel can duplicate outer rows. We must bypass
2314 * the unique rel cache here since we're possibly using a subset
2315 * of join quals. We can use 'force_cache' == true when all join
2316 * quals are self-join quals. Otherwise, we could end up putting
2317 * false negatives in the cache.
2318 */
2322 &uclauses))
2323 continue;
2324
2325 /*
2326 * 'uclauses' is the copy of outer->baserestrictinfo that are
2327 * associated with an index. We proved by matching selfjoinquals
2328 * to a unique index that the outer relation has at most one
2329 * matching row for each inner row. Sometimes that is not enough.
2330 * e.g. "WHERE s1.b = s2.b AND s1.a = 1 AND s2.a = 2" when the
2331 * unique index is (a,b). Having non-empty uclauses, we must
2332 * validate that the inner baserestrictinfo contains the same
2333 * expressions, or we won't match the same row on each side of the
2334 * join.
2335 */
2337 continue;
2338
2339 /*
2340 * Remove rrel RelOptInfo from the planner structures and the
2341 * corresponding row mark.
2342 */
2344
2346
2347 /* We have removed the outer relation, try the next one. */
2348 break;
2349 }
2350 }
2351
2353}
static bool match_unique_clauses(PlannerInfo *root, RelOptInfo *outer, List *uclauses, Index relid)
Definition analyzejoins.c:2127
static void split_selfjoin_quals(PlannerInfo *root, List *joinquals, List **selfjoinquals, List **otherjoinquals, int from, int to)
Definition analyzejoins.c:2062
static void remove_self_join_rel(PlannerInfo *root, PlanRowMark *kmark, PlanRowMark *rmark, RelOptInfo *toKeep, RelOptInfo *toRemove, List *restrictlist)
Definition analyzejoins.c:1874
Definition plannodes.h:1606
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 2360 of file analyzejoins.c.
2361{
2368
2369 /* Collect indexes of base relations of the join tree */
2371 {
2373
2375 {
2378
2379 /*
2380 * We only consider ordinary relations as candidates to be
2381 * removed, and these relations should not have TABLESAMPLE
2382 * clauses specified. Removing a relation with TABLESAMPLE clause
2383 * could potentially change the syntax of the query. Because of
2384 * UPDATE/DELETE EPQ mechanism, currently Query->resultRelation or
2385 * Query->mergeTargetRelation associated rel cannot be eliminated.
2386 */
2390 varno != root->parse->resultRelation &&
2391 varno != root->parse->mergeTargetRelation)
2392 {
2394 relids = bms_add_member(relids, varno);
2395 }
2396 }
2398 {
2399 /* Recursively go inside the sub-joinlist */
2401 toRemove);
2402 }
2403 else
2406 }
2407
2409
2410 /* Need at least two relations for the join */
2413
2414 /*
2415 * In order to find relations with the same oid we first build an array of
2416 * candidates and then sort it by oid.
2417 */
2419 i = -1;
2420 j = 0;
2422 {
2425 j++;
2426 }
2427
2429 self_join_candidates_cmp);
2430
2431 /*
2432 * Iteratively form a group of relation indexes with the same oid and
2433 * launch the routine that detects self-joins in this group and removes
2434 * excessive range table entries.
2435 *
2436 * At the end of the iteration, exclude the group from the overall relids
2437 * list. So each next iteration of the cycle will involve less and less
2438 * value of relids.
2439 */
2440 i = 0;
2442 {
2444 {
2446 {
2447 /* Create a group of relation indexes with the same oid */
2450
2452 {
2454 i++;
2455 }
2456 relids = bms_del_members(relids, group);
2457
2458 /*
2459 * Try to remove self-joins from a group of identical entries.
2460 * Make the next attempt iteratively - if something is deleted
2461 * from a group, changes in clauses and equivalence classes
2462 * can give us a chance to find more candidates.
2463 */
2464 do
2465 {
2473 bms_free(group);
2474 }
2475 else
2476 {
2477 /* Single relation, just remove it from the set */
2480 }
2481 }
2482 }
2483
2485
2487}
static int self_join_candidates_cmp(const void *a, const void *b)
Definition analyzejoins.c:2493
static Relids remove_self_joins_one_group(PlannerInfo *root, Relids relids)
Definition analyzejoins.c:2193
static Relids remove_self_joins_recurse(PlannerInfo *root, List *joinlist, Relids toRemove)
Definition analyzejoins.c:2360
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1145
Definition parsenodes.h:1138
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 93 of file analyzejoins.c.
94{
96
97 /*
98 * We are only interested in relations that are left-joined to, so we can
99 * scan the join_info_list to find them easily.
100 */
101restart:
103 {
107
108 /* Skip if not removable */
110 continue;
111
112 /*
113 * Currently, join_is_removable can only succeed when the sjinfo's
114 * righthand is a single baserel. Remove that rel from the query and
115 * joinlist.
116 */
118
120
121 /* We verify that exactly one reference gets removed from joinlist */
122 nremoved = 0;
126
127 /*
128 * We can delete this SpecialJoinInfo from the list too, since it's no
129 * longer of interest. (Since we'll restart the foreach loop
130 * immediately, we don't bother with foreach_delete_current.)
131 */
133
134 /*
135 * Restart the scan. This is necessary to ensure we find all
136 * removable joins independently of ordering of the join_info_list
137 * (note that removal of attr_needed bits may make a join appear
138 * removable that did not before).
139 */
140 goto restart;
141 }
142
144}
static void remove_leftjoinrel_from_query(PlannerInfo *root, int relid, SpecialJoinInfo *sjinfo)
Definition analyzejoins.c:326
static bool join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo)
Definition analyzejoins.c:158
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 2540 of file analyzejoins.c.
2541{
2543 int relid = -1;
2544
2548
2549 /*
2550 * Merge pairs of relations participated in self-join. Remove unnecessary
2551 * range table entries.
2552 */
2554
2556 {
2557 /* At the end, remove orphaned relation links */
2559 {
2561
2565 }
2566 }
2567
2569}
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 1750 of file analyzejoins.c.
1751{
1753 {
1754 return true;
1755 }
1757 {
1759 int relid = -1;
1761 (rinfo->required_relids == rinfo->clause_relids);
1764
1765 /*
1766 * Recurse down into clauses if the target relation is present in
1767 * clause_relids or required_relids. We must check required_relids
1768 * because the relation not present in clause_relids might still be
1769 * present somewhere in orclause.
1770 */
1773 {
1775
1778
1780 context->rt_index,
1781 context->new_index);
1782
1783 /*
1784 * Incrementally adjust num_base_rels based on the change of
1785 * clause_relids, which could contain both base relids and
1786 * outer-join relids. This operation is legal until we remove
1787 * only baserels.
1788 */
1789 rinfo->num_base_rels -= bms_num_members(rinfo->clause_relids) -
1791
1792 rinfo->clause_relids = new_clause_relids;
1793 rinfo->left_relids =
1795 rinfo->right_relids =
1797 }
1798
1800 rinfo->required_relids = rinfo->clause_relids;
1801 else
1802 rinfo->required_relids =
1804
1805 rinfo->outer_relids =
1807 rinfo->incompatible_relids =
1809
1810 if (rinfo->mergeopfamilies &&
1811 bms_get_singleton_member(rinfo->clause_relids, &relid) &&
1812 clause_relids_is_multiple &&
1814 {
1817
1820
1821 /*
1822 * For self-join elimination, changing varnos could transform
1823 * "t1.a = t2.a" into "t1.a = t1.a". That is always true as long
1824 * as "t1.a" is not null. We use equal() to check for such a
1825 * case, and then we replace the qual with a check for not null
1826 * (NullTest).
1827 */
1829 {
1831
1835 ntest->location = -1;
1837 rinfo->mergeopfamilies = NIL;
1838 rinfo->left_em = NULL;
1839 rinfo->right_em = NULL;
1840 }
1842 }
1843 return true;
1844 }
1845
1846 return false;
1847}
bool ChangeVarNodesWalkExpression(Node *node, ChangeVarNodes_context *context)
Definition rewriteManip.c:758
Definition primnodes.h:1996
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 1680 of file analyzejoins.c.
1681{
1684
1688
1690}
References a, b, equal(), fb(), and result.
Referenced by add_non_redundant_clauses().
◆ self_join_candidates_cmp()
Definition at line 2493 of file analyzejoins.c.
2494{
2497
2500 else
2501 return 0;
2502}
References a, b, fb(), and SelfJoinCandidate::reloid.
Referenced by remove_self_joins_recurse().
◆ split_selfjoin_quals()
|
static |
Definition at line 2062 of file analyzejoins.c.
2064{
2067
2069 {
2070 OpExpr *expr;
2073
2074 /* In general, clause looks like F(arg1) = G(arg2) */
2075 if (!rinfo->mergeopfamilies ||
2076 bms_num_members(rinfo->clause_relids) != 2 ||
2079 {
2081 continue;
2082 }
2083
2084 expr = (OpExpr *) rinfo->clause;
2085
2087 {
2089 continue;
2090 }
2091
2094
2099
2100 /*
2101 * Quite an expensive operation, narrowing the use case. For example,
2102 * when we have cast of the same var to different (but compatible)
2103 * types.
2104 */
2106 bms_singleton_member(rinfo->right_relids),
2107 bms_singleton_member(rinfo->left_relids), 0,
2108 replace_relid_callback);
2109
2112 else
2114 }
2115
2118}
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 1580 of file analyzejoins.c.
1581{
1584
1585 /*
1586 * We don't expect any EC child members to exist at this point. Ensure
1587 * that's the case, otherwise, we might be getting asked to do something
1588 * this function hasn't been coded for.
1589 */
1591
1593 {
1595
1597 {
1599 continue;
1600 }
1601
1604
1605 /* We only process inner joins */
1607 replace_relid_callback);
1608
1610 {
1612 continue;
1613
1615 {
1617 break;
1618 }
1619 }
1620
1623 }
1624
1627
1628 ec_clear_derived_clauses(ec);
1629
1630 /* Update EC source expressions */
1632 {
1634
1636 {
1638 continue;
1639 }
1640
1642 replace_relid_callback);
1643
1644 /*
1645 * After switching the clause to the remaining relation, check it for
1646 * redundancy with existing ones. We don't have to check for
1647 * redundancy with derived clauses, because we've just deleted them.
1648 */
1650 {
1652 continue;
1653
1655 {
1657 break;
1658 }
1659 }
1660
1663 }
1664
1668}
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().
