Quelle  joininfo.c

/*-------------------------------------------------------------------------
 *
 * joininfo.c
 *   joininfo list manipulation routines
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *   src/backend/optimizer/util/joininfo.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "nodes/makefuncs.h"
#include "optimizer/joininfo.h"
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/planmain.h"
#include "optimizer/restrictinfo.h"


/*
 * have_relevant_joinclause
 *  Detect whether there is a joinclause that involves
 *  the two given relations.
 *
 * Note: the joinclause does not have to be evaluable with only these two
 * relations.  This is intentional.  For example consider
 *  SELECT * FROM a, b, c WHERE a.x = (b.y + c.z)
 * If a is much larger than the other tables, it may be worthwhile to
 * cross-join b and c and then use an inner indexscan on a.x.  Therefore
 * we should consider this joinclause as reason to join b to c, even though
 * it can't be applied at that join step.
 */
bool
have_relevant_joinclause(PlannerInfo *root,
       RelOptInfo *rel1, RelOptInfo *rel2)
{
 bool  result = false;
 List    *joininfo;
 Relids  other_relids;
 ListCell   *l;

 /*
  * We could scan either relation's joininfo list; may as well use the
  * shorter one.
 */
 if (list_length(rel1->joininfo) <= list_length(rel2->joininfo))
 {
  joininfo = rel1->joininfo;
  other_relids = rel2->relids;
 }
 else
 {
  joininfo = rel2->joininfo;
  other_relids = rel1->relids;
 }

 foreach(l, joininfo)
 {
  RestrictInfo *rinfo = (RestrictInfo *) lfirst(l);

  if (bms_overlap(other_relids, rinfo->required_relids))
  {
   result = true;
   break;
  }
 }

 /*
  * We also need to check the EquivalenceClass data structure, which might
  * contain relationships not emitted into the joininfo lists.
 */
 if (!result && rel1->has_eclass_joins && rel2->has_eclass_joins)
  result = have_relevant_eclass_joinclause(root, rel1, rel2);

 return result;
}


/*
 * add_join_clause_to_rels
 *   Add 'restrictinfo' to the joininfo list of each relation it requires.
 *
 * Note that the same copy of the restrictinfo node is linked to by all the
 * lists it is in.  This allows us to exploit caching of information about
 * the restriction clause (but we must be careful that the information does
 * not depend on context).
 *
 * 'restrictinfo' describes the join clause
 * 'join_relids' is the set of relations participating in the join clause
 *     (some of these could be outer joins)
 */
void
add_join_clause_to_rels(PlannerInfo *root,
      RestrictInfo *restrictinfo,
      Relids join_relids)
{
 int   cur_relid;

 /* Don't add the clause if it is always true */
 if (restriction_is_always_true(root, restrictinfo))
  return;

 /*
  * Substitute the origin qual with constant-FALSE if it is provably always
  * false.
  *
  * Note that we need to keep the same rinfo_serial, since it is in
  * practice the same condition.  We also need to reset the
  * last_rinfo_serial counter, which is essential to ensure that the
  * RestrictInfos for the "same" qual condition get identical serial
  * numbers (see deconstruct_distribute_oj_quals).
 */
 if (restriction_is_always_false(root, restrictinfo))
 {
  int   save_rinfo_serial = restrictinfo->rinfo_serial;
  int   save_last_rinfo_serial = root->last_rinfo_serial;

  restrictinfo = make_restrictinfo(root,
           (Expr *) makeBoolConst(false, false),
           restrictinfo->is_pushed_down,
           restrictinfo->has_clone,
           restrictinfo->is_clone,
           restrictinfo->pseudoconstant,
           0, /* security_level */
           restrictinfo->required_relids,
           restrictinfo->incompatible_relids,
           restrictinfo->outer_relids);
  restrictinfo->rinfo_serial = save_rinfo_serial;
  root->last_rinfo_serial = save_last_rinfo_serial;
 }

 cur_relid = -1;
 while ((cur_relid = bms_next_member(join_relids, cur_relid)) >= 0)
 {
  RelOptInfo *rel = find_base_rel_ignore_join(root, cur_relid);

  /* We only need to add the clause to baserels */
  if (rel == NULL)
   continue;
  rel->joininfo = lappend(rel->joininfo, restrictinfo);
 }
}

/*
 * remove_join_clause_from_rels
 *   Delete 'restrictinfo' from all the joininfo lists it is in
 *
 * This reverses the effect of add_join_clause_to_rels.  It's used when we
 * discover that a relation need not be joined at all.
 *
 * 'restrictinfo' describes the join clause
 * 'join_relids' is the set of relations participating in the join clause
 *     (some of these could be outer joins)
 */
void
remove_join_clause_from_rels(PlannerInfo *root,
        RestrictInfo *restrictinfo,
        Relids join_relids)
{
 int   cur_relid;

 cur_relid = -1;
 while ((cur_relid = bms_next_member(join_relids, cur_relid)) >= 0)
 {
  RelOptInfo *rel = find_base_rel_ignore_join(root, cur_relid);

  /* We would only have added the clause to baserels */
  if (rel == NULL)
   continue;

  /*
   * Remove the restrictinfo from the list.  Pointer comparison is
   * sufficient.
 */
  Assert(list_member_ptr(rel->joininfo, restrictinfo));
  rel->joininfo = list_delete_ptr(rel->joininfo, restrictinfo);
 }
}