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 1659 of file analyzejoins.c.
1663{
1665 {
1667
1669
1671 {
1673 /* Can't compare trivially different clauses */
1674 continue;
1675
1676 if (src == rinfo ||
1677 (rinfo->parent_ec != NULL &&
1678 src->parent_ec == rinfo->parent_ec) ||
1679 restrict_infos_logically_equal(rinfo, src))
1680 {
1682 break;
1683 }
1684 }
1687 }
1688}
static bool restrict_infos_logically_equal(RestrictInfo *a, RestrictInfo *b)
Definition analyzejoins.c:1633
void distribute_restrictinfo_to_rels(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition initsplan.c:3558
Definition pathnodes.h:2864
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 1270 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 1310 of file analyzejoins.c.
1317{
1320}
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:1332
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 1332 of file analyzejoins.c.
1340{
1346
1347 /* Certainly can't prove uniqueness when there are no joinclauses */
1349 return false;
1350
1351 /*
1352 * Make a quick check to eliminate cases in which we will surely be unable
1353 * to prove uniqueness of the innerrel.
1354 */
1356 return false;
1357
1358 /*
1359 * Query the cache to see if we've managed to prove that innerrel is
1360 * unique for any subset of this outerrel. For non-self-join search, we
1361 * don't need an exact match, as extra outerrels can't make the innerrel
1362 * any less unique (or more formally, the restrictlist for a join to a
1363 * superset outerrel must be a superset of the conditions we successfully
1364 * used before). For self-join search, we require an exact match of
1365 * outerrels because we need extra clauses to be valid for our case. Also,
1366 * for self-join checking we've filtered the clauses list. Thus, we can
1367 * match only the result cached for a self-join search for another
1368 * self-join check.
1369 */
1371 {
1373
1376 uniqueRelInfo->self_join))
1377 {
1378 if (extra_clauses)
1379 *extra_clauses = uniqueRelInfo->extra_clauses;
1380 return true; /* Success! */
1381 }
1382 }
1383
1384 /*
1385 * Conversely, we may have already determined that this outerrel, or some
1386 * superset thereof, cannot prove this innerrel to be unique.
1387 */
1389 {
1391
1393 return false;
1394 }
1395
1396 /* No cached information, so try to make the proof. */
1398 jointype, restrictlist,
1400 {
1401 /*
1402 * Cache the positive result for future probes, being sure to keep it
1403 * in the planner_cxt even if we are working in GEQO.
1404 *
1405 * Note: one might consider trying to isolate the minimal subset of
1406 * the outerrels that proved the innerrel unique. But it's not worth
1407 * the trouble, because the planner builds up joinrels incrementally
1408 * and so we'll see the minimally sufficient outerrels before any
1409 * supersets of them anyway.
1410 */
1414 uniqueRelInfo->self_join = self_join;
1417 uniqueRelInfo);
1419
1420 if (extra_clauses)
1421 *extra_clauses = outer_exprs;
1422 return true; /* Success! */
1423 }
1424 else
1425 {
1426 /*
1427 * None of the join conditions for outerrel proved innerrel unique, so
1428 * we can safely reject this outerrel or any subset of it in future
1429 * checks.
1430 *
1431 * However, in normal planning mode, caching this knowledge is totally
1432 * pointless; it won't be queried again, because we build up joinrels
1433 * from smaller to larger. It's only useful when using GEQO or
1434 * another planner extension that attempts planning multiple times.
1435 *
1436 * Also, allow callers to override that heuristic and force caching;
1437 * that's useful for reduce_unique_semijoins, which calls here before
1438 * the normal join search starts.
1439 */
1441 {
1443 innerrel->non_unique_for_rels =
1445 bms_copy(outerrelids));
1447 }
1448
1449 return false;
1450 }
1451}
static bool is_innerrel_unique_for(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, List **extra_clauses)
Definition analyzejoins.c:1459
static bool rel_supports_distinctness(PlannerInfo *root, RelOptInfo *rel)
Definition analyzejoins.c:921
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:3787
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 1459 of file analyzejoins.c.
1466{
1469
1470 /*
1471 * Search for mergejoinable clauses that constrain the inner rel against
1472 * the outer rel. If an operator is mergejoinable then it behaves like
1473 * equality for some btree opclass, so it's what we want. The
1474 * mergejoinability test also eliminates clauses containing volatile
1475 * functions, which we couldn't depend on.
1476 */
1478 {
1480
1481 /*
1482 * As noted above, if it's a pushed-down clause and we're at an outer
1483 * join, we can't use it.
1484 */
1487 continue;
1488
1489 /* Ignore if it's not a mergejoinable clause */
1492 continue; /* not mergejoinable */
1493
1494 /*
1495 * Check if the clause has the form "outer op inner" or "inner op
1496 * outer", and if so mark which side is inner.
1497 */
1499 innerrel->relids))
1500 continue; /* no good for these input relations */
1501
1502 /* OK, add to the list */
1504 }
1505
1506 /* Let rel_is_distinct_for() do the hard work */
1508}
static bool rel_is_distinct_for(PlannerInfo *root, RelOptInfo *rel, List *clause_list, List **extra_clauses)
Definition analyzejoins.c:981
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 156 of file analyzejoins.c.
157{
159 RelOptInfo *innerrel;
163 ListCell *l;
165
166 /*
167 * Must be a left join to a single baserel, else we aren't going to be
168 * able to do anything with it.
169 */
171 return false;
172
174 return false;
175
176 /*
177 * Never try to eliminate a left join to the query result rel. Although
178 * the case is syntactically impossible in standard SQL, MERGE will build
179 * a join tree that looks exactly like that.
180 */
182 return false;
183
185
186 /*
187 * Before we go to the effort of checking whether any innerrel variables
188 * are needed above the join, make a quick check to eliminate cases in
189 * which we will surely be unable to prove uniqueness of the innerrel.
190 */
192 return false;
193
194 /* Compute the relid set for the join we are considering */
199
200 /*
201 * We can't remove the join if any inner-rel attributes are used above the
202 * join. Here, "above" the join includes pushed-down conditions, so we
203 * should reject if attr_needed includes the OJ's own relid; therefore,
204 * compare to inputrelids not joinrelids.
205 *
206 * As a micro-optimization, it seems better to start with max_attr and
207 * count down rather than starting with min_attr and counting up, on the
208 * theory that the system attributes are somewhat less likely to be wanted
209 * and should be tested last.
210 */
212 attroff >= 0;
213 attroff--)
214 {
216 return false;
217 }
218
219 /*
220 * Similarly check that the inner rel isn't needed by any PlaceHolderVars
221 * that will be used above the join. The PHV case is a little bit more
222 * complicated, because PHVs may have been assigned a ph_eval_at location
223 * that includes the innerrel, yet their contained expression might not
224 * actually reference the innerrel (it could be just a constant, for
225 * instance). If such a PHV is due to be evaluated above the join then it
226 * needn't prevent join removal.
227 */
229 {
231
233 return false; /* it references innerrel laterally */
235 continue; /* it definitely doesn't reference innerrel */
237 continue; /* PHV is not used above the join */
239 return false; /* it has to be evaluated below the join */
240
241 /*
242 * We need to be sure there will still be a place to evaluate the PHV
243 * if we remove the join, ie that ph_eval_at wouldn't become empty.
244 */
246 return false; /* there isn't any other place to eval PHV */
247 /* Check contained expression last, since this is a bit expensive */
249 innerrel->relids))
250 return false; /* contained expression references innerrel */
251 }
252
253 /*
254 * Search for mergejoinable clauses that constrain the inner rel against
255 * either the outer rel or a pseudoconstant. If an operator is
256 * mergejoinable then it behaves like equality for some btree opclass, so
257 * it's what we want. The mergejoinability test also eliminates clauses
258 * containing volatile functions, which we couldn't depend on.
259 */
261 {
263
264 /*
265 * If the current join commutes with some other outer join(s) via
266 * outer join identity 3, there will be multiple clones of its join
267 * clauses in the joininfo list. We want to consider only the
268 * has_clone form of such clauses. Processing more than one form
269 * would be wasteful, and also some of the others would confuse the
270 * RINFO_IS_PUSHED_DOWN test below.
271 */
273 continue; /* ignore it */
274
275 /*
276 * If it's not a join clause for this outer join, we can't use it.
277 * Note that if the clause is pushed-down, then it is logically from
278 * above the outer join, even if it references no other rels (it might
279 * be from WHERE, for example).
280 */
282 continue; /* ignore; not useful here */
283
284 /* Ignore if it's not a mergejoinable clause */
287 continue; /* not mergejoinable */
288
289 /*
290 * Check if the clause has the form "outer op inner" or "inner op
291 * outer", and if so mark which side is inner.
292 */
294 innerrel->relids))
295 continue; /* no good for these input relations */
296
297 /* OK, add to list */
299 }
300
301 /*
302 * Now that we have the relevant equality join clauses, try to prove the
303 * innerrel distinct.
304 */
306 return true;
307
308 /*
309 * Some day it would be nice to check for other methods of establishing
310 * distinctness.
311 */
312 return false;
313}
bool bms_get_singleton_member(const Bitmapset *a, int *member)
Definition bitmapset.c:714
Definition nodes.h:135
Definition pathnodes.h:3374
Definition pathnodes.h:992
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 2075 of file analyzejoins.c.
2077{
2079 {
2080 Expr *clause;
2083 bool matched = false;
2084
2086
2087 /* Only filters like f(R.x1,...,R.xN) == expr we should consider. */
2089 bms_is_empty(rinfo->right_relids));
2090
2093 replace_relid_callback);
2094
2096 get_leftop(clause);
2098 get_rightop(clause);
2099
2100 /*
2101 * Compare these left and right sides with the corresponding sides of
2102 * the outer's filters. If no one is detected - return immediately.
2103 */
2105 {
2108
2110 /* Don't consider clauses that aren't similar to 'F(X)=G(Y)' */
2111 continue;
2112
2114
2119
2121 {
2122 matched = true;
2123 break;
2124 }
2125 }
2126
2127 if (!matched)
2128 return false;
2129 }
2130
2131 return true;
2132}
static bool replace_relid_callback(Node *node, ChangeVarNodes_context *context)
Definition analyzejoins.c:1703
void ChangeVarNodesExtended(Node *node, int rt_index, int new_index, int sublevels_up, ChangeVarNodes_callback callback)
Definition rewriteManip.c:677
Definition primnodes.h:189
References Assert, bms_is_empty, ChangeVarNodesExtended(), copyObject, equal(), fb(), foreach_node, get_leftop(), get_rightop(), is_opclause(), NIL, and replace_relid_callback().
Referenced by remove_self_joins_one_group().
◆ query_is_distinct_for()
Definition at line 1117 of file analyzejoins.c.
1118{
1119 ListCell *l;
1121
1123
1124 /*
1125 * DISTINCT (including DISTINCT ON) guarantees uniqueness if all the
1126 * columns in the DISTINCT clause appear in colnos and operator semantics
1127 * match. This is true even if there are SRFs in the DISTINCT columns or
1128 * elsewhere in the tlist.
1129 */
1131 {
1133 {
1136 query->targetList);
1137
1141 break; /* exit early if no match */
1142 }
1144 return true;
1145 }
1146
1147 /*
1148 * Otherwise, a set-returning function in the query's targetlist can
1149 * result in returning duplicate rows, despite any grouping that might
1150 * occur before tlist evaluation. (If all tlist SRFs are within GROUP BY
1151 * columns, it would be safe because they'd be expanded before grouping.
1152 * But it doesn't currently seem worth the effort to check for that.)
1153 */
1154 if (query->hasTargetSRFs)
1155 return false;
1156
1157 /*
1158 * Similarly, GROUP BY without GROUPING SETS guarantees uniqueness if all
1159 * the grouped columns appear in colnos and operator semantics match.
1160 */
1162 {
1164 {
1167 query->targetList);
1168
1172 break; /* exit early if no match */
1173 }
1175 return true;
1176 }
1178 {
1179 List *gsets;
1180
1181 /*
1182 * If we have grouping sets with expressions, we probably don't have
1183 * uniqueness and analysis would be hard. Punt.
1184 */
1186 return false;
1187
1188 /*
1189 * If we have no groupClause (therefore no grouping expressions), we
1190 * might have one or many empty grouping sets. If there's just one,
1191 * or if the DISTINCT clause is used on the GROUP BY, then we're
1192 * returning only one row and are certainly unique. But otherwise, we
1193 * know we're certainly not unique.
1194 */
1196 return true;
1197
1199
1201 }
1202 else
1203 {
1204 /*
1205 * If we have no GROUP BY, but do have aggregates or HAVING, then the
1206 * result is at most one row so it's surely unique, for any operators.
1207 */
1209 return true;
1210 }
1211
1212 /*
1213 * UNION, INTERSECT, EXCEPT guarantee uniqueness of the whole output row,
1214 * except with ALL.
1215 */
1217 {
1219
1221
1223 {
1225
1226 /* We're good if all the nonjunk output columns are in colnos */
1229 {
1232
1234 continue; /* ignore resjunk columns */
1235
1236 /* non-resjunk columns should have grouping clauses */
1240
1244 break; /* exit early if no match */
1245 }
1247 return true;
1248 }
1249 }
1250
1251 /*
1252 * XXX Are there any other cases in which we can easily see the result
1253 * must be distinct?
1254 *
1255 * If you do add more smarts to this function, be sure to update
1256 * query_supports_distinctness() to match.
1257 */
1258
1259 return false;
1260}
static Oid distinct_col_search(int colno, List *colnos, List *opids)
Definition analyzejoins.c:1270
bool equality_ops_are_compatible(Oid opno1, Oid opno2)
Definition lsyscache.c:771
List * expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
Definition parse_agg.c:1947
Definition parsenodes.h:2280
Definition parsenodes.h:1494
Definition primnodes.h:2236
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 1079 of file analyzejoins.c.
1080{
1081 /* SRFs break distinctness except with DISTINCT, see below */
1083 return false;
1084
1085 /* check for features we can prove distinctness with */
1089 query->hasAggs ||
1090 query->havingQual ||
1091 query->setOperations)
1092 return true;
1093
1094 return false;
1095}
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 845 of file analyzejoins.c.
846{
848
849 /*
850 * Scan the join_info_list to find semijoins.
851 */
853 {
856 RelOptInfo *innerrel;
858 List *restrictlist;
859
860 /*
861 * Must be a semijoin to a single baserel, else we aren't going to be
862 * able to do anything with it.
863 */
865 continue;
866
868 continue;
869
871
872 /*
873 * Before we trouble to run generate_join_implied_equalities, make a
874 * quick check to eliminate cases in which we will surely be unable to
875 * prove uniqueness of the innerrel.
876 */
878 continue;
879
880 /* Compute the relid set for the join we are considering */
883
884 /*
885 * Since we're only considering a single-rel RHS, any join clauses it
886 * has must be clauses linking it to the semijoin's min_lefthand. We
887 * can also consider EC-derived join clauses.
888 */
889 restrictlist =
891 joinrelids,
892 sjinfo->min_lefthand,
893 innerrel,
894 NULL),
895 innerrel->joininfo);
896
897 /* Test whether the innerrel is unique for those clauses. */
901 continue;
902
903 /* OK, remove the SpecialJoinInfo from the list. */
905 }
906}
bool innerrel_is_unique(PlannerInfo *root, Relids joinrelids, Relids outerrelids, RelOptInfo *innerrel, JoinType jointype, List *restrictlist, bool force_cache)
Definition analyzejoins.c:1310
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:3191
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 981 of file analyzejoins.c.
983{
984 /*
985 * We could skip a couple of tests here if we assume all callers checked
986 * rel_supports_distinctness first, but it doesn't seem worth taking any
987 * risk for.
988 */
990 return false;
992 {
993 /*
994 * Examine the indexes to see if we have a matching unique index.
995 * relation_has_unique_index_for automatically adds any usable
996 * restriction clauses for the rel, so we needn't do that here.
997 */
999 return true;
1000 }
1002 {
1007 ListCell *l;
1008
1009 /*
1010 * Build the argument lists for query_is_distinct_for: a list of
1011 * output column numbers that the query needs to be distinct over, and
1012 * a list of equality operators that the output columns need to be
1013 * distinct according to.
1014 *
1015 * (XXX we are not considering restriction clauses attached to the
1016 * subquery; is that worth doing?)
1017 */
1019 {
1021 Oid op;
1022 Var *var;
1023
1024 /*
1025 * Get the equality operator we need uniqueness according to.
1026 * (This might be a cross-type operator and thus not exactly the
1027 * same operator the subquery would consider; that's all right
1028 * since query_is_distinct_for can resolve such cases.) The
1029 * caller's mergejoinability test should have selected only
1030 * OpExprs.
1031 */
1033
1034 /* caller identified the inner side for us */
1035 if (rinfo->outer_is_left)
1037 else
1039
1040 /*
1041 * We may ignore any RelabelType node above the operand. (There
1042 * won't be more than one, since eval_const_expressions() has been
1043 * applied already.)
1044 */
1047
1048 /*
1049 * If inner side isn't a Var referencing a subquery output column,
1050 * this clause doesn't help us.
1051 */
1054 continue;
1055
1058 }
1059
1061 return true;
1062 }
1063 return false;
1064}
bool query_is_distinct_for(Query *query, List *colnos, List *opids)
Definition analyzejoins.c:1117
bool relation_has_unique_index_for(PlannerInfo *root, RelOptInfo *rel, List *restrictlist, List **extra_clauses)
Definition indxpath.c:4145
Definition primnodes.h:846
Definition parsenodes.h:118
Definition primnodes.h:1215
Definition primnodes.h:262
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 921 of file analyzejoins.c.
922{
923 /* We only know about baserels ... */
925 return false;
927 {
928 /*
929 * For a plain relation, we only know how to prove uniqueness by
930 * reference to unique indexes. Make sure there's at least one
931 * suitable unique index. It must be immediately enforced, and not a
932 * partial index. (Keep these conditions in sync with
933 * relation_has_unique_index_for!)
934 */
936
938 {
940
942 return true;
943 }
944 }
946 {
948
949 /* Check if the subquery has any qualities that support distinctness */
951 return true;
952 }
953 /* We have no proof rules for any other rtekinds. */
954 return false;
955}
bool query_supports_distinctness(Query *query)
Definition analyzejoins.c:1079
Definition pathnodes.h:1329
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 545 of file analyzejoins.c.
547{
553 ListCell *l;
554
555 /* Compute the relid set for the join we are considering */
557 Assert(ojrelid != 0);
559
561
562 /*
563 * Remove any joinquals referencing the rel from the joininfo lists.
564 *
565 * In some cases, a joinqual has to be put back after deleting its
566 * reference to the target rel. This can occur for pseudoconstant and
567 * outerjoin-delayed quals, which can get marked as requiring the rel in
568 * order to force them to be evaluated at or above the join. We can't
569 * just discard them, though. Only quals that logically belonged to the
570 * outer join being discarded should be removed from the query.
571 *
572 * We might encounter a qual that is a clone of a deletable qual with some
573 * outer-join relids added (see deconstruct_distribute_oj_quals). To
574 * ensure we get rid of such clones as well, add the relids of all OJs
575 * commutable with this one to the set we test against for
576 * pushed-down-ness.
577 */
579 sjinfo->commute_above_r);
581 sjinfo->commute_below_l);
582
583 /*
584 * We must make a copy of the rel's old joininfo list before starting the
585 * loop, because otherwise remove_join_clause_from_rels would destroy the
586 * list while we're scanning it.
587 */
590 {
592
594
596 {
597 /*
598 * There might be references to relid or ojrelid in the
599 * RestrictInfo's relid sets, as a consequence of PHVs having had
600 * ph_eval_at sets that include those. We already checked above
601 * that any such PHV is safe (and updated its ph_eval_at), so we
602 * can just drop those references.
603 */
604 remove_rel_from_restrictinfo(rinfo, relid, ojrelid);
605
606 /*
607 * Cross-check that the clause itself does not reference the
608 * target rel or join.
609 */
610#ifdef USE_ASSERT_CHECKING
611 {
614
617 }
618#endif
619 /* Now throw it back into the joininfo lists */
621 }
622 }
623
624 /*
625 * There may be references to the rel in root->fkey_list, but if so,
626 * match_foreign_keys_to_quals() will get rid of them.
627 */
628
629 /*
630 * Now remove the rel from the baserel array to prevent it from being
631 * referenced again. (We can't do this earlier because
632 * remove_join_clause_from_rels will touch it.)
633 */
636
637 /* And nuke the RelOptInfo, just in case there's another access path */
638 pfree(rel);
639
640 /*
641 * Now repeat construction of attr_needed bits coming from all other
642 * sources.
643 */
648}
static void remove_rel_from_query(PlannerInfo *root, RelOptInfo *rel, int subst, SpecialJoinInfo *sjinfo, Relids joinrelids)
Definition analyzejoins.c:326
static void remove_rel_from_restrictinfo(RestrictInfo *rinfo, int relid, int ojrelid)
Definition analyzejoins.c:659
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:916
void rebuild_eclass_attr_needed(PlannerInfo *root)
Definition equivclass.c:2573
void rebuild_lateral_attr_needed(PlannerInfo *root)
Definition initsplan.c:1174
void rebuild_joinclause_attr_needed(PlannerInfo *root)
Definition initsplan.c:3890
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:327
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 720 of file analyzejoins.c.
722{
724
725 /* Fix up the EC's overall relids */
729 sjinfo->ojrelid, subst);
730
731 /*
732 * We don't expect any EC child members to exist at this point. Ensure
733 * that's the case, otherwise, we might be getting asked to do something
734 * this function hasn't been coded for.
735 */
737
738 /*
739 * Fix up the member expressions. Any non-const member that ends with
740 * empty em_relids must be a Var or PHV of the removed relation. We don't
741 * need it anymore, so we can drop it.
742 */
744 {
746
749 cur_em->em_relids)))
750 {
755 sjinfo->ojrelid, subst);
758 }
759 }
760
761 /* Fix up the source clauses, in case we can re-use them later */
763 {
765
768 replace_relid_callback);
769 else
771 }
772
773 /*
774 * Rather than expend code on fixing up any already-derived clauses, just
775 * drop them. (At this point, any such clauses would be base restriction
776 * clauses, which we'd not need anymore anyway.)
777 */
778 ec_clear_derived_clauses(ec);
779}
void ec_clear_derived_clauses(EquivalenceClass *ec)
Definition equivclass.c:3830
Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid)
Definition rewriteManip.c:761
Definition pathnodes.h:1695
References adjust_relid_set(), Assert, bms_is_empty, bms_is_member(), ChangeVarNodesExtended(), EquivalenceClass::ec_childmembers, ec_clear_derived_clauses(), EquivalenceClass::ec_members, EquivalenceClass::ec_relids, EquivalenceClass::ec_sources, fb(), foreach_delete_current, lfirst, SpecialJoinInfo::ojrelid, remove_rel_from_restrictinfo(), and replace_relid_callback().
Referenced by remove_rel_from_query().
◆ remove_rel_from_joinlist()
Definition at line 791 of file analyzejoins.c.
792{
795
797 {
799
801 {
803
804 if (varno == relid)
805 (*nremoved)++;
806 else
808 }
810 {
811 /* Recurse to handle subproblem */
813
815 relid, nremoved);
816 /* Avoid including empty sub-lists in the result */
819 }
820 else
821 {
824 }
825 }
826
827 return result;
828}
static List * remove_rel_from_joinlist(List *joinlist, int relid, int *nremoved)
Definition analyzejoins.c:791
Definition primnodes.h:2293
References elog, ERROR, fb(), IsA, lappend(), lfirst, NIL, nodeTag, and remove_rel_from_joinlist().
Referenced by remove_rel_from_joinlist(), remove_useless_joins(), and remove_useless_self_joins().
◆ remove_rel_from_query()
|
static |
Definition at line 326 of file analyzejoins.c.
329{
331 Index rti;
332 ListCell *l;
333
334 /*
335 * Update all_baserels and related relid sets.
336 */
339
341 {
343 sjinfo->ojrelid);
345 sjinfo->ojrelid);
346 }
347
348 /*
349 * Likewise remove references from SpecialJoinInfo data structures.
350 *
351 * This is relevant in case the outer join we're deleting is nested inside
352 * other outer joins: the upper joins' relid sets have to be adjusted. The
353 * RHS of the target outer join will be made empty here, but that's OK
354 * since caller will delete that SpecialJoinInfo entirely.
355 */
357 {
359
360 /*
361 * initsplan.c is fairly cavalier about allowing SpecialJoinInfos'
362 * lefthand/righthand relid sets to be shared with other data
363 * structures. Ensure that we don't modify the original relid sets.
364 * (The commute_xxx sets are always per-SpecialJoinInfo though.)
365 */
370 /* Now remove relid from the sets: */
375
377 {
378 Assert(subst <= 0);
379
380 /* Remove sjinfo->ojrelid bits from the sets: */
382 sjinfo->ojrelid);
384 sjinfo->ojrelid);
386 sjinfo->ojrelid);
388 sjinfo->ojrelid);
389 /* relid cannot appear in these fields, but ojrelid can: */
391 sjinfo->ojrelid);
393 sjinfo->ojrelid);
395 sjinfo->ojrelid);
397 sjinfo->ojrelid);
398 }
399 else
400 {
401 Assert(subst > 0);
402
404 0, replace_relid_callback);
405 }
406 }
407
408 /*
409 * Likewise remove references from PlaceHolderVar data structures,
410 * removing any no-longer-needed placeholders entirely. We remove PHV
411 * only for left-join removal. With self-join elimination, PHVs already
412 * get moved to the remaining relation, where they might still be needed.
413 * It might also happen that we skip the removal of some PHVs that could
414 * be removed. However, the overhead of extra PHVs is small compared to
415 * the complexity of analysis needed to remove them.
416 *
417 * Removal is a bit trickier than it might seem: we can remove PHVs that
418 * are used at the target rel and/or in the join qual, but not those that
419 * are used at join partner rels or above the join. It's not that easy to
420 * distinguish PHVs used at partner rels from those used in the join qual,
421 * since they will both have ph_needed sets that are subsets of
422 * joinrelids. However, a PHV used at a partner rel could not have the
423 * target rel in ph_eval_at, so we check that while deciding whether to
424 * remove or just update the PHV. There is no corresponding test in
425 * join_is_removable because it doesn't need to distinguish those cases.
426 */
428 {
430
436 {
437 /*
438 * This code shouldn't be executed if one relation is substituted
439 * with another: in this case, the placeholder may be employed in
440 * a filter inside the scan node the SJE removes.
441 */
443 l);
445 }
446 else
447 {
449
453 sjinfo->ojrelid, subst);
455 /* Reduce ph_needed to contain only "relation 0"; see below */
458 else
460
462
463 /*
464 * ph_lateral might contain rels mentioned in ph_eval_at after the
465 * replacement, remove them.
466 */
468 /* ph_lateral might or might not be empty */
469
473 sjinfo->ojrelid, subst);
475
477 replace_relid_callback);
478
480 }
481 }
482
483 /*
484 * Likewise remove references from EquivalenceClasses.
485 */
487 {
489
492 remove_rel_from_eclass(ec, sjinfo, relid, subst);
493 }
494
495 /*
496 * Finally, we must recompute per-Var attr_needed and per-PlaceHolderVar
497 * ph_needed relid sets. These have to be known accurately, else we may
498 * fail to remove other now-removable outer joins. And our removal of the
499 * join clause(s) for this outer join may mean that Vars that were
500 * formerly needed no longer are. So we have to do this honestly by
501 * repeating the construction of those relid sets. We can cheat to one
502 * small extent: we can avoid re-examining the targetlist and HAVING qual
503 * by preserving "relation 0" bits from the existing relid sets. This is
504 * safe because we'd never remove such references.
505 *
506 * So, start by removing all other bits from attr_needed sets and
507 * lateral_vars lists. (We already did this above for ph_needed.)
508 */
510 {
513
514 /* there may be empty slots corresponding to non-baserel RTEs */
516 continue;
517
519
521 attroff >= 0;
522 attroff--)
523 {
526 else
528 }
529
530 if (subst > 0)
532 subst, 0, replace_relid_callback);
533 }
534}
static void remove_rel_from_eclass(EquivalenceClass *ec, SpecialJoinInfo *sjinfo, int relid, int subst)
Definition analyzejoins.c:720
Bitmapset * bms_difference(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:346
Definition pathnodes.h:1634
Definition pathnodes.h:3085
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, RelOptInfo::relid, 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 659 of file analyzejoins.c.
660{
661 /*
662 * initsplan.c is fairly cavalier about allowing RestrictInfos to share
663 * relid sets with other RestrictInfos, and SpecialJoinInfos too. Make
664 * sure this RestrictInfo has its own relid sets before we modify them.
665 * (In present usage, clause_relids is probably not shared, but
666 * required_relids could be; let's not assume anything.)
667 */
668 rinfo->clause_relids = bms_copy(rinfo->clause_relids);
669 rinfo->clause_relids = bms_del_member(rinfo->clause_relids, relid);
670 rinfo->clause_relids = bms_del_member(rinfo->clause_relids, ojrelid);
671 /* Likewise for required_relids */
675
676 /* If it's an OR, recurse to clean up sub-clauses */
678 {
680
683 {
685
686 /* OR arguments should be ANDs or sub-RestrictInfos */
688 {
691
693 {
695
697 }
698 }
699 else
700 {
702
704 }
705 }
706 }
707}
bool restriction_is_or_clause(RestrictInfo *restrictinfo)
Definition restrictinfo.c:407
Definition primnodes.h:967
References Assert, bms_copy(), bms_del_member(), castNode, fb(), is_andclause(), is_orclause(), lfirst, lfirst_node, 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 1827 of file analyzejoins.c.
1830{
1836
1839
1840 /*
1841 * Replace the index of the removing table with the keeping one. The
1842 * technique of removing/distributing restrictinfo is used here to attach
1843 * just appeared (for keeping relation) join clauses and avoid adding
1844 * duplicates of those that already exist in the joininfo list.
1845 */
1848 {
1851 0, replace_relid_callback);
1852
1855 else
1857 }
1858
1859 /*
1860 * Concatenate restrictlist to the list of base restrictions of the
1861 * removing table just to simplify the replacement procedure: all of them
1862 * weren't connected to any keeping relations and need to be added to some
1863 * rels.
1864 */
1866 restrictlist);
1868 {
1870 0, replace_relid_callback);
1871
1874 else
1876 }
1877
1878 /*
1879 * Now, add all non-redundant clauses to the keeping relation.
1880 */
1885
1888
1889 /*
1890 * Arrange equivalence classes, mentioned removing a table, with the
1891 * keeping one: varno of removing table should be replaced in members and
1892 * sources lists. Also, remove duplicated elements if this replacement
1893 * procedure created them.
1894 */
1895 i = -1;
1897 {
1899
1902 }
1903
1904 /*
1905 * Transfer the targetlist and attr_needed flags.
1906 */
1907
1909 {
1911
1913 replace_relid_callback);
1916 }
1917
1919 {
1921
1925 toRemove->attr_needed[attno]);
1926 }
1927
1928 /*
1929 * If the removed relation has a row mark, transfer it to the remaining
1930 * one.
1931 *
1932 * If both rels have row marks, just keep the one corresponding to the
1933 * remaining relation because we verified earlier that they have the same
1934 * strength.
1935 */
1937 {
1939 {
1941
1943 }
1944 else
1945 {
1946 /* Shouldn't have inheritance children here. */
1948
1950 }
1951 }
1952
1953 /*
1954 * Replace varno in all the query structures, except nodes RangeTblRef
1955 * otherwise later remove_rel_from_joinlist will yield errors.
1956 */
1958 0, replace_relid_callback);
1959
1960 /* Replace links in the planner info */
1962
1963 /* At last, replace varno in root targetlist and HAVING clause */
1968 replace_relid_callback);
1969
1972
1973 /*
1974 * There may be references to the rel in root->fkey_list, but if so,
1975 * match_foreign_keys_to_quals() will get rid of them.
1976 */
1977
1978 /*
1979 * Finally, remove the rel from the baserel array to prevent it from being
1980 * referenced again. (We can't do this earlier because
1981 * remove_join_clause_from_rels will touch it.)
1982 */
1985
1986 /* And nuke the RelOptInfo, just in case there's another access path. */
1988
1989
1990 /*
1991 * Now repeat construction of attr_needed bits coming from all other
1992 * sources.
1993 */
1998}
static void add_non_redundant_clauses(PlannerInfo *root, List *rinfo_candidates, List **keep_rinfo_list, Index removed_relid)
Definition analyzejoins.c:1659
static void update_eclasses(EquivalenceClass *ec, int from, int to)
Definition analyzejoins.c:1533
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 2141 of file analyzejoins.c.
2142{
2144 int k; /* Index of kept relation */
2145 int r = -1; /* Index of removed relation */
2146
2148 {
2150
2151 k = r;
2152
2154 {
2157 List *restrictlist;
2165
2166 /* A sanity check: the relations have the same Oid. */
2168 root->simple_rte_array[r]->relid);
2169
2170 /*
2171 * It is impossible to eliminate the join of two relations if they
2172 * belong to different rules of order. Otherwise, the planner
2173 * can't find any variants of the correct query plan.
2174 */
2176 {
2178
2183 {
2185 break;
2186 }
2187 }
2189 continue;
2190
2191 /*
2192 * Check Row Marks equivalence. We can't remove the join if the
2193 * relations have row marks of different strength (e.g., one is
2194 * locked FOR UPDATE, and another just has ROW_MARK_REFERENCE for
2195 * EvalPlanQual rechecking).
2196 */
2198 {
2200
2202 {
2205 }
2207 {
2210 }
2211
2213 break;
2214 }
2216 continue;
2217
2218 /*
2219 * We only deal with base rels here, so their relids bitset
2220 * contains only one member -- their relid.
2221 */
2224
2225 /*
2226 * PHVs should not impose any constraints on removing self-joins.
2227 */
2228
2229 /*
2230 * At this stage, joininfo lists of inner and outer can contain
2231 * only clauses required for a superior outer join that can't
2232 * influence this optimization. So, we can avoid to call the
2233 * build_joinrel_restrictlist() routine.
2234 */
2236 rrel->relids,
2239 continue;
2240
2241 /*
2242 * Process restrictlist to separate the self-join quals from the
2243 * other quals. e.g., "x = x" goes to selfjoinquals and "a = b" to
2244 * otherjoinquals.
2245 */
2248
2251
2252 /*
2253 * To enable SJE for the only degenerate case without any self
2254 * join clauses at all, add baserestrictinfo to this list. The
2255 * degenerate case works only if both sides have the same clause.
2256 * So doesn't matter which side to add.
2257 */
2259
2260 /*
2261 * Determine if the rrel can duplicate outer rows. We must bypass
2262 * the unique rel cache here since we're possibly using a subset
2263 * of join quals. We can use 'force_cache' == true when all join
2264 * quals are self-join quals. Otherwise, we could end up putting
2265 * false negatives in the cache.
2266 */
2270 &uclauses))
2271 continue;
2272
2273 /*
2274 * 'uclauses' is the copy of outer->baserestrictinfo that are
2275 * associated with an index. We proved by matching selfjoinquals
2276 * to a unique index that the outer relation has at most one
2277 * matching row for each inner row. Sometimes that is not enough.
2278 * e.g. "WHERE s1.b = s2.b AND s1.a = 1 AND s2.a = 2" when the
2279 * unique index is (a,b). Having non-empty uclauses, we must
2280 * validate that the inner baserestrictinfo contains the same
2281 * expressions, or we won't match the same row on each side of the
2282 * join.
2283 */
2285 continue;
2286
2287 /*
2288 * Remove rrel RelOptInfo from the planner structures and the
2289 * corresponding row mark.
2290 */
2292
2293 result = bms_add_member(result, r);
2294
2295 /* We have removed the outer relation, try the next one. */
2296 break;
2297 }
2298 }
2299
2300 return result;
2301}
static bool match_unique_clauses(PlannerInfo *root, RelOptInfo *outer, List *uclauses, Index relid)
Definition analyzejoins.c:2075
static void split_selfjoin_quals(PlannerInfo *root, List *joinquals, List **selfjoinquals, List **otherjoinquals, int from, int to)
Definition analyzejoins.c:2010
static void remove_self_join_rel(PlannerInfo *root, PlanRowMark *kmark, PlanRowMark *rmark, RelOptInfo *toKeep, RelOptInfo *toRemove, List *restrictlist)
Definition analyzejoins.c:1827
Definition plannodes.h:1585
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(), 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 2308 of file analyzejoins.c.
2309{
2316
2317 /* Collect indexes of base relations of the join tree */
2319 {
2321
2323 {
2326
2327 /*
2328 * We only consider ordinary relations as candidates to be
2329 * removed, and these relations should not have TABLESAMPLE
2330 * clauses specified. Removing a relation with TABLESAMPLE clause
2331 * could potentially change the syntax of the query. Because of
2332 * UPDATE/DELETE EPQ mechanism, currently Query->resultRelation or
2333 * Query->mergeTargetRelation associated rel cannot be eliminated.
2334 */
2338 varno != root->parse->resultRelation &&
2339 varno != root->parse->mergeTargetRelation)
2340 {
2342 relids = bms_add_member(relids, varno);
2343 }
2344 }
2346 {
2347 /* Recursively go inside the sub-joinlist */
2349 toRemove);
2350 }
2351 else
2354 }
2355
2357
2358 /* Need at least two relations for the join */
2361
2362 /*
2363 * In order to find relations with the same oid we first build an array of
2364 * candidates and then sort it by oid.
2365 */
2367 i = -1;
2368 j = 0;
2370 {
2373 j++;
2374 }
2375
2377 self_join_candidates_cmp);
2378
2379 /*
2380 * Iteratively form a group of relation indexes with the same oid and
2381 * launch the routine that detects self-joins in this group and removes
2382 * excessive range table entries.
2383 *
2384 * At the end of the iteration, exclude the group from the overall relids
2385 * list. So each next iteration of the cycle will involve less and less
2386 * value of relids.
2387 */
2388 i = 0;
2390 {
2392 {
2394 {
2395 /* Create a group of relation indexes with the same oid */
2398
2400 {
2402 i++;
2403 }
2404 relids = bms_del_members(relids, group);
2405
2406 /*
2407 * Try to remove self-joins from a group of identical entries.
2408 * Make the next attempt iteratively - if something is deleted
2409 * from a group, changes in clauses and equivalence classes
2410 * can give us a chance to find more candidates.
2411 */
2412 do
2413 {
2421 bms_free(group);
2422 }
2423 else
2424 {
2425 /* Single relation, just remove it from the set */
2428 }
2429 }
2430 }
2431
2433
2435}
static int self_join_candidates_cmp(const void *a, const void *b)
Definition analyzejoins.c:2441
static Relids remove_self_joins_one_group(PlannerInfo *root, Relids relids)
Definition analyzejoins.c:2141
static Relids remove_self_joins_recurse(PlannerInfo *root, List *joinlist, Relids toRemove)
Definition analyzejoins.c:2308
Bitmapset * bms_del_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:1160
Definition parsenodes.h:1085
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 91 of file analyzejoins.c.
92{
94
95 /*
96 * We are only interested in relations that are left-joined to, so we can
97 * scan the join_info_list to find them easily.
98 */
99restart:
101 {
105
106 /* Skip if not removable */
108 continue;
109
110 /*
111 * Currently, join_is_removable can only succeed when the sjinfo's
112 * righthand is a single baserel. Remove that rel from the query and
113 * joinlist.
114 */
116
118
119 /* We verify that exactly one reference gets removed from joinlist */
120 nremoved = 0;
124
125 /*
126 * We can delete this SpecialJoinInfo from the list too, since it's no
127 * longer of interest. (Since we'll restart the foreach loop
128 * immediately, we don't bother with foreach_delete_current.)
129 */
131
132 /*
133 * Restart the scan. This is necessary to ensure we find all
134 * removable joins independently of ordering of the join_info_list
135 * (note that removal of attr_needed bits may make a join appear
136 * removable that did not before).
137 */
138 goto restart;
139 }
140
142}
static void remove_leftjoinrel_from_query(PlannerInfo *root, int relid, SpecialJoinInfo *sjinfo)
Definition analyzejoins.c:545
static bool join_is_removable(PlannerInfo *root, SpecialJoinInfo *sjinfo)
Definition analyzejoins.c:156
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 2488 of file analyzejoins.c.
2489{
2491 int relid = -1;
2492
2496
2497 /*
2498 * Merge pairs of relations participated in self-join. Remove unnecessary
2499 * range table entries.
2500 */
2502
2504 {
2505 /* At the end, remove orphaned relation links */
2507 {
2509
2513 }
2514 }
2515
2517}
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 1703 of file analyzejoins.c.
1704{
1706 {
1707 return true;
1708 }
1710 {
1712 int relid = -1;
1714 (rinfo->required_relids == rinfo->clause_relids);
1717
1718 /*
1719 * Recurse down into clauses if the target relation is present in
1720 * clause_relids or required_relids. We must check required_relids
1721 * because the relation not present in clause_relids might still be
1722 * present somewhere in orclause.
1723 */
1726 {
1728
1731
1733 context->rt_index,
1734 context->new_index);
1735
1736 /*
1737 * Incrementally adjust num_base_rels based on the change of
1738 * clause_relids, which could contain both base relids and
1739 * outer-join relids. This operation is legal until we remove
1740 * only baserels.
1741 */
1742 rinfo->num_base_rels -= bms_num_members(rinfo->clause_relids) -
1744
1745 rinfo->clause_relids = new_clause_relids;
1746 rinfo->left_relids =
1748 rinfo->right_relids =
1750 }
1751
1753 rinfo->required_relids = rinfo->clause_relids;
1754 else
1755 rinfo->required_relids =
1757
1758 rinfo->outer_relids =
1760 rinfo->incompatible_relids =
1762
1763 if (rinfo->mergeopfamilies &&
1764 bms_get_singleton_member(rinfo->clause_relids, &relid) &&
1765 clause_relids_is_multiple &&
1767 {
1770
1773
1774 /*
1775 * For self-join elimination, changing varnos could transform
1776 * "t1.a = t2.a" into "t1.a = t1.a". That is always true as long
1777 * as "t1.a" is not null. We use equal() to check for such a
1778 * case, and then we replace the qual with a check for not null
1779 * (NullTest).
1780 */
1782 {
1784
1788 ntest->location = -1;
1790 rinfo->mergeopfamilies = NIL;
1791 rinfo->left_em = NULL;
1792 rinfo->right_em = NULL;
1793 }
1795 }
1796 return true;
1797 }
1798
1799 return false;
1800}
bool ChangeVarNodesWalkExpression(Node *node, ChangeVarNodes_context *context)
Definition rewriteManip.c:744
Definition primnodes.h:1981
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_eclass(), remove_rel_from_query(), remove_self_join_rel(), split_selfjoin_quals(), and update_eclasses().
◆ restrict_infos_logically_equal()
|
static |
Definition at line 1633 of file analyzejoins.c.
1634{
1636 bool result;
1637
1641
1642 return result;
1643}
References a, b, equal(), and fb().
Referenced by add_non_redundant_clauses().
◆ self_join_candidates_cmp()
Definition at line 2441 of file analyzejoins.c.
2442{
2445
2448 else
2449 return 0;
2450}
References a, b, fb(), and SelfJoinCandidate::reloid.
Referenced by remove_self_joins_recurse().
◆ split_selfjoin_quals()
|
static |
Definition at line 2010 of file analyzejoins.c.
2012{
2015
2017 {
2018 OpExpr *expr;
2021
2022 /* In general, clause looks like F(arg1) = G(arg2) */
2023 if (!rinfo->mergeopfamilies ||
2024 bms_num_members(rinfo->clause_relids) != 2 ||
2027 {
2029 continue;
2030 }
2031
2032 expr = (OpExpr *) rinfo->clause;
2033
2035 {
2037 continue;
2038 }
2039
2042
2047
2048 /*
2049 * Quite an expensive operation, narrowing the use case. For example,
2050 * when we have cast of the same var to different (but compatible)
2051 * types.
2052 */
2054 bms_singleton_member(rinfo->right_relids),
2055 bms_singleton_member(rinfo->left_relids), 0,
2056 replace_relid_callback);
2057
2060 else
2062 }
2063
2066}
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 1533 of file analyzejoins.c.
1534{
1537
1538 /*
1539 * We don't expect any EC child members to exist at this point. Ensure
1540 * that's the case, otherwise, we might be getting asked to do something
1541 * this function hasn't been coded for.
1542 */
1544
1546 {
1548
1550 {
1552 continue;
1553 }
1554
1557
1558 /* We only process inner joins */
1560 replace_relid_callback);
1561
1563 {
1565 continue;
1566
1568 {
1570 break;
1571 }
1572 }
1573
1576 }
1577
1580
1581 ec_clear_derived_clauses(ec);
1582
1583 /* Update EC source expressions */
1585 {
1587
1589 {
1591 continue;
1592 }
1593
1595 replace_relid_callback);
1596
1597 /*
1598 * After switching the clause to the remaining relation, check it for
1599 * redundancy with existing ones. We don't have to check for
1600 * redundancy with derived clauses, because we've just deleted them.
1601 */
1603 {
1605 continue;
1606
1608 {
1610 break;
1611 }
1612 }
1613
1616 }
1617
1621}
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().
