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 1687 of file analyzejoins.c.
1691{
1693 {
1695
1697
1699 {
1701 /* Can't compare trivially different clauses */
1702 continue;
1703
1704 if (src == rinfo ||
1705 (rinfo->parent_ec != NULL &&
1706 src->parent_ec == rinfo->parent_ec) ||
1707 restrict_infos_logically_equal(rinfo, src))
1708 {
1710 break;
1711 }
1712 }
1715 }
1716}
static bool restrict_infos_logically_equal(RestrictInfo *a, RestrictInfo *b)
Definition analyzejoins.c:1661
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()
Definition at line 1298 of file analyzejoins.c.
References fb(), forboth, InvalidOid, lfirst_int, and lfirst_oid.
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 1338 of file analyzejoins.c.
1345{
1348}
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:1360
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 1360 of file analyzejoins.c.
1368{
1374
1375 /* Certainly can't prove uniqueness when there are no joinclauses */
1377 return false;
1378
1379 /*
1380 * Make a quick check to eliminate cases in which we will surely be unable
1381 * to prove uniqueness of the innerrel.
1382 */
1384 return false;
1385
1386 /*
1387 * Query the cache to see if we've managed to prove that innerrel is
1388 * unique for any subset of this outerrel. For non-self-join search, we
1389 * don't need an exact match, as extra outerrels can't make the innerrel
1390 * any less unique (or more formally, the restrictlist for a join to a
1391 * superset outerrel must be a superset of the conditions we successfully
1392 * used before). For self-join search, we require an exact match of
1393 * outerrels because we need extra clauses to be valid for our case. Also,
1394 * for self-join checking we've filtered the clauses list. Thus, we can
1395 * match only the result cached for a self-join search for another
1396 * self-join check.
1397 */
1399 {
1401
1404 uniqueRelInfo->self_join))
1405 {
1406 if (extra_clauses)
1407 *extra_clauses = uniqueRelInfo->extra_clauses;
1408 return true; /* Success! */
1409 }
1410 }
1411
1412 /*
1413 * Conversely, we may have already determined that this outerrel, or some
1414 * superset thereof, cannot prove this innerrel to be unique.
1415 */
1417 {
1419
1421 return false;
1422 }
1423
1424 /* No cached information, so try to make the proof. */
1426 jointype, restrictlist,
1428 {
1429 /*
1430 * Cache the positive result for future probes, being sure to keep it
1431 * in the planner_cxt even if we are working in GEQO.
1432 *
1433 * Note: one might consider trying to isolate the minimal subset of
1434 * the outerrels that proved the innerrel unique. But it's not worth
1435 * the trouble, because the planner builds up joinrels incrementally
1436 * and so we'll see the minimally sufficient outerrels before any
1437 * supersets of them anyway.
1438 */
1442 uniqueRelInfo->self_join = self_join;
1445 uniqueRelInfo);
1447
1448 if (extra_clauses)
1449 *extra_clauses = outer_exprs;
1450 return true; /* Success! */
1451 }
1452 else
1453 {
1454 /*
1455 * None of the join conditions for outerrel proved innerrel unique, so
1456 * we can safely reject this outerrel or any subset of it in future
1457 * checks.
1458 *
1459 * However, in normal planning mode, caching this knowledge is totally
1460 * pointless; it won't be queried again, because we build up joinrels
1461 * from smaller to larger. It's only useful when using GEQO or
1462 * another planner extension that attempts planning multiple times.
1463 *
1464 * Also, allow callers to override that heuristic and force caching;
1465 * that's useful for reduce_unique_semijoins, which calls here before
1466 * the normal join search starts.
1467 */
1469 {
1471 innerrel->non_unique_for_rels =
1473 bms_copy(outerrelids));
1475 }
1476
1477 return false;
1478 }
1479}
static bool is_innerrel_unique_for(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, List **extra_clauses)
Definition analyzejoins.c:1487
static bool rel_supports_distinctness(PlannerInfo *root, RelOptInfo *rel)
Definition analyzejoins.c:949
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:3818
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 1487 of file analyzejoins.c.
1494{
1497
1498 /*
1499 * Search for mergejoinable clauses that constrain the inner rel against
1500 * the outer rel. If an operator is mergejoinable then it behaves like
1501 * equality for some btree opclass, so it's what we want. The
1502 * mergejoinability test also eliminates clauses containing volatile
1503 * functions, which we couldn't depend on.
1504 */
1506 {
1508
1509 /*
1510 * As noted above, if it's a pushed-down clause and we're at an outer
1511 * join, we can't use it.
1512 */
1515 continue;
1516
1517 /* Ignore if it's not a mergejoinable clause */
1520 continue; /* not mergejoinable */
1521
1522 /*
1523 * Check if the clause has the form "outer op inner" or "inner op
1524 * outer", and if so mark which side is inner.
1525 */
1527 innerrel->relids))
1528 continue; /* no good for these input relations */
1529
1530 /* OK, add to the list */
1532 }
1533
1534 /* Let rel_is_distinct_for() do the hard work */
1536}
static bool rel_is_distinct_for(PlannerInfo *root, RelOptInfo *rel, List *clause_list, List **extra_clauses)
Definition analyzejoins.c:1009
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:3405
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 2100 of file analyzejoins.c.
2102{
2104 {
2105 Expr *clause;
2108 bool matched = false;
2109
2111
2112 /* Only filters like f(R.x1,...,R.xN) == expr we should consider. */
2114 bms_is_empty(rinfo->right_relids));
2115
2118 replace_relid_callback);
2119
2121 get_leftop(clause);
2123 get_rightop(clause);
2124
2125 /*
2126 * Compare these left and right sides with the corresponding sides of
2127 * the outer's filters. If no one is detected - return immediately.
2128 */
2130 {
2133
2135 /* Don't consider clauses that aren't similar to 'F(X)=G(Y)' */
2136 continue;
2137
2139
2144
2146 {
2147 matched = true;
2148 break;
2149 }
2150 }
2151
2152 if (!matched)
2153 return false;
2154 }
2155
2156 return true;
2157}
static bool replace_relid_callback(Node *node, ChangeVarNodes_context *context)
Definition analyzejoins.c:1731
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 1145 of file analyzejoins.c.
1146{
1147 ListCell *l;
1149
1151
1152 /*
1153 * DISTINCT (including DISTINCT ON) guarantees uniqueness if all the
1154 * columns in the DISTINCT clause appear in colnos and operator semantics
1155 * match. This is true even if there are SRFs in the DISTINCT columns or
1156 * elsewhere in the tlist.
1157 */
1159 {
1161 {
1164 query->targetList);
1165
1169 break; /* exit early if no match */
1170 }
1172 return true;
1173 }
1174
1175 /*
1176 * Otherwise, a set-returning function in the query's targetlist can
1177 * result in returning duplicate rows, despite any grouping that might
1178 * occur before tlist evaluation. (If all tlist SRFs are within GROUP BY
1179 * columns, it would be safe because they'd be expanded before grouping.
1180 * But it doesn't currently seem worth the effort to check for that.)
1181 */
1182 if (query->hasTargetSRFs)
1183 return false;
1184
1185 /*
1186 * Similarly, GROUP BY without GROUPING SETS guarantees uniqueness if all
1187 * the grouped columns appear in colnos and operator semantics match.
1188 */
1190 {
1192 {
1195 query->targetList);
1196
1200 break; /* exit early if no match */
1201 }
1203 return true;
1204 }
1206 {
1207 List *gsets;
1208
1209 /*
1210 * If we have grouping sets with expressions, we probably don't have
1211 * uniqueness and analysis would be hard. Punt.
1212 */
1214 return false;
1215
1216 /*
1217 * If we have no groupClause (therefore no grouping expressions), we
1218 * might have one or many empty grouping sets. If there's just one,
1219 * or if the DISTINCT clause is used on the GROUP BY, then we're
1220 * returning only one row and are certainly unique. But otherwise, we
1221 * know we're certainly not unique.
1222 */
1224 return true;
1225
1227
1229 }
1230 else
1231 {
1232 /*
1233 * If we have no GROUP BY, but do have aggregates or HAVING, then the
1234 * result is at most one row so it's surely unique, for any operators.
1235 */
1237 return true;
1238 }
1239
1240 /*
1241 * UNION, INTERSECT, EXCEPT guarantee uniqueness of the whole output row,
1242 * except with ALL.
1243 */
1245 {
1247
1249
1251 {
1253
1254 /* We're good if all the nonjunk output columns are in colnos */
1257 {
1260
1262 continue; /* ignore resjunk columns */
1263
1264 /* non-resjunk columns should have grouping clauses */
1268
1272 break; /* exit early if no match */
1273 }
1275 return true;
1276 }
1277 }
1278
1279 /*
1280 * XXX Are there any other cases in which we can easily see the result
1281 * must be distinct?
1282 *
1283 * If you do add more smarts to this function, be sure to update
1284 * query_supports_distinctness() to match.
1285 */
1286
1287 return false;
1288}
static Oid distinct_col_search(int colno, List *colnos, List *opids)
Definition analyzejoins.c:1298
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:2263
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition tlist.c:376
References Assert, castNode, distinct_col_search(), Query::distinctClause, equality_ops_are_compatible(), expand_grouping_sets(), fb(), get_sortgroupclause_tle(), Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, lfirst, list_head(), list_length(), lnext(), OidIsValid, SETOP_NONE, Query::setOperations, and Query::targetList.
Referenced by rel_is_distinct_for().
◆ query_supports_distinctness()
Definition at line 1107 of file analyzejoins.c.
1108{
1109 /* SRFs break distinctness except with DISTINCT, see below */
1111 return false;
1112
1113 /* check for features we can prove distinctness with */
1117 query->hasAggs ||
1118 query->havingQual ||
1119 query->setOperations)
1120 return true;
1121
1122 return false;
1123}
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 873 of file analyzejoins.c.
874{
876
877 /*
878 * Scan the join_info_list to find semijoins.
879 */
881 {
884 RelOptInfo *innerrel;
886 List *restrictlist;
887
888 /*
889 * Must be a semijoin to a single baserel, else we aren't going to be
890 * able to do anything with it.
891 */
893 continue;
894
896 continue;
897
899
900 /*
901 * Before we trouble to run generate_join_implied_equalities, make a
902 * quick check to eliminate cases in which we will surely be unable to
903 * prove uniqueness of the innerrel.
904 */
906 continue;
907
908 /* Compute the relid set for the join we are considering */
911
912 /*
913 * Since we're only considering a single-rel RHS, any join clauses it
914 * has must be clauses linking it to the semijoin's min_lefthand. We
915 * can also consider EC-derived join clauses.
916 */
917 restrictlist =
919 joinrelids,
920 sjinfo->min_lefthand,
921 innerrel,
922 NULL),
923 innerrel->joininfo);
924
925 /* Test whether the innerrel is unique for those clauses. */
929 continue;
930
931 /* OK, remove the SpecialJoinInfo from the list. */
933 }
934}
bool innerrel_is_unique(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
Definition analyzejoins.c:1338
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 1009 of file analyzejoins.c.
1011{
1012 /*
1013 * We could skip a couple of tests here if we assume all callers checked
1014 * rel_supports_distinctness first, but it doesn't seem worth taking any
1015 * risk for.
1016 */
1018 return false;
1020 {
1021 /*
1022 * Examine the indexes to see if we have a matching unique index.
1023 * relation_has_unique_index_for automatically adds any usable
1024 * restriction clauses for the rel, so we needn't do that here.
1025 */
1027 return true;
1028 }
1030 {
1035 ListCell *l;
1036
1037 /*
1038 * Build the argument lists for query_is_distinct_for: a list of
1039 * output column numbers that the query needs to be distinct over, and
1040 * a list of equality operators that the output columns need to be
1041 * distinct according to.
1042 *
1043 * (XXX we are not considering restriction clauses attached to the
1044 * subquery; is that worth doing?)
1045 */
1047 {
1049 Oid op;
1050 Var *var;
1051
1052 /*
1053 * Get the equality operator we need uniqueness according to.
1054 * (This might be a cross-type operator and thus not exactly the
1055 * same operator the subquery would consider; that's all right
1056 * since query_is_distinct_for can resolve such cases.) The
1057 * caller's mergejoinability test should have selected only
1058 * OpExprs.
1059 */
1061
1062 /* caller identified the inner side for us */
1063 if (rinfo->outer_is_left)
1065 else
1067
1068 /*
1069 * We may ignore any RelabelType node above the operand. (There
1070 * won't be more than one, since eval_const_expressions() has been
1071 * applied already.)
1072 */
1075
1076 /*
1077 * If inner side isn't a Var referencing a subquery output column,
1078 * this clause doesn't help us.
1079 */
1082 continue;
1083
1086 }
1087
1089 return true;
1090 }
1091 return false;
1092}
bool query_is_distinct_for(Query *query, List *colnos, List *opids)
Definition analyzejoins.c:1145
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_int(), lappend_oid(), lfirst_node, NIL, 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 949 of file analyzejoins.c.
950{
951 /* We only know about baserels ... */
953 return false;
955 {
956 /*
957 * For a plain relation, we only know how to prove uniqueness by
958 * reference to unique indexes. Make sure there's at least one
959 * suitable unique index. It must be immediately enforced, and not a
960 * partial index. (Keep these conditions in sync with
961 * relation_has_unique_index_for!)
962 */
964
966 {
968
970 return true;
971 }
972 }
974 {
976
977 /* Check if the subquery has any qualities that support distinctness */
979 return true;
980 }
981 /* We have no proof rules for any other rtekinds. */
982 return false;
983}
bool query_supports_distinctness(Query *query)
Definition analyzejoins.c:1107
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 {
790 }
791 }
792
793 /* Fix up the source clauses, in case we can re-use them later */
795 {
797
798 remove_rel_from_restrictinfo(rinfo, relid, ojrelid);
799 }
800
801 /*
802 * Rather than expend code on fixing up any already-derived clauses, just
803 * drop them. (At this point, any such clauses would be base restriction
804 * clauses, which we'd not need anymore anyway.)
805 */
806 ec_clear_derived_clauses(ec);
807}
void ec_clear_derived_clauses(EquivalenceClass *ec)
Definition equivclass.c:3830
Definition pathnodes.h:1715
References Assert, 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 819 of file analyzejoins.c.
820{
823
825 {
827
829 {
831
832 if (varno == relid)
833 (*nremoved)++;
834 else
836 }
838 {
839 /* Recurse to handle subproblem */
841
843 relid, nremoved);
844 /* Avoid including empty sub-lists in the result */
847 }
848 else
849 {
852 }
853 }
854
856}
static List * remove_rel_from_joinlist(List *joinlist, int relid, int *nremoved)
Definition analyzejoins.c:819
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_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 1855 of file analyzejoins.c.
1858{
1864
1867
1868 /*
1869 * Replace the index of the removing table with the keeping one. The
1870 * technique of removing/distributing restrictinfo is used here to attach
1871 * just appeared (for keeping relation) join clauses and avoid adding
1872 * duplicates of those that already exist in the joininfo list.
1873 */
1876 {
1879 0, replace_relid_callback);
1880
1883 else
1885 }
1886
1887 /*
1888 * Concatenate restrictlist to the list of base restrictions of the
1889 * removing table just to simplify the replacement procedure: all of them
1890 * weren't connected to any keeping relations and need to be added to some
1891 * rels.
1892 */
1894 restrictlist);
1896 {
1898 0, replace_relid_callback);
1899
1902 else
1904 }
1905
1906 /*
1907 * Now, add all non-redundant clauses to the keeping relation.
1908 */
1913
1916
1917 /*
1918 * Arrange equivalence classes, mentioned removing a table, with the
1919 * keeping one: varno of removing table should be replaced in members and
1920 * sources lists. Also, remove duplicated elements if this replacement
1921 * procedure created them.
1922 */
1923 i = -1;
1925 {
1927
1930 }
1931
1932 /*
1933 * Transfer the targetlist and attr_needed flags.
1934 */
1935
1937 {
1939
1941 replace_relid_callback);
1944 }
1945
1947 {
1949
1953 toRemove->attr_needed[attno]);
1954 }
1955
1956 /*
1957 * If the removed relation has a row mark, transfer it to the remaining
1958 * one.
1959 *
1960 * If both rels have row marks, just keep the one corresponding to the
1961 * remaining relation because we verified earlier that they have the same
1962 * strength.
1963 */
1965 {
1967 {
1969
1971 }
1972 else
1973 {
1974 /* Shouldn't have inheritance children here. */
1976
1978 }
1979 }
1980
1981 /*
1982 * Replace varno in all the query structures, except nodes RangeTblRef
1983 * otherwise later remove_rel_from_joinlist will yield errors.
1984 */
1986 0, replace_relid_callback);
1987
1988 /* Replace links in the planner info */
1990
1991 /* Replace varno in the fully-processed targetlist */
1994
1997
1998 /*
1999 * There may be references to the rel in root->fkey_list, but if so,
2000 * match_foreign_keys_to_quals() will get rid of them.
2001 */
2002
2003 /*
2004 * Finally, remove the rel from the baserel array to prevent it from being
2005 * referenced again. (We can't do this earlier because
2006 * remove_join_clause_from_rels will touch it.)
2007 */
2010
2011 /* And nuke the RelOptInfo, just in case there's another access path. */
2013
2014
2015 /*
2016 * Now repeat construction of attr_needed bits coming from all other
2017 * sources.
2018 */
2023}
static void add_non_redundant_clauses(PlannerInfo *root, List *rinfo_candidates, List **keep_rinfo_list, Index removed_relid)
Definition analyzejoins.c:1687
static void update_eclasses(EquivalenceClass *ec, int from, int to)
Definition analyzejoins.c:1561
References add_non_redundant_clauses(), adjust_relid_set(), Assert, bms_add_member(), bms_add_members(), 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 2166 of file analyzejoins.c.
2167{
2169 int k; /* Index of kept relation */
2170 int r = -1; /* Index of removed relation */
2171
2173 {
2175
2176 k = r;
2177
2179 {
2182 List *restrictlist;
2190
2191 /* A sanity check: the relations have the same Oid. */
2193 root->simple_rte_array[r]->relid);
2194
2195 /*
2196 * It is impossible to eliminate the join of two relations if they
2197 * belong to different rules of order. Otherwise, the planner
2198 * can't find any variants of the correct query plan.
2199 */
2201 {
2203
2208 {
2210 break;
2211 }
2212 }
2214 continue;
2215
2216 /*
2217 * Check Row Marks equivalence. We can't remove the join if the
2218 * relations have row marks of different strength (e.g., one is
2219 * locked FOR UPDATE, and another just has ROW_MARK_REFERENCE for
2220 * EvalPlanQual rechecking).
2221 */
2223 {
2225
2227 {
2230 }
2232 {
2235 }
2236
2238 break;
2239 }
2241 continue;
2242
2243 /*
2244 * We only deal with base rels here, so their relids bitset
2245 * contains only one member -- their relid.
2246 */
2249
2250 /*
2251 * PHVs should not impose any constraints on removing self-joins.
2252 */
2253
2254 /*
2255 * At this stage, joininfo lists of inner and outer can contain
2256 * only clauses required for a superior outer join that can't
2257 * influence this optimization. So, we can avoid to call the
2258 * build_joinrel_restrictlist() routine.
2259 */
2261 rrel->relids,
2264 continue;
2265
2266 /*
2267 * Process restrictlist to separate the self-join quals from the
2268 * other quals. e.g., "x = x" goes to selfjoinquals and "a = b" to
2269 * otherjoinquals.
2270 */
2273
2276
2277 /*
2278 * To enable SJE for the only degenerate case without any self
2279 * join clauses at all, add baserestrictinfo to this list. The
2280 * degenerate case works only if both sides have the same clause.
2281 * So doesn't matter which side to add.
2282 */
2284
2285 /*
2286 * Determine if the rrel can duplicate outer rows. We must bypass
2287 * the unique rel cache here since we're possibly using a subset
2288 * of join quals. We can use 'force_cache' == true when all join
2289 * quals are self-join quals. Otherwise, we could end up putting
2290 * false negatives in the cache.
2291 */
2295 &uclauses))
2296 continue;
2297
2298 /*
2299 * 'uclauses' is the copy of outer->baserestrictinfo that are
2300 * associated with an index. We proved by matching selfjoinquals
2301 * to a unique index that the outer relation has at most one
2302 * matching row for each inner row. Sometimes that is not enough.
2303 * e.g. "WHERE s1.b = s2.b AND s1.a = 1 AND s2.a = 2" when the
2304 * unique index is (a,b). Having non-empty uclauses, we must
2305 * validate that the inner baserestrictinfo contains the same
2306 * expressions, or we won't match the same row on each side of the
2307 * join.
2308 */
2310 continue;
2311
2312 /*
2313 * Remove rrel RelOptInfo from the planner structures and the
2314 * corresponding row mark.
2315 */
2317
2319
2320 /* We have removed the outer relation, try the next one. */
2321 break;
2322 }
2323 }
2324
2326}
static bool match_unique_clauses(PlannerInfo *root, RelOptInfo *outer, List *uclauses, Index relid)
Definition analyzejoins.c:2100
static void split_selfjoin_quals(PlannerInfo *root, List *joinquals, List **selfjoinquals, List **otherjoinquals, int from, int to)
Definition analyzejoins.c:2035
static void remove_self_join_rel(PlannerInfo *root, PlanRowMark *kmark, PlanRowMark *rmark, RelOptInfo *toKeep, RelOptInfo *toRemove, List *restrictlist)
Definition analyzejoins.c:1855
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 2333 of file analyzejoins.c.
2334{
2341
2342 /* Collect indexes of base relations of the join tree */
2344 {
2346
2348 {
2351
2352 /*
2353 * We only consider ordinary relations as candidates to be
2354 * removed, and these relations should not have TABLESAMPLE
2355 * clauses specified. Removing a relation with TABLESAMPLE clause
2356 * could potentially change the syntax of the query. Because of
2357 * UPDATE/DELETE EPQ mechanism, currently Query->resultRelation or
2358 * Query->mergeTargetRelation associated rel cannot be eliminated.
2359 */
2363 varno != root->parse->resultRelation &&
2364 varno != root->parse->mergeTargetRelation)
2365 {
2367 relids = bms_add_member(relids, varno);
2368 }
2369 }
2371 {
2372 /* Recursively go inside the sub-joinlist */
2374 toRemove);
2375 }
2376 else
2379 }
2380
2382
2383 /* Need at least two relations for the join */
2386
2387 /*
2388 * In order to find relations with the same oid we first build an array of
2389 * candidates and then sort it by oid.
2390 */
2392 i = -1;
2393 j = 0;
2395 {
2398 j++;
2399 }
2400
2402 self_join_candidates_cmp);
2403
2404 /*
2405 * Iteratively form a group of relation indexes with the same oid and
2406 * launch the routine that detects self-joins in this group and removes
2407 * excessive range table entries.
2408 *
2409 * At the end of the iteration, exclude the group from the overall relids
2410 * list. So each next iteration of the cycle will involve less and less
2411 * value of relids.
2412 */
2413 i = 0;
2415 {
2417 {
2419 {
2420 /* Create a group of relation indexes with the same oid */
2423
2425 {
2427 i++;
2428 }
2429 relids = bms_del_members(relids, group);
2430
2431 /*
2432 * Try to remove self-joins from a group of identical entries.
2433 * Make the next attempt iteratively - if something is deleted
2434 * from a group, changes in clauses and equivalence classes
2435 * can give us a chance to find more candidates.
2436 */
2437 do
2438 {
2446 bms_free(group);
2447 }
2448 else
2449 {
2450 /* Single relation, just remove it from the set */
2453 }
2454 }
2455 }
2456
2458
2460}
static int self_join_candidates_cmp(const void *a, const void *b)
Definition analyzejoins.c:2466
static Relids remove_self_joins_one_group(PlannerInfo *root, Relids relids)
Definition analyzejoins.c:2166
static Relids remove_self_joins_recurse(PlannerInfo *root, List *joinlist, Relids toRemove)
Definition analyzejoins.c:2333
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 2513 of file analyzejoins.c.
2514{
2516 int relid = -1;
2517
2521
2522 /*
2523 * Merge pairs of relations participated in self-join. Remove unnecessary
2524 * range table entries.
2525 */
2527
2529 {
2530 /* At the end, remove orphaned relation links */
2532 {
2534
2538 }
2539 }
2540
2542}
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 1731 of file analyzejoins.c.
1732{
1734 {
1735 return true;
1736 }
1738 {
1740 int relid = -1;
1742 (rinfo->required_relids == rinfo->clause_relids);
1745
1746 /*
1747 * Recurse down into clauses if the target relation is present in
1748 * clause_relids or required_relids. We must check required_relids
1749 * because the relation not present in clause_relids might still be
1750 * present somewhere in orclause.
1751 */
1754 {
1756
1759
1761 context->rt_index,
1762 context->new_index);
1763
1764 /*
1765 * Incrementally adjust num_base_rels based on the change of
1766 * clause_relids, which could contain both base relids and
1767 * outer-join relids. This operation is legal until we remove
1768 * only baserels.
1769 */
1770 rinfo->num_base_rels -= bms_num_members(rinfo->clause_relids) -
1772
1773 rinfo->clause_relids = new_clause_relids;
1774 rinfo->left_relids =
1776 rinfo->right_relids =
1778 }
1779
1781 rinfo->required_relids = rinfo->clause_relids;
1782 else
1783 rinfo->required_relids =
1785
1786 rinfo->outer_relids =
1788 rinfo->incompatible_relids =
1790
1791 if (rinfo->mergeopfamilies &&
1792 bms_get_singleton_member(rinfo->clause_relids, &relid) &&
1793 clause_relids_is_multiple &&
1795 {
1798
1801
1802 /*
1803 * For self-join elimination, changing varnos could transform
1804 * "t1.a = t2.a" into "t1.a = t1.a". That is always true as long
1805 * as "t1.a" is not null. We use equal() to check for such a
1806 * case, and then we replace the qual with a check for not null
1807 * (NullTest).
1808 */
1810 {
1812
1816 ntest->location = -1;
1818 rinfo->mergeopfamilies = NIL;
1819 rinfo->left_em = NULL;
1820 rinfo->right_em = NULL;
1821 }
1823 }
1824 return true;
1825 }
1826
1827 return false;
1828}
bool ChangeVarNodesWalkExpression(Node *node, ChangeVarNodes_context *context)
Definition rewriteManip.c:758
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 1661 of file analyzejoins.c.
1662{
1665
1669
1671}
References a, b, equal(), fb(), and result.
Referenced by add_non_redundant_clauses().
◆ self_join_candidates_cmp()
Definition at line 2466 of file analyzejoins.c.
2467{
2470
2473 else
2474 return 0;
2475}
References a, b, fb(), and SelfJoinCandidate::reloid.
Referenced by remove_self_joins_recurse().
◆ split_selfjoin_quals()
|
static |
Definition at line 2035 of file analyzejoins.c.
2037{
2040
2042 {
2043 OpExpr *expr;
2046
2047 /* In general, clause looks like F(arg1) = G(arg2) */
2048 if (!rinfo->mergeopfamilies ||
2049 bms_num_members(rinfo->clause_relids) != 2 ||
2052 {
2054 continue;
2055 }
2056
2057 expr = (OpExpr *) rinfo->clause;
2058
2060 {
2062 continue;
2063 }
2064
2067
2072
2073 /*
2074 * Quite an expensive operation, narrowing the use case. For example,
2075 * when we have cast of the same var to different (but compatible)
2076 * types.
2077 */
2079 bms_singleton_member(rinfo->right_relids),
2080 bms_singleton_member(rinfo->left_relids), 0,
2081 replace_relid_callback);
2082
2085 else
2087 }
2088
2091}
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 1561 of file analyzejoins.c.
1562{
1565
1566 /*
1567 * We don't expect any EC child members to exist at this point. Ensure
1568 * that's the case, otherwise, we might be getting asked to do something
1569 * this function hasn't been coded for.
1570 */
1572
1574 {
1576
1578 {
1580 continue;
1581 }
1582
1585
1586 /* We only process inner joins */
1588 replace_relid_callback);
1589
1591 {
1593 continue;
1594
1596 {
1598 break;
1599 }
1600 }
1601
1604 }
1605
1608
1609 ec_clear_derived_clauses(ec);
1610
1611 /* Update EC source expressions */
1613 {
1615
1617 {
1619 continue;
1620 }
1621
1623 replace_relid_callback);
1624
1625 /*
1626 * After switching the clause to the remaining relation, check it for
1627 * redundancy with existing ones. We don't have to check for
1628 * redundancy with derived clauses, because we've just deleted them.
1629 */
1631 {
1633 continue;
1634
1636 {
1638 break;
1639 }
1640 }
1641
1644 }
1645
1649}
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().
