pgpa_output.c File Reference

#include "postgres.h"
#include "pgpa_output.h"
#include "pgpa_scan.h"
#include "nodes/parsenodes.h"
#include "parser/parsetree.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"

Include dependency graph for pgpa_output.c:

Go to the source code of this file.

Data Structures
struct	pgpa_output_context

Typedefs
typedef struct pgpa_output_context	pgpa_output_context

Functions
static void	pgpa_output_unrolled_join (pgpa_output_context *context, pgpa_unrolled_join *join)
static void	pgpa_output_join_member (pgpa_output_context *context, pgpa_join_member *member)
static void	pgpa_output_scan_strategy (pgpa_output_context *context, pgpa_scan_strategy strategy, List *scans)
static void	pgpa_output_relation_name (pgpa_output_context *context, Oid relid)
static void	pgpa_output_query_feature (pgpa_output_context *context, pgpa_qf_type type, List *query_features)
static void	pgpa_output_simple_strategy (pgpa_output_context *context, char *strategy, List *relid_sets)
static void	pgpa_output_no_gather (pgpa_output_context *context, Bitmapset *relids)
static void	pgpa_output_do_not_scan (pgpa_output_context *context, List *identifiers)
static void	pgpa_output_relations (pgpa_output_context *context, StringInfo buf, Bitmapset *relids)
static char *	pgpa_cstring_join_strategy (pgpa_join_strategy strategy)
static char *	pgpa_cstring_scan_strategy (pgpa_scan_strategy strategy)
static char *	pgpa_cstring_query_feature_type (pgpa_qf_type type)
static void	pgpa_maybe_linebreak (StringInfo buf, int wrap_column)
void	pgpa_output_advice (StringInfo buf, pgpa_plan_walker_context *walker, pgpa_identifier *rt_identifiers)

Typedef Documentation

pgpa_output_context

typedef struct pgpa_output_context pgpa_output_context

Function Documentation

pgpa_cstring_join_strategy()

static char * pgpa_cstring_join_strategy ( pgpa_join_strategy  strategy )

static

Definition at line 470 of file pgpa_output.c.

{
    switch (strategy)
    {
        case JSTRAT_MERGE_JOIN_PLAIN:
            return "MERGE_JOIN_PLAIN";
        case JSTRAT_MERGE_JOIN_MATERIALIZE:
            return "MERGE_JOIN_MATERIALIZE";
        case JSTRAT_NESTED_LOOP_PLAIN:
            return "NESTED_LOOP_PLAIN";
        case JSTRAT_NESTED_LOOP_MATERIALIZE:
            return "NESTED_LOOP_MATERIALIZE";
        case JSTRAT_NESTED_LOOP_MEMOIZE:
            return "NESTED_LOOP_MEMOIZE";
        case JSTRAT_HASH_JOIN:
            return "HASH_JOIN";
    }
 
    pg_unreachable();
    return NULL;
}

References fb(), JSTRAT_HASH_JOIN, JSTRAT_MERGE_JOIN_MATERIALIZE, JSTRAT_MERGE_JOIN_PLAIN, JSTRAT_NESTED_LOOP_MATERIALIZE, JSTRAT_NESTED_LOOP_MEMOIZE, JSTRAT_NESTED_LOOP_PLAIN, and pg_unreachable.

Referenced by pgpa_output_advice().

pgpa_cstring_query_feature_type()

static char * pgpa_cstring_query_feature_type ( pgpa_qf_type  type )

static

Definition at line 526 of file pgpa_output.c.

{
    switch (type)
    {
        case PGPAQF_GATHER:
            return "GATHER";
        case PGPAQF_GATHER_MERGE:
            return "GATHER_MERGE";
        case PGPAQF_SEMIJOIN_NON_UNIQUE:
            return "SEMIJOIN_NON_UNIQUE";
        case PGPAQF_SEMIJOIN_UNIQUE:
            return "SEMIJOIN_UNIQUE";
    }
 
 
    pg_unreachable();
    return NULL;
}

References fb(), pg_unreachable, PGPAQF_GATHER, PGPAQF_GATHER_MERGE, PGPAQF_SEMIJOIN_NON_UNIQUE, PGPAQF_SEMIJOIN_UNIQUE, and type.

Referenced by pgpa_output_query_feature().

pgpa_cstring_scan_strategy()

static char * pgpa_cstring_scan_strategy ( pgpa_scan_strategy  strategy )

static

Definition at line 496 of file pgpa_output.c.

{
    switch (strategy)
    {
        case PGPA_SCAN_ORDINARY:
            return "ORDINARY_SCAN";
        case PGPA_SCAN_SEQ:
            return "SEQ_SCAN";
        case PGPA_SCAN_BITMAP_HEAP:
            return "BITMAP_HEAP_SCAN";
        case PGPA_SCAN_FOREIGN:
            return "FOREIGN_JOIN";
        case PGPA_SCAN_INDEX:
            return "INDEX_SCAN";
        case PGPA_SCAN_INDEX_ONLY:
            return "INDEX_ONLY_SCAN";
        case PGPA_SCAN_PARTITIONWISE:
            return "PARTITIONWISE";
        case PGPA_SCAN_TID:
            return "TID_SCAN";
    }
 
    pg_unreachable();
    return NULL;
}

References fb(), pg_unreachable, PGPA_SCAN_BITMAP_HEAP, PGPA_SCAN_FOREIGN, PGPA_SCAN_INDEX, PGPA_SCAN_INDEX_ONLY, PGPA_SCAN_ORDINARY, PGPA_SCAN_PARTITIONWISE, PGPA_SCAN_SEQ, and PGPA_SCAN_TID.

Referenced by pgpa_output_scan_strategy().

pgpa_maybe_linebreak()

static void pgpa_maybe_linebreak ( StringInfo  buf, int  wrap_column  )

static

Definition at line 559 of file pgpa_output.c.

{
    char       *trailing_nl;
    int         line_start;
    int         save_cursor;
 
    /* If line wrapping is disabled, exit quickly. */
    if (wrap_column <= 0)
        return;
 
    /*
     * Set line_start to the byte offset within buf->data of the first
     * character of the current line, where the current line means the last
     * one in the buffer. Note that line_start could be the offset of the
     * trailing '\0' if the last character in the buffer is a line break.
     */
    trailing_nl = strrchr(buf->data, '\n');
    if (trailing_nl == NULL)
        line_start = 0;
    else
        line_start = (trailing_nl - buf->data) + 1;
 
    /*
     * Remember that the current end of the buffer is a potential location to
     * insert a line break on a future call to this function.
     */
    save_cursor = buf->cursor;
    buf->cursor = buf->len;
 
    /* If we haven't passed the wrap column, we don't need a newline. */
    if (buf->len - line_start <= wrap_column)
        return;
 
    /*
     * It only makes sense to insert a newline at a position later than the
     * beginning of the current line.
     */
    if (save_cursor <= line_start)
        return;
 
    /* Insert a newline at the previous cursor location. */
    enlargeStringInfo(buf, 1);
    memmove(&buf->data[save_cursor] + 1, &buf->data[save_cursor],
            buf->len - save_cursor);
    ++buf->cursor;
    buf->data[++buf->len] = '\0';
    buf->data[save_cursor] = '\n';
}

References buf, enlargeStringInfo(), and fb().

Referenced by pgpa_output_advice(), pgpa_output_do_not_scan(), pgpa_output_query_feature(), pgpa_output_relations(), pgpa_output_scan_strategy(), pgpa_output_simple_strategy(), and pgpa_output_unrolled_join().

pgpa_output_advice()

void pgpa_output_advice	(	StringInfo	buf,
		pgpa_plan_walker_context *	walker,
		pgpa_identifier *	rt_identifiers
	)

Definition at line 80 of file pgpa_output.c.

{
    Index       rtable_length = list_length(walker->pstmt->rtable);
    ListCell   *lc;
    pgpa_output_context context;
 
    /* Basic initialization. */
    memset(&context, 0, sizeof(pgpa_output_context));
    context.buf = buf;
 
    /*
     * Convert identifiers to string form. Note that the loop variable here is
     * not an RTI, because RTIs are 1-based. Some RTIs will have no
     * identifier, either because the reloptkind is RTE_JOIN or because that
     * portion of the query didn't make it into the final plan.
     */
    context.rid_strings = palloc0_array(const char *, rtable_length);
    for (int i = 0; i < rtable_length; ++i)
        if (rt_identifiers[i].alias_name != NULL)
            context.rid_strings[i] = pgpa_identifier_string(&rt_identifiers[i]);
 
    /*
     * If the user chooses to use EXPLAIN (PLAN_ADVICE) in an 80-column window
     * from a psql client with default settings, psql will add one space to
     * the left of the output and EXPLAIN will add two more to the left of the
     * advice. Thus, lines of more than 77 characters will wrap. We set the
     * wrap limit to 76 here so that the output won't reach all the way to the
     * very last column of the terminal.
     *
     * Of course, this is fairly arbitrary set of assumptions, and one could
     * well make an argument for a different wrap limit, or for a configurable
     * one.
     */
    context.wrap_column = 76;
 
    /*
     * Each piece of JOIN_ORDER() advice fully describes the join order for a
     * a single unrolled join. Merging is not permitted, because that would
     * change the meaning, e.g. SEQ_SCAN(a b c d) means simply that sequential
     * scans should be used for all of those relations, and is thus equivalent
     * to SEQ_SCAN(a b) SEQ_SCAN(c d), but JOIN_ORDER(a b c d) means that "a"
     * is the driving table which is then joined to "b" then "c" then "d",
     * which is totally different from JOIN_ORDER(a b) and JOIN_ORDER(c d).
     */
    foreach(lc, walker->toplevel_unrolled_joins)
    {
        pgpa_unrolled_join *ujoin = lfirst(lc);
 
        if (buf->len > 0)
            appendStringInfoChar(buf, '\n');
        appendStringInfo(context.buf, "JOIN_ORDER(");
        pgpa_output_unrolled_join(&context, ujoin);
        appendStringInfoChar(context.buf, ')');
        pgpa_maybe_linebreak(context.buf, context.wrap_column);
    }
 
    /* Emit join strategy advice. */
    for (int s = 0; s < NUM_PGPA_JOIN_STRATEGY; ++s)
    {
        char       *strategy = pgpa_cstring_join_strategy(s);
 
        pgpa_output_simple_strategy(&context,
                                    strategy,
                                    walker->join_strategies[s]);
    }
 
    /*
     * Emit scan strategy advice (but not for ordinary scans, which are
     * definitionally uninteresting).
     */
    for (int c = 0; c < NUM_PGPA_SCAN_STRATEGY; ++c)
        if (c != PGPA_SCAN_ORDINARY)
            pgpa_output_scan_strategy(&context, c, walker->scans[c]);
 
    /* Emit query feature advice. */
    for (int t = 0; t < NUM_PGPA_QF_TYPES; ++t)
        pgpa_output_query_feature(&context, t, walker->query_features[t]);
 
    /* Emit NO_GATHER advice. */
    pgpa_output_no_gather(&context, walker->no_gather_scans);
 
    /* Emit DO_NOT_SCAN advice. */
    pgpa_output_do_not_scan(&context, walker->do_not_scan_identifiers);
}

References appendStringInfo(), appendStringInfoChar(), pgpa_output_context::buf, buf, fb(), i, lfirst, list_length(), NUM_PGPA_JOIN_STRATEGY, NUM_PGPA_QF_TYPES, NUM_PGPA_SCAN_STRATEGY, palloc0_array, pgpa_cstring_join_strategy(), pgpa_identifier_string(), pgpa_maybe_linebreak(), pgpa_output_do_not_scan(), pgpa_output_no_gather(), pgpa_output_query_feature(), pgpa_output_scan_strategy(), pgpa_output_simple_strategy(), pgpa_output_unrolled_join(), PGPA_SCAN_ORDINARY, pgpa_output_context::rid_strings, and pgpa_output_context::wrap_column.

Referenced by pgpa_planner_shutdown().

pgpa_output_do_not_scan()

static void pgpa_output_do_not_scan ( pgpa_output_context *  context, List *  identifiers  )

static

Definition at line 408 of file pgpa_output.c.

{
    bool        first = true;
 
    if (identifiers == NIL)
        return;
    if (context->buf->len > 0)
        appendStringInfoChar(context->buf, '\n');
    appendStringInfoString(context->buf, "DO_NOT_SCAN(");
 
    foreach_ptr(pgpa_identifier, rid, identifiers)
    {
        if (first)
            first = false;
        else
        {
            pgpa_maybe_linebreak(context->buf, context->wrap_column);
            appendStringInfoChar(context->buf, ' ');
        }
        appendStringInfoString(context->buf, pgpa_identifier_string(rid));
    }
 
    appendStringInfoChar(context->buf, ')');
}

References appendStringInfoChar(), appendStringInfoString(), pgpa_output_context::buf, foreach_ptr, StringInfoData::len, NIL, pgpa_identifier_string(), pgpa_maybe_linebreak(), and pgpa_output_context::wrap_column.

Referenced by pgpa_output_advice().

pgpa_output_join_member()

static void pgpa_output_join_member ( pgpa_output_context *  context, pgpa_join_member *  member  )

static

Definition at line 190 of file pgpa_output.c.

{
    if (member->unrolled_join != NULL)
    {
        appendStringInfoChar(context->buf, '(');
        pgpa_output_unrolled_join(context, member->unrolled_join);
        appendStringInfoChar(context->buf, ')');
    }
    else
    {
        pgpa_scan  *scan = member->scan;
 
        Assert(scan != NULL);
        if (bms_membership(scan->relids) == BMS_SINGLETON)
            pgpa_output_relations(context, context->buf, scan->relids);
        else
        {
            appendStringInfoChar(context->buf, '{');
            pgpa_output_relations(context, context->buf, scan->relids);
            appendStringInfoChar(context->buf, '}');
        }
    }
}

References appendStringInfoChar(), Assert, bms_membership(), BMS_SINGLETON, pgpa_output_context::buf, fb(), pgpa_output_relations(), pgpa_output_unrolled_join(), pgpa_scan::relids, pgpa_join_member::scan, and pgpa_join_member::unrolled_join.

Referenced by pgpa_output_unrolled_join().

pgpa_output_no_gather()

static void pgpa_output_no_gather ( pgpa_output_context *  context, Bitmapset *  relids  )

static

Definition at line 392 of file pgpa_output.c.

{
    if (relids == NULL)
        return;
    if (context->buf->len > 0)
        appendStringInfoChar(context->buf, '\n');
    appendStringInfoString(context->buf, "NO_GATHER(");
    pgpa_output_relations(context, context->buf, relids);
    appendStringInfoChar(context->buf, ')');
}

References appendStringInfoChar(), appendStringInfoString(), pgpa_output_context::buf, fb(), StringInfoData::len, and pgpa_output_relations().

Referenced by pgpa_output_advice().

pgpa_output_query_feature()

static void pgpa_output_query_feature ( pgpa_output_context *  context, pgpa_qf_type  type, List *  query_features  )

static

Definition at line 300 of file pgpa_output.c.

{
    bool        first = true;
 
    if (query_features == NIL)
        return;
 
    if (context->buf->len > 0)
        appendStringInfoChar(context->buf, '\n');
    appendStringInfo(context->buf, "%s(",
                     pgpa_cstring_query_feature_type(type));
 
    foreach_ptr(pgpa_query_feature, qf, query_features)
    {
        if (first)
            first = false;
        else
        {
            pgpa_maybe_linebreak(context->buf, context->wrap_column);
            appendStringInfoChar(context->buf, ' ');
        }
 
        if (bms_membership(qf->relids) == BMS_SINGLETON)
            pgpa_output_relations(context, context->buf, qf->relids);
        else
        {
            appendStringInfoChar(context->buf, '(');
            pgpa_output_relations(context, context->buf, qf->relids);
            appendStringInfoChar(context->buf, ')');
        }
    }
 
    appendStringInfoChar(context->buf, ')');
    pgpa_maybe_linebreak(context->buf, context->wrap_column);
}

References appendStringInfo(), appendStringInfoChar(), bms_membership(), BMS_SINGLETON, pgpa_output_context::buf, fb(), foreach_ptr, StringInfoData::len, NIL, pgpa_cstring_query_feature_type(), pgpa_maybe_linebreak(), pgpa_output_relations(), type, and pgpa_output_context::wrap_column.

Referenced by pgpa_output_advice().

pgpa_output_relation_name()

static void pgpa_output_relation_name ( pgpa_output_context *  context, Oid  relid  )

static

Definition at line 283 of file pgpa_output.c.

{
    Oid         nspoid = get_rel_namespace(relid);
    char       *relnamespace = get_namespace_name_or_temp(nspoid);
    char       *relname = get_rel_name(relid);
 
    appendStringInfoString(context->buf, quote_identifier(relnamespace));
    appendStringInfoChar(context->buf, '.');
    appendStringInfoString(context->buf, quote_identifier(relname));
}

References appendStringInfoChar(), appendStringInfoString(), pgpa_output_context::buf, fb(), get_namespace_name_or_temp(), get_rel_name(), get_rel_namespace(), quote_identifier(), and relname.

Referenced by pgpa_output_scan_strategy().

pgpa_output_relations()

static void pgpa_output_relations ( pgpa_output_context *  context, StringInfo  buf, Bitmapset *  relids  )

static

Definition at line 440 of file pgpa_output.c.

{
    int         rti = -1;
    bool        first = true;
 
    while ((rti = bms_next_member(relids, rti)) >= 0)
    {
        const char *rid_string = context->rid_strings[rti - 1];
 
        if (rid_string == NULL)
            elog(ERROR, "no identifier for RTI %d", rti);
 
        if (first)
        {
            first = false;
            appendStringInfoString(buf, rid_string);
        }
        else
        {
            pgpa_maybe_linebreak(buf, context->wrap_column);
            appendStringInfo(buf, " %s", rid_string);
        }
    }
}

References appendStringInfo(), appendStringInfoString(), bms_next_member(), buf, elog, ERROR, fb(), pgpa_maybe_linebreak(), pgpa_output_context::rid_strings, and pgpa_output_context::wrap_column.

Referenced by pgpa_output_join_member(), pgpa_output_no_gather(), pgpa_output_query_feature(), pgpa_output_scan_strategy(), and pgpa_output_simple_strategy().

pgpa_output_scan_strategy()

static void pgpa_output_scan_strategy ( pgpa_output_context *  context, pgpa_scan_strategy  strategy, List *  scans  )

static

Definition at line 221 of file pgpa_output.c.

{
    bool        first = true;
 
    if (scans == NIL)
        return;
 
    if (context->buf->len > 0)
        appendStringInfoChar(context->buf, '\n');
    appendStringInfo(context->buf, "%s(",
                     pgpa_cstring_scan_strategy(strategy));
 
    foreach_ptr(pgpa_scan, scan, scans)
    {
        Plan       *plan = scan->plan;
 
        if (first)
            first = false;
        else
        {
            pgpa_maybe_linebreak(context->buf, context->wrap_column);
            appendStringInfoChar(context->buf, ' ');
        }
 
        /* Output the relation identifiers. */
        if (bms_membership(scan->relids) == BMS_SINGLETON)
            pgpa_output_relations(context, context->buf, scan->relids);
        else
        {
            appendStringInfoChar(context->buf, '(');
            pgpa_output_relations(context, context->buf, scan->relids);
            appendStringInfoChar(context->buf, ')');
        }
 
        /* For index or index-only scans, output index information. */
        if (strategy == PGPA_SCAN_INDEX)
        {
            Assert(IsA(plan, IndexScan));
            pgpa_maybe_linebreak(context->buf, context->wrap_column);
            appendStringInfoChar(context->buf, ' ');
            pgpa_output_relation_name(context, ((IndexScan *) plan)->indexid);
        }
        else if (strategy == PGPA_SCAN_INDEX_ONLY)
        {
            Assert(IsA(plan, IndexOnlyScan));
            pgpa_maybe_linebreak(context->buf, context->wrap_column);
            appendStringInfoChar(context->buf, ' ');
            pgpa_output_relation_name(context,
                                      ((IndexOnlyScan *) plan)->indexid);
        }
    }
 
    appendStringInfoChar(context->buf, ')');
    pgpa_maybe_linebreak(context->buf, context->wrap_column);
}

References appendStringInfo(), appendStringInfoChar(), Assert, bms_membership(), BMS_SINGLETON, pgpa_output_context::buf, foreach_ptr, IsA, StringInfoData::len, NIL, pgpa_cstring_scan_strategy(), pgpa_maybe_linebreak(), pgpa_output_relation_name(), pgpa_output_relations(), PGPA_SCAN_INDEX, PGPA_SCAN_INDEX_ONLY, plan, and pgpa_output_context::wrap_column.

Referenced by pgpa_output_advice().

pgpa_output_simple_strategy()

static void pgpa_output_simple_strategy ( pgpa_output_context *  context, char *  strategy, List *  relid_sets  )

static

Definition at line 351 of file pgpa_output.c.

{
    bool        first = true;
 
    if (relid_sets == NIL)
        return;
 
    if (context->buf->len > 0)
        appendStringInfoChar(context->buf, '\n');
    appendStringInfo(context->buf, "%s(", strategy);
 
    foreach_node(Bitmapset, relids, relid_sets)
    {
        if (first)
            first = false;
        else
        {
            pgpa_maybe_linebreak(context->buf, context->wrap_column);
            appendStringInfoChar(context->buf, ' ');
        }
 
        if (bms_membership(relids) == BMS_SINGLETON)
            pgpa_output_relations(context, context->buf, relids);
        else
        {
            appendStringInfoChar(context->buf, '(');
            pgpa_output_relations(context, context->buf, relids);
            appendStringInfoChar(context->buf, ')');
        }
    }
 
    appendStringInfoChar(context->buf, ')');
    pgpa_maybe_linebreak(context->buf, context->wrap_column);
}

References appendStringInfo(), appendStringInfoChar(), bms_membership(), BMS_SINGLETON, pgpa_output_context::buf, fb(), foreach_node, StringInfoData::len, NIL, pgpa_maybe_linebreak(), pgpa_output_relations(), and pgpa_output_context::wrap_column.

Referenced by pgpa_output_advice().

pgpa_output_unrolled_join()

static void pgpa_output_unrolled_join ( pgpa_output_context *  context, pgpa_unrolled_join *  join  )

static

Definition at line 171 of file pgpa_output.c.

{
    pgpa_output_join_member(context, &join->outer);
 
    for (int k = 0; k < join->ninner; ++k)
    {
        pgpa_join_member *member = &join->inner[k];
 
        pgpa_maybe_linebreak(context->buf, context->wrap_column);
        appendStringInfoChar(context->buf, ' ');
        pgpa_output_join_member(context, member);
    }
}

References appendStringInfoChar(), pgpa_output_context::buf, pgpa_unrolled_join::inner, pgpa_unrolled_join::ninner, pgpa_unrolled_join::outer, pgpa_maybe_linebreak(), pgpa_output_join_member(), and pgpa_output_context::wrap_column.

Referenced by pgpa_output_advice(), and pgpa_output_join_member().