#include "postgres.h"
#include "pgpa_identifier.h"
#include "parser/parsetree.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"

Include dependency graph for pgpa_identifier.c:

Functions
static Index *	pgpa_create_top_rti_map (Index rtable_length, List rtable, List appinfos)

static int	pgpa_occurrence_number (List rtable, Index top_rti_map, SubPlanRTInfo *rtinfo, Index rti)

const char *	pgpa_identifier_string (const pgpa_identifier *rid)

void	pgpa_compute_identifier_by_rti (PlannerInfo root, Index rti, pgpa_identifier rid)

int	pgpa_compute_identifiers_by_relids (PlannerInfo root, Bitmapset relids, pgpa_identifier *rids)

pgpa_identifier *	pgpa_create_identifiers_for_planned_stmt (PlannedStmt *pstmt)

Index	pgpa_compute_rti_from_identifier (int rtable_length, pgpa_identifier rt_identifiers, pgpa_identifier rid)

Function Documentation

◆ pgpa_compute_identifier_by_rti()

void pgpa_compute_identifier_by_rti	(	PlannerInfo *	root,
		Index	rti,
		pgpa_identifier *	rid
	)

Definition at line 115 of file pgpa_identifier.c.

{
    Index       top_rti = rti;
    int         occurrence = 1;
    RangeTblEntry *rte;
    RangeTblEntry *top_rte;
    char       *partnsp = NULL;
    char       *partrel = NULL;
 
    /*
     * If this is a child RTE, find the topmost parent that is still of type
     * RTE_RELATION. We do this because we identify children of partitioned
     * tables by the name of the child table, but subqueries can also have
     * child rels and we don't care about those here.
     */
    for (;;)
    {
        AppendRelInfo *appinfo;
        RangeTblEntry *parent_rte;
 
        /* append_rel_array can be NULL if there are no children */
        if (root->append_rel_array == NULL ||
            (appinfo = root->append_rel_array[top_rti]) == NULL)
            break;
 
        parent_rte = rt_fetch(appinfo->parent_relid, root->parse->rtable);
        if (parent_rte->rtekind != RTE_RELATION)
            break;
 
        top_rti = appinfo->parent_relid;
    }
 
    /* Get the range table entries for the RTI and top RTI. */
    rte = rt_fetch(rti, root->parse->rtable);
    top_rte = rt_fetch(top_rti, root->parse->rtable);
    Assert(rte->rtekind != RTE_JOIN);
    Assert(top_rte->rtekind != RTE_JOIN);
 
    /* Work out the correct occurrence number. */
    for (Index prior_rti = 1; prior_rti < top_rti; ++prior_rti)
    {
        RangeTblEntry *prior_rte;
        AppendRelInfo *appinfo;
 
        /*
         * If this is a child rel of a parent that is a relation, skip it.
         *
         * Such range table entries are disambiguated by mentioning the schema
         * and name of the table, not by counting them as separate occurrences
         * of the same table.
         *
         * NB: append_rel_array can be NULL if there are no children
         */
        if (root->append_rel_array != NULL &&
            (appinfo = root->append_rel_array[prior_rti]) != NULL)
        {
            RangeTblEntry *parent_rte;
 
            parent_rte = rt_fetch(appinfo->parent_relid, root->parse->rtable);
            if (parent_rte->rtekind == RTE_RELATION)
                continue;
        }
 
        /* Skip NULL entries and joins. */
        prior_rte = rt_fetch(prior_rti, root->parse->rtable);
        if (prior_rte == NULL || prior_rte->rtekind == RTE_JOIN)
            continue;
 
        /* Skip if the alias name differs. */
        if (strcmp(prior_rte->eref->aliasname, rte->eref->aliasname) != 0)
            continue;
 
        /* Looks like a true duplicate. */
        ++occurrence;
    }
 
    /* If this is a child table, get the schema and relation names. */
    if (rti != top_rti)
    {
        partnsp = get_namespace_name_or_temp(get_rel_namespace(rte->relid));
        partrel = get_rel_name(rte->relid);
    }
 
    /* OK, we have all the answers we need. Return them to the caller. */
    rid->alias_name = top_rte->eref->aliasname;
    rid->occurrence = occurrence;
    rid->partnsp = partnsp;
    rid->partrel = partrel;
    rid->plan_name = root->plan_name;
}

References pgpa_identifier::alias_name, Assert, fb(), get_namespace_name_or_temp(), get_rel_name(), get_rel_namespace(), pgpa_identifier::occurrence, pgpa_identifier::partnsp, pgpa_identifier::partrel, pgpa_identifier::plan_name, root, rt_fetch, RTE_JOIN, and RTE_RELATION.

Referenced by pgpa_build_simple_rel(), pgpa_compute_identifiers_by_relids(), and pgpa_ri_checker_save().

◆ pgpa_compute_identifiers_by_relids()

int pgpa_compute_identifiers_by_relids	(	PlannerInfo *	root,
		Bitmapset *	relids,
		pgpa_identifier *	rids
	)

Definition at line 220 of file pgpa_identifier.c.

{
    int         count = 0;
    int         rti = -1;
 
    while ((rti = bms_next_member(relids, rti)) >= 0)
    {
        RangeTblEntry *rte = rt_fetch(rti, root->parse->rtable);
 
        if (rte->rtekind == RTE_JOIN)
            continue;
        pgpa_compute_identifier_by_rti(root, rti, &rids[count++]);
    }
 
    Assert(count > 0);
    return count;
}

References Assert, bms_next_member(), fb(), pgpa_compute_identifier_by_rti(), root, rt_fetch, and RTE_JOIN.

Referenced by pgpa_get_join_state().

◆ pgpa_compute_rti_from_identifier()

Index pgpa_compute_rti_from_identifier	(	int	rtable_length,
		pgpa_identifier *	rt_identifiers,
		pgpa_identifier *	rid
	)

Definition at line 352 of file pgpa_identifier.c.

{
    Index       result = 0;
 
    for (Index rti = 1; rti <= rtable_length; ++rti)
    {
        pgpa_identifier *rti_rid = &rt_identifiers[rti - 1];
 
        /* If there's no identifier for this RTI, skip it. */
        if (rti_rid->alias_name == NULL)
            continue;
 
        /*
         * If it matches, return this RTI. As usual, an omitted partition
         * schema matches anything, but partition and plan names must either
         * match exactly or be omitted on both sides.
         */
        if (strcmp(rid->alias_name, rti_rid->alias_name) == 0 &&
            rid->occurrence == rti_rid->occurrence &&
            (rid->partnsp == NULL || rti_rid->partnsp == NULL ||
             strcmp(rid->partnsp, rti_rid->partnsp) == 0) &&
            strings_equal_or_both_null(rid->partrel, rti_rid->partrel) &&
            strings_equal_or_both_null(rid->plan_name, rti_rid->plan_name))
        {
            if (result != 0)
            {
                /* Multiple matches were found. */
                return 0;
            }
            result = rti;
        }
    }
 
    return result;
}

References pgpa_identifier::alias_name, fb(), pgpa_identifier::occurrence, pgpa_identifier::partnsp, pgpa_identifier::partrel, pgpa_identifier::plan_name, and strings_equal_or_both_null().

Referenced by pgpa_walker_join_order_matches_member(), and pgpa_walker_would_advise().

◆ pgpa_create_identifiers_for_planned_stmt()

pgpa_identifier * pgpa_create_identifiers_for_planned_stmt ( PlannedStmt * pstmt )

Definition at line 244 of file pgpa_identifier.c.

{
    Index       rtable_length = list_length(pstmt->rtable);
    pgpa_identifier *result = palloc0_array(pgpa_identifier, rtable_length);
    Index      *top_rti_map;
    int         rtinfoindex = 0;
    SubPlanRTInfo *rtinfo = NULL;
    SubPlanRTInfo *nextrtinfo = NULL;
 
    /*
     * Account for relations added by inheritance expansion of partitioned
     * tables.
     */
    top_rti_map = pgpa_create_top_rti_map(rtable_length, pstmt->rtable,
                                          pstmt->appendRelations);
 
    /*
     * When we begin iterating, we're processing the portion of the range
     * table that originated from the top-level PlannerInfo, so subrtinfo is
     * NULL. Later, subrtinfo will be the SubPlanRTInfo for the subquery whose
     * portion of the range table we are processing. nextrtinfo is always the
     * SubPlanRTInfo that follows the current one, if any, so when we're
     * processing the top-level query's portion of the range table, the next
     * SubPlanRTInfo is the very first one.
     */
    if (pstmt->subrtinfos != NULL)
        nextrtinfo = linitial(pstmt->subrtinfos);
 
    /* Main loop over the range table. */
    for (Index rti = 1; rti <= rtable_length; rti++)
    {
        const char *plan_name;
        Index       top_rti;
        RangeTblEntry *rte;
        RangeTblEntry *top_rte;
        char       *partnsp = NULL;
        char       *partrel = NULL;
        int         occurrence;
        pgpa_identifier *rid;
 
        /*
         * Advance to the next SubPlanRTInfo, if it's time to do that.
         *
         * This loop probably shouldn't ever iterate more than once, because
         * that would imply that a subquery was planned but added nothing to
         * the range table; but let's be defensive and assume it can happen.
         */
        while (nextrtinfo != NULL && rti > nextrtinfo->rtoffset)
        {
            rtinfo = nextrtinfo;
            if (++rtinfoindex >= list_length(pstmt->subrtinfos))
                nextrtinfo = NULL;
            else
                nextrtinfo = list_nth(pstmt->subrtinfos, rtinfoindex);
        }
 
        /* Fetch the range table entry, if any. */
        rte = rt_fetch(rti, pstmt->rtable);
 
        /*
         * We can't and don't need to identify null entries, and we don't want
         * to identify join entries.
         */
        if (rte == NULL || rte->rtekind == RTE_JOIN)
            continue;
 
        /*
         * If this is not a relation added by partitioned table expansion,
         * then the top RTI/RTE are just the same as this RTI/RTE. Otherwise,
         * we need the information for the top RTI/RTE, and must also fetch
         * the partition schema and name.
         */
        top_rti = top_rti_map[rti - 1];
        if (rti == top_rti)
            top_rte = rte;
        else
        {
            top_rte = rt_fetch(top_rti, pstmt->rtable);
            partnsp =
                get_namespace_name_or_temp(get_rel_namespace(rte->relid));
            partrel = get_rel_name(rte->relid);
        }
 
        /* Compute the correct occurrence number. */
        occurrence = pgpa_occurrence_number(pstmt->rtable, top_rti_map,
                                            rtinfo, top_rti);
 
        /* Get the name of the current plan (NULL for toplevel query). */
        plan_name = rtinfo == NULL ? NULL : rtinfo->plan_name;
 
        /* Save all the details we've derived. */
        rid = &result[rti - 1];
        rid->alias_name = top_rte->eref->aliasname;
        rid->occurrence = occurrence;
        rid->partnsp = partnsp;
        rid->partrel = partrel;
        rid->plan_name = plan_name;
    }
 
    return result;
}

References pgpa_identifier::alias_name, PlannedStmt::appendRelations, fb(), get_namespace_name_or_temp(), get_rel_name(), get_rel_namespace(), linitial, list_length(), list_nth(), pgpa_identifier::occurrence, palloc0_array, pgpa_identifier::partnsp, pgpa_identifier::partrel, pgpa_create_top_rti_map(), pgpa_occurrence_number(), pgpa_identifier::plan_name, rt_fetch, PlannedStmt::rtable, RTE_JOIN, and PlannedStmt::subrtinfos.

Referenced by pgpa_planner_shutdown(), and pgpa_ri_checker_validate().

◆ pgpa_create_top_rti_map()

static Index * pgpa_create_top_rti_map	(	Index	rtable_length,
		List *	rtable,
		List *	appinfos
	)

static

Definition at line 407 of file pgpa_identifier.c.

{
    Index      *top_rti_map = palloc0_array(Index, rtable_length);
 
    /* Initially, make every RTI point to itself. */
    for (Index rti = 1; rti <= rtable_length; ++rti)
        top_rti_map[rti - 1] = rti;
 
    /* Update the map for each AppendRelInfo object. */
    foreach_node(AppendRelInfo, appinfo, appinfos)
    {
        Index       parent_rti = appinfo->parent_relid;
        RangeTblEntry *parent_rte = rt_fetch(parent_rti, rtable);
 
        /* If the parent is not RTE_RELATION, ignore this entry. */
        if (parent_rte->rtekind != RTE_RELATION)
            continue;
 
        /*
         * Map the child to wherever we mapped the parent. Parents always
         * precede their children in the AppendRelInfo list, so this should
         * work out.
         */
        top_rti_map[appinfo->child_relid - 1] = top_rti_map[parent_rti - 1];
    }
 
    return top_rti_map;
}

References fb(), foreach_node, palloc0_array, rt_fetch, and RTE_RELATION.

Referenced by pgpa_create_identifiers_for_planned_stmt().

◆ pgpa_identifier_string()

const char * pgpa_identifier_string ( const pgpa_identifier * rid )

Definition at line 80 of file pgpa_identifier.c.

{
    const char *result;
 
    Assert(rid->alias_name != NULL);
    result = quote_identifier(rid->alias_name);
 
    Assert(rid->occurrence >= 0);
    if (rid->occurrence > 1)
        result = psprintf("%s#%d", result, rid->occurrence);
 
    if (rid->partrel != NULL)
    {
        if (rid->partnsp == NULL)
            result = psprintf("%s/%s", result,
                              quote_identifier(rid->partrel));
        else
            result = psprintf("%s/%s.%s", result,
                              quote_identifier(rid->partnsp),
                              quote_identifier(rid->partrel));
    }
 
    if (rid->plan_name != NULL)
        result = psprintf("%s@%s", result, quote_identifier(rid->plan_name));
 
    return result;
}

References pgpa_identifier::alias_name, Assert, fb(), pgpa_identifier::occurrence, pgpa_identifier::partnsp, pgpa_identifier::partrel, pgpa_identifier::plan_name, psprintf(), and quote_identifier().

Referenced by pgpa_format_advice_target(), pgpa_output_advice(), pgpa_ri_checker_save(), and pgpa_ri_checker_validate().

◆ pgpa_occurrence_number()

static int pgpa_occurrence_number	(	List *	rtable,
		Index *	top_rti_map,
		SubPlanRTInfo *	rtinfo,
		Index	rti
	)