tidpath.c File Reference

#include "postgres.h"
#include "access/sysattr.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_type.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/cost.h"
#include "optimizer/optimizer.h"
#include "optimizer/pathnode.h"
#include "optimizer/paths.h"
#include "optimizer/restrictinfo.h"

Include dependency graph for tidpath.c:

Go to the source code of this file.

Functions
static bool	IsCTIDVar (Var *var, RelOptInfo *rel)
static bool	IsBinaryTidClause (RestrictInfo *rinfo, RelOptInfo *rel)
static bool	IsTidEqualClause (RestrictInfo *rinfo, RelOptInfo *rel)
static bool	IsTidRangeClause (RestrictInfo *rinfo, RelOptInfo *rel)
static bool	IsTidEqualAnyClause (PlannerInfo *root, RestrictInfo *rinfo, RelOptInfo *rel)
static bool	IsCurrentOfClause (RestrictInfo *rinfo, RelOptInfo *rel)
static bool	RestrictInfoIsTidQual (PlannerInfo *root, RestrictInfo *rinfo, RelOptInfo *rel)
static List *	TidQualFromRestrictInfoList (PlannerInfo *root, List *rlist, RelOptInfo *rel, bool *isCurrentOf)
static List *	TidRangeQualFromRestrictInfoList (List *rlist, RelOptInfo *rel)
static void	BuildParameterizedTidPaths (PlannerInfo *root, RelOptInfo *rel, List *clauses)
static bool	ec_member_matches_ctid (PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg)
bool	create_tidscan_paths (PlannerInfo *root, RelOptInfo *rel)

Function Documentation

BuildParameterizedTidPaths()

static void BuildParameterizedTidPaths ( PlannerInfo *  root, RelOptInfo *  rel, List *  clauses  )

static

Definition at line 426 of file tidpath.c.

{
    ListCell   *l;
 
    foreach(l, clauses)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
        List       *tidquals;
        Relids      required_outer;
 
        /*
         * Validate whether each clause is actually usable; we must check this
         * even when examining clauses generated from an EquivalenceClass,
         * since they might not satisfy the restriction on not having Vars of
         * our rel on the other side, or somebody might've built an operator
         * class that accepts type "tid" but has other operators in it.
         *
         * We currently consider only TidEqual join clauses.  In principle we
         * might find a suitable ScalarArrayOpExpr in the rel's joininfo list,
         * but it seems unlikely to be worth expending the cycles to check.
         * And we definitely won't find a CurrentOfExpr here.  Hence, we don't
         * use RestrictInfoIsTidQual; but this must match that function
         * otherwise.
         */
        if (rinfo->pseudoconstant ||
            !restriction_is_securely_promotable(rinfo, rel) ||
            !IsTidEqualClause(rinfo, rel))
            continue;
 
        /*
         * Check if clause can be moved to this rel; this is probably
         * redundant when considering EC-derived clauses, but we must check it
         * for "loose" join clauses.
         */
        if (!join_clause_is_movable_to(rinfo, rel))
            continue;
 
        /* OK, make list of clauses for this path */
        tidquals = list_make1(rinfo);
 
        /* Compute required outer rels for this path */
        required_outer = bms_union(rinfo->required_relids, rel->lateral_relids);
        required_outer = bms_del_member(required_outer, rel->relid);
 
        add_path(rel, (Path *) create_tidscan_path(root, rel, tidquals,
                                                   required_outer));
    }
}

References add_path(), bms_del_member(), bms_union(), create_tidscan_path(), IsTidEqualClause(), join_clause_is_movable_to(), RelOptInfo::lateral_relids, lfirst_node, list_make1, RelOptInfo::relid, RestrictInfo::required_relids, restriction_is_securely_promotable(), and root.

Referenced by create_tidscan_paths().

create_tidscan_paths()

bool create_tidscan_paths	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

Definition at line 498 of file tidpath.c.

{
    List       *tidquals;
    List       *tidrangequals;
    bool        isCurrentOf;
 
    /*
     * If any suitable quals exist in the rel's baserestrict list, generate a
     * plain (unparameterized) TidPath with them.
     *
     * We skip this when enable_tidscan = false, except when the qual is
     * CurrentOfExpr. In that case, a TID scan is the only correct path.
     */
    tidquals = TidQualFromRestrictInfoList(root, rel->baserestrictinfo, rel,
                                           &isCurrentOf);
 
    if (tidquals != NIL && (enable_tidscan || isCurrentOf))
    {
        /*
         * This path uses no join clauses, but it could still have required
         * parameterization due to LATERAL refs in its tlist.
         */
        Relids      required_outer = rel->lateral_relids;
 
        add_path(rel, (Path *) create_tidscan_path(root, rel, tidquals,
                                                   required_outer));
 
        /*
         * When the qual is CurrentOfExpr, the path that we just added is the
         * only one the executor can handle, so we should return before adding
         * any others. Returning true lets the caller know not to add any
         * others, either.
         */
        if (isCurrentOf)
            return true;
    }
 
    /* Skip the rest if TID scans are disabled. */
    if (!enable_tidscan)
        return false;
 
    /*
     * If there are range quals in the baserestrict list, generate a
     * TidRangePath.
     */
    tidrangequals = TidRangeQualFromRestrictInfoList(rel->baserestrictinfo,
                                                     rel);
 
    if (tidrangequals != NIL)
    {
        /*
         * This path uses no join clauses, but it could still have required
         * parameterization due to LATERAL refs in its tlist.
         */
        Relids      required_outer = rel->lateral_relids;
 
        add_path(rel, (Path *) create_tidrangescan_path(root, rel,
                                                        tidrangequals,
                                                        required_outer));
    }
 
    /*
     * Try to generate parameterized TidPaths using equality clauses extracted
     * from EquivalenceClasses.  (This is important since simple "t1.ctid =
     * t2.ctid" clauses will turn into ECs.)
     */
    if (rel->has_eclass_joins)
    {
        List       *clauses;
 
        /* Generate clauses, skipping any that join to lateral_referencers */
        clauses = generate_implied_equalities_for_column(root,
                                                         rel,
                                                         ec_member_matches_ctid,
                                                         NULL,
                                                         rel->lateral_referencers);
 
        /* Generate a path for each usable join clause */
        BuildParameterizedTidPaths(root, rel, clauses);
    }
 
    /*
     * Also consider parameterized TidPaths using "loose" join quals.  Quals
     * of the form "t1.ctid = t2.ctid" would turn into these if they are outer
     * join quals, for example.
     */
    BuildParameterizedTidPaths(root, rel, rel->joininfo);
 
    return false;
}

References add_path(), RelOptInfo::baserestrictinfo, BuildParameterizedTidPaths(), create_tidrangescan_path(), create_tidscan_path(), ec_member_matches_ctid(), enable_tidscan, generate_implied_equalities_for_column(), RelOptInfo::has_eclass_joins, RelOptInfo::joininfo, RelOptInfo::lateral_referencers, RelOptInfo::lateral_relids, NIL, root, TidQualFromRestrictInfoList(), and TidRangeQualFromRestrictInfoList().

Referenced by set_plain_rel_pathlist().

ec_member_matches_ctid()

static bool ec_member_matches_ctid ( PlannerInfo *  root, RelOptInfo *  rel, EquivalenceClass *  ec, EquivalenceMember *  em, void *  arg  )

static

Definition at line 481 of file tidpath.c.

{
    if (em->em_expr && IsA(em->em_expr, Var) &&
        IsCTIDVar((Var *) em->em_expr, rel))
        return true;
    return false;
}

References EquivalenceMember::em_expr, IsA, and IsCTIDVar().

Referenced by create_tidscan_paths().

IsBinaryTidClause()

static bool IsBinaryTidClause ( RestrictInfo *  rinfo, RelOptInfo *  rel  )

static

Definition at line 77 of file tidpath.c.

{
    OpExpr     *node;
    Node       *arg1,
               *arg2,
               *other;
    Relids      other_relids;
 
    /* Must be an OpExpr */
    if (!is_opclause(rinfo->clause))
        return false;
    node = (OpExpr *) rinfo->clause;
 
    /* OpExpr must have two arguments */
    if (list_length(node->args) != 2)
        return false;
    arg1 = linitial(node->args);
    arg2 = lsecond(node->args);
 
    /* Look for CTID as either argument */
    other = NULL;
    other_relids = NULL;
    if (arg1 && IsA(arg1, Var) &&
        IsCTIDVar((Var *) arg1, rel))
    {
        other = arg2;
        other_relids = rinfo->right_relids;
    }
    if (!other && arg2 && IsA(arg2, Var) &&
        IsCTIDVar((Var *) arg2, rel))
    {
        other = arg1;
        other_relids = rinfo->left_relids;
    }
    if (!other)
        return false;
 
    /* The other argument must be a pseudoconstant */
    if (bms_is_member(rel->relid, other_relids) ||
        contain_volatile_functions(other))
        return false;
 
    return true;                /* success */
}

References OpExpr::args, bms_is_member(), RestrictInfo::clause, contain_volatile_functions(), if(), is_opclause(), IsA, IsCTIDVar(), linitial, list_length(), lsecond, and RelOptInfo::relid.

Referenced by IsTidEqualClause(), and IsTidRangeClause().

IsCTIDVar()

static bool IsCTIDVar ( Var *  var, RelOptInfo *  rel  )

inlinestatic

Definition at line 56 of file tidpath.c.

{
    /* The vartype check is strictly paranoia */
    if (var->varattno == SelfItemPointerAttributeNumber &&
        var->vartype == TIDOID &&
        var->varno == rel->relid &&
        var->varnullingrels == NULL &&
        var->varlevelsup == 0)
        return true;
    return false;
}

References RelOptInfo::relid, SelfItemPointerAttributeNumber, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by ec_member_matches_ctid(), IsBinaryTidClause(), and IsTidEqualAnyClause().

IsCurrentOfClause()

static bool IsCurrentOfClause ( RestrictInfo *  rinfo, RelOptInfo *  rel  )

static

Definition at line 212 of file tidpath.c.

{
    CurrentOfExpr *node;
 
    /* Must be a CurrentOfExpr */
    if (!(rinfo->clause && IsA(rinfo->clause, CurrentOfExpr)))
        return false;
    node = (CurrentOfExpr *) rinfo->clause;
 
    /* If it references this rel, we're good */
    if (node->cvarno == rel->relid)
        return true;
 
    return false;
}

References RestrictInfo::clause, CurrentOfExpr::cvarno, if(), IsA, and RelOptInfo::relid.

Referenced by RestrictInfoIsTidQual(), and TidQualFromRestrictInfoList().

IsTidEqualAnyClause()

static bool IsTidEqualAnyClause ( PlannerInfo *  root, RestrictInfo *  rinfo, RelOptInfo *  rel  )

static

Definition at line 173 of file tidpath.c.

{
    ScalarArrayOpExpr *node;
    Node       *arg1,
               *arg2;
 
    /* Must be a ScalarArrayOpExpr */
    if (!(rinfo->clause && IsA(rinfo->clause, ScalarArrayOpExpr)))
        return false;
    node = (ScalarArrayOpExpr *) rinfo->clause;
 
    /* Operator must be tideq */
    if (node->opno != TIDEqualOperator)
        return false;
    if (!node->useOr)
        return false;
    Assert(list_length(node->args) == 2);
    arg1 = linitial(node->args);
    arg2 = lsecond(node->args);
 
    /* CTID must be first argument */
    if (arg1 && IsA(arg1, Var) &&
        IsCTIDVar((Var *) arg1, rel))
    {
        /* The other argument must be a pseudoconstant */
        if (bms_is_member(rel->relid, pull_varnos(root, arg2)) ||
            contain_volatile_functions(arg2))
            return false;
 
        return true;            /* success */
    }
 
    return false;
}

References ScalarArrayOpExpr::args, Assert, bms_is_member(), RestrictInfo::clause, contain_volatile_functions(), if(), IsA, IsCTIDVar(), linitial, list_length(), lsecond, ScalarArrayOpExpr::opno, pull_varnos(), RelOptInfo::relid, root, and ScalarArrayOpExpr::useOr.

Referenced by RestrictInfoIsTidQual().

IsTidEqualClause()

static bool IsTidEqualClause ( RestrictInfo *  rinfo, RelOptInfo *  rel  )

static

Definition at line 131 of file tidpath.c.

{
    if (!IsBinaryTidClause(rinfo, rel))
        return false;
 
    if (((OpExpr *) rinfo->clause)->opno == TIDEqualOperator)
        return true;
 
    return false;
}

References RestrictInfo::clause, and IsBinaryTidClause().

Referenced by BuildParameterizedTidPaths(), and RestrictInfoIsTidQual().

IsTidRangeClause()

static bool IsTidRangeClause ( RestrictInfo *  rinfo, RelOptInfo *  rel  )

static

Definition at line 151 of file tidpath.c.

{
    Oid         opno;
 
    if (!IsBinaryTidClause(rinfo, rel))
        return false;
    opno = ((OpExpr *) rinfo->clause)->opno;
 
    if (opno == TIDLessOperator || opno == TIDLessEqOperator ||
        opno == TIDGreaterOperator || opno == TIDGreaterEqOperator)
        return true;
 
    return false;
}

References RestrictInfo::clause, and IsBinaryTidClause().

Referenced by TidRangeQualFromRestrictInfoList().

RestrictInfoIsTidQual()

static bool RestrictInfoIsTidQual ( PlannerInfo *  root, RestrictInfo *  rinfo, RelOptInfo *  rel  )

static

Definition at line 235 of file tidpath.c.

{
    /*
     * We may ignore pseudoconstant clauses (they can't contain Vars, so could
     * not match anyway).
     */
    if (rinfo->pseudoconstant)
        return false;
 
    /*
     * If clause must wait till after some lower-security-level restriction
     * clause, reject it.
     */
    if (!restriction_is_securely_promotable(rinfo, rel))
        return false;
 
    /*
     * Check all base cases.
     */
    if (IsTidEqualClause(rinfo, rel) ||
        IsTidEqualAnyClause(root, rinfo, rel) ||
        IsCurrentOfClause(rinfo, rel))
        return true;
 
    return false;
}

References IsCurrentOfClause(), IsTidEqualAnyClause(), IsTidEqualClause(), restriction_is_securely_promotable(), and root.

Referenced by TidQualFromRestrictInfoList().

TidQualFromRestrictInfoList()

static List* TidQualFromRestrictInfoList ( PlannerInfo *  root, List *  rlist, RelOptInfo *  rel, bool *  isCurrentOf  )

static

Definition at line 281 of file tidpath.c.

{
    RestrictInfo *tidclause = NULL; /* best simple CTID qual so far */
    List       *orlist = NIL;   /* best OR'ed CTID qual so far */
    ListCell   *l;
 
    *isCurrentOf = false;
 
    foreach(l, rlist)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
 
        if (restriction_is_or_clause(rinfo))
        {
            List       *rlst = NIL;
            ListCell   *j;
 
            /*
             * We must be able to extract a CTID condition from every
             * sub-clause of an OR, or we can't use it.
             */
            foreach(j, ((BoolExpr *) rinfo->orclause)->args)
            {
                Node       *orarg = (Node *) lfirst(j);
                List       *sublist;
 
                /* OR arguments should be ANDs or sub-RestrictInfos */
                if (is_andclause(orarg))
                {
                    List       *andargs = ((BoolExpr *) orarg)->args;
                    bool        sublistIsCurrentOf;
 
                    /* Recurse in case there are sub-ORs */
                    sublist = TidQualFromRestrictInfoList(root, andargs, rel,
                                                          &sublistIsCurrentOf);
                    if (sublistIsCurrentOf)
                        elog(ERROR, "IS CURRENT OF within OR clause");
                }
                else
                {
                    RestrictInfo *ri = castNode(RestrictInfo, orarg);
 
                    Assert(!restriction_is_or_clause(ri));
                    if (RestrictInfoIsTidQual(root, ri, rel))
                        sublist = list_make1(ri);
                    else
                        sublist = NIL;
                }
 
                /*
                 * If nothing found in this arm, we can't do anything with
                 * this OR clause.
                 */
                if (sublist == NIL)
                {
                    rlst = NIL; /* forget anything we had */
                    break;      /* out of loop over OR args */
                }
 
                /*
                 * OK, continue constructing implicitly-OR'ed result list.
                 */
                rlst = list_concat(rlst, sublist);
            }
 
            if (rlst)
            {
                /*
                 * Accept the OR'ed list if it's the first one, or if it's
                 * shorter than the previous one.
                 */
                if (orlist == NIL || list_length(rlst) < list_length(orlist))
                    orlist = rlst;
            }
        }
        else
        {
            /* Not an OR clause, so handle base cases */
            if (RestrictInfoIsTidQual(root, rinfo, rel))
            {
                /* We can stop immediately if it's a CurrentOfExpr */
                if (IsCurrentOfClause(rinfo, rel))
                {
                    *isCurrentOf = true;
                    return list_make1(rinfo);
                }
 
                /*
                 * Otherwise, remember the first non-OR CTID qual.  We could
                 * try to apply some preference order if there's more than
                 * one, but such usage seems very unlikely, so don't bother.
                 */
                if (tidclause == NULL)
                    tidclause = rinfo;
            }
        }
    }
 
    /*
     * Prefer any singleton CTID qual to an OR'ed list.  Again, it seems
     * unlikely to be worth thinking harder than that.
     */
    if (tidclause)
        return list_make1(tidclause);
    return orlist;
}

References Assert, castNode, elog, ERROR, is_andclause(), IsCurrentOfClause(), j, lfirst, lfirst_node, list_concat(), list_length(), list_make1, NIL, RestrictInfoIsTidQual(), restriction_is_or_clause(), and root.

Referenced by create_tidscan_paths().

TidRangeQualFromRestrictInfoList()

static List* TidRangeQualFromRestrictInfoList ( List *  rlist, RelOptInfo *  rel  )

static

Definition at line 398 of file tidpath.c.

{
    List       *rlst = NIL;
    ListCell   *l;
 
    if ((rel->amflags & AMFLAG_HAS_TID_RANGE) == 0)
        return NIL;
 
    foreach(l, rlist)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, l);
 
        if (IsTidRangeClause(rinfo, rel))
            rlst = lappend(rlst, rinfo);
    }
 
    return rlst;
}

References AMFLAG_HAS_TID_RANGE, RelOptInfo::amflags, IsTidRangeClause(), lappend(), lfirst_node, and NIL.

Referenced by create_tidscan_paths().