pgpa_trove.c File Reference

#include "postgres.h"
#include "pgpa_trove.h"
#include "common/hashfn_unstable.h"
#include "lib/simplehash.h"

Include dependency graph for pgpa_trove.c:

Go to the source code of this file.

Data Structures
struct	pgpa_trove_slice
struct	pgpa_trove
struct	pgpa_trove_entry_key
struct	pgpa_trove_entry_element

Macros
#define	SH_PREFIX   pgpa_trove_entry
#define	SH_ELEMENT_TYPE   pgpa_trove_entry_element
#define	SH_KEY_TYPE   pgpa_trove_entry_key
#define	SH_KEY   key
#define	SH_HASH_KEY(tb, key)   pgpa_trove_entry_hash_key(key)
#define	SH_EQUAL(tb, a, b)   pgpa_trove_entry_compare_key(a, b)
#define	SH_SCOPE   static inline
#define	SH_DECLARE
#define	SH_DEFINE

Typedefs
typedef struct pgpa_trove_slice	pgpa_trove_slice

Functions
static uint32	pgpa_trove_entry_hash_key (pgpa_trove_entry_key key)
static bool	pgpa_trove_entry_compare_key (pgpa_trove_entry_key a, pgpa_trove_entry_key b)
static void	pgpa_init_trove_slice (pgpa_trove_slice *tslice)
static void	pgpa_trove_add_to_slice (pgpa_trove_slice *tslice, pgpa_advice_tag_type tag, pgpa_advice_target *target)
static void	pgpa_trove_add_to_hash (pgpa_trove_entry_hash *hash, pgpa_advice_target *target, int index)
static Bitmapset *	pgpa_trove_slice_lookup (pgpa_trove_slice *tslice, pgpa_identifier *rid)
pgpa_trove *	pgpa_build_trove (List *advice_items)
void	pgpa_trove_lookup (pgpa_trove *trove, pgpa_trove_lookup_type type, int nrids, pgpa_identifier *rids, pgpa_trove_result *result)
void	pgpa_trove_lookup_all (pgpa_trove *trove, pgpa_trove_lookup_type type, pgpa_trove_entry **entries, int *nentries)
char *	pgpa_cstring_trove_entry (pgpa_trove_entry *entry)
void	pgpa_trove_set_flags (pgpa_trove_entry *entries, Bitmapset *indexes, int flags)
void	pgpa_trove_append_flags (StringInfo buf, int flags)

Macro Definition Documentation

SH_DECLARE

#define SH_DECLARE

Definition at line 111 of file pgpa_trove.c.

SH_DEFINE

#define SH_DEFINE

Definition at line 112 of file pgpa_trove.c.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   pgpa_trove_entry_element

Definition at line 105 of file pgpa_trove.c.

SH_EQUAL

#define SH_EQUAL	(		tb,
			a,
			b
	)		pgpa_trove_entry_compare_key(a, b)

Definition at line 109 of file pgpa_trove.c.

SH_HASH_KEY

#define SH_HASH_KEY	(		tb,
			key
	)		pgpa_trove_entry_hash_key(key)

Definition at line 108 of file pgpa_trove.c.

SH_KEY

#define SH_KEY   key

Definition at line 107 of file pgpa_trove.c.

SH_KEY_TYPE

#define SH_KEY_TYPE   pgpa_trove_entry_key

Definition at line 106 of file pgpa_trove.c.

SH_PREFIX

#define SH_PREFIX   pgpa_trove_entry

Definition at line 104 of file pgpa_trove.c.

SH_SCOPE

#define SH_SCOPE   static inline

Definition at line 110 of file pgpa_trove.c.

Typedef Documentation

pgpa_trove_slice

typedef struct pgpa_trove_slice pgpa_trove_slice

Function Documentation

pgpa_build_trove()

pgpa_trove * pgpa_build_trove

(

List *

advice_items

)

Definition at line 132 of file pgpa_trove.c.

{
    pgpa_trove *trove = palloc_object(pgpa_trove);
 
    pgpa_init_trove_slice(&trove->join);
    pgpa_init_trove_slice(&trove->rel);
    pgpa_init_trove_slice(&trove->scan);
 
    foreach_ptr(pgpa_advice_item, item, advice_items)
    {
        switch (item->tag)
        {
            case PGPA_TAG_JOIN_ORDER:
                {
                    pgpa_advice_target *target;
 
                    /*
                     * For most advice types, each element in the top-level
                     * list is a separate target, but it's most convenient to
                     * regard the entirety of a JOIN_ORDER specification as a
                     * single target. Since it wasn't represented that way
                     * during parsing, build a surrogate object now.
                     */
                    target = palloc0_object(pgpa_advice_target);
                    target->ttype = PGPA_TARGET_ORDERED_LIST;
                    target->children = item->targets;
 
                    pgpa_trove_add_to_slice(&trove->join,
                                            item->tag, target);
                }
                break;
 
            case PGPA_TAG_BITMAP_HEAP_SCAN:
            case PGPA_TAG_INDEX_ONLY_SCAN:
            case PGPA_TAG_INDEX_SCAN:
            case PGPA_TAG_SEQ_SCAN:
            case PGPA_TAG_TID_SCAN:
 
                /*
                 * Scan advice.
                 */
                foreach_ptr(pgpa_advice_target, target, item->targets)
                {
                    /*
                     * For now, all of our scan types target single relations,
                     * but in the future this might not be true, e.g. a custom
                     * scan could replace a join.
                     */
                    Assert(target->ttype == PGPA_TARGET_IDENTIFIER);
                    pgpa_trove_add_to_slice(&trove->scan,
                                            item->tag, target);
                }
                break;
 
            case PGPA_TAG_FOREIGN_JOIN:
            case PGPA_TAG_HASH_JOIN:
            case PGPA_TAG_MERGE_JOIN_MATERIALIZE:
            case PGPA_TAG_MERGE_JOIN_PLAIN:
            case PGPA_TAG_NESTED_LOOP_MATERIALIZE:
            case PGPA_TAG_NESTED_LOOP_MEMOIZE:
            case PGPA_TAG_NESTED_LOOP_PLAIN:
            case PGPA_TAG_SEMIJOIN_NON_UNIQUE:
            case PGPA_TAG_SEMIJOIN_UNIQUE:
 
                /*
                 * Join strategy advice.
                 */
                foreach_ptr(pgpa_advice_target, target, item->targets)
                {
                    pgpa_trove_add_to_slice(&trove->join,
                                            item->tag, target);
                }
                break;
 
            case PGPA_TAG_PARTITIONWISE:
            case PGPA_TAG_GATHER:
            case PGPA_TAG_GATHER_MERGE:
            case PGPA_TAG_NO_GATHER:
 
                /*
                 * Advice about a RelOptInfo relevant to both scans and joins.
                 */
                foreach_ptr(pgpa_advice_target, target, item->targets)
                {
                    pgpa_trove_add_to_slice(&trove->rel,
                                            item->tag, target);
                }
                break;
        }
    }
 
    return trove;
}

References Assert, pgpa_advice_target::children, fb(), foreach_ptr, pgpa_trove::join, palloc0_object, palloc_object, pgpa_init_trove_slice(), PGPA_TAG_BITMAP_HEAP_SCAN, PGPA_TAG_FOREIGN_JOIN, PGPA_TAG_GATHER, PGPA_TAG_GATHER_MERGE, PGPA_TAG_HASH_JOIN, PGPA_TAG_INDEX_ONLY_SCAN, PGPA_TAG_INDEX_SCAN, PGPA_TAG_JOIN_ORDER, PGPA_TAG_MERGE_JOIN_MATERIALIZE, PGPA_TAG_MERGE_JOIN_PLAIN, PGPA_TAG_NESTED_LOOP_MATERIALIZE, PGPA_TAG_NESTED_LOOP_MEMOIZE, PGPA_TAG_NESTED_LOOP_PLAIN, PGPA_TAG_NO_GATHER, PGPA_TAG_PARTITIONWISE, PGPA_TAG_SEMIJOIN_NON_UNIQUE, PGPA_TAG_SEMIJOIN_UNIQUE, PGPA_TAG_SEQ_SCAN, PGPA_TAG_TID_SCAN, PGPA_TARGET_IDENTIFIER, PGPA_TARGET_ORDERED_LIST, pgpa_trove_add_to_slice(), pgpa_trove::rel, pgpa_trove::scan, and pgpa_advice_target::ttype.

Referenced by pgpa_planner_setup().

pgpa_cstring_trove_entry()

char * pgpa_cstring_trove_entry

(

pgpa_trove_entry *

entry

)

Definition at line 295 of file pgpa_trove.c.

{
    StringInfoData buf;
 
    initStringInfo(&buf);
    appendStringInfo(&buf, "%s", pgpa_cstring_advice_tag(entry->tag));
 
    /* JOIN_ORDER tags are transformed by pgpa_build_trove; undo that here */
    if (entry->tag != PGPA_TAG_JOIN_ORDER)
        appendStringInfoChar(&buf, '(');
    else
        Assert(entry->target->ttype == PGPA_TARGET_ORDERED_LIST);
 
    pgpa_format_advice_target(&buf, entry->target);
 
    if (entry->target->itarget != NULL)
    {
        appendStringInfoChar(&buf, ' ');
        pgpa_format_index_target(&buf, entry->target->itarget);
    }
 
    if (entry->tag != PGPA_TAG_JOIN_ORDER)
        appendStringInfoChar(&buf, ')');
 
    return buf.data;
}

References appendStringInfo(), appendStringInfoChar(), Assert, buf, fb(), initStringInfo(), pgpa_advice_target::itarget, pgpa_cstring_advice_tag(), pgpa_format_advice_target(), pgpa_format_index_target(), PGPA_TAG_JOIN_ORDER, PGPA_TARGET_ORDERED_LIST, pgpa_trove_entry::tag, pgpa_trove_entry::target, and pgpa_advice_target::ttype.

Referenced by pgpa_planner_append_feedback().

pgpa_init_trove_slice()

static void pgpa_init_trove_slice ( pgpa_trove_slice *  tslice )

static

Definition at line 431 of file pgpa_trove.c.

{
    /*
     * In an ideal world, we'll make tslice->nallocated big enough that the
     * array and hash table will be large enough to contain the number of
     * advice items in this trove slice, but a generous default value is not
     * good for performance, because pgpa_init_trove_slice() has to zero an
     * amount of memory proportional to tslice->nallocated. Hence, we keep the
     * starting value quite small, on the theory that advice strings will
     * often be relatively short.
     */
    tslice->nallocated = 16;
    tslice->nused = 0;
    tslice->entries = palloc_array(pgpa_trove_entry, tslice->nallocated);
    tslice->hash = pgpa_trove_entry_create(CurrentMemoryContext,
                                           tslice->nallocated, NULL);
}

References CurrentMemoryContext, fb(), and palloc_array.

Referenced by pgpa_build_trove().

pgpa_trove_add_to_hash()

static void pgpa_trove_add_to_hash ( pgpa_trove_entry_hash *  hash, pgpa_advice_target *  target, int  index  )

static

Definition at line 396 of file pgpa_trove.c.

{
    pgpa_trove_entry_key key;
    pgpa_trove_entry_element *element;
    bool        found;
 
    /* For non-identifiers, add entries for all descendants. */
    if (target->ttype != PGPA_TARGET_IDENTIFIER)
    {
        foreach_ptr(pgpa_advice_target, child_target, target->children)
        {
            pgpa_trove_add_to_hash(hash, child_target, index);
        }
        return;
    }
 
    /* Sanity checks. */
    Assert(target->rid.occurrence > 0);
    Assert(target->rid.alias_name != NULL);
 
    /* Add an entry for this relation identifier. */
    key.alias_name = target->rid.alias_name;
    key.partition_name = target->rid.partrel;
    key.plan_name = target->rid.plan_name;
    element = pgpa_trove_entry_insert(hash, key, &found);
    if (!found)
        element->indexes = NULL;
    element->indexes = bms_add_member(element->indexes, index);
}

References pgpa_identifier::alias_name, Assert, bms_add_member(), pgpa_advice_target::children, element(), fb(), foreach_ptr, hash(), pgpa_identifier::occurrence, pgpa_identifier::partrel, PGPA_TARGET_IDENTIFIER, pgpa_trove_add_to_hash(), pgpa_identifier::plan_name, pgpa_advice_target::rid, and pgpa_advice_target::ttype.

Referenced by pgpa_trove_add_to_hash(), and pgpa_trove_add_to_slice().

pgpa_trove_add_to_slice()

static void pgpa_trove_add_to_slice ( pgpa_trove_slice *  tslice, pgpa_advice_tag_type  tag, pgpa_advice_target *  target  )

static

Definition at line 366 of file pgpa_trove.c.

{
    pgpa_trove_entry *entry;
 
    if (tslice->nused >= tslice->nallocated)
    {
        int         new_allocated;
 
        new_allocated = tslice->nallocated * 2;
        tslice->entries = repalloc_array(tslice->entries, pgpa_trove_entry,
                                         new_allocated);
        tslice->nallocated = new_allocated;
    }
 
    entry = &tslice->entries[tslice->nused];
    entry->tag = tag;
    entry->target = target;
    entry->flags = 0;
 
    pgpa_trove_add_to_hash(tslice->hash, target, tslice->nused);
 
    tslice->nused++;
}

References fb(), pgpa_trove_entry::flags, pgpa_trove_add_to_hash(), repalloc_array, pgpa_trove_entry::tag, and pgpa_trove_entry::target.

Referenced by pgpa_build_trove().

pgpa_trove_append_flags()

void pgpa_trove_append_flags	(	StringInfo	buf,
		int	flags
	)

Definition at line 343 of file pgpa_trove.c.

{
    if ((flags & PGPA_TE_MATCH_FULL) != 0)
    {
        Assert((flags & PGPA_TE_MATCH_PARTIAL) != 0);
        appendStringInfo(buf, "matched");
    }
    else if ((flags & PGPA_TE_MATCH_PARTIAL) != 0)
        appendStringInfo(buf, "partially matched");
    else
        appendStringInfo(buf, "not matched");
    if ((flags & PGPA_TE_INAPPLICABLE) != 0)
        appendStringInfo(buf, ", inapplicable");
    if ((flags & PGPA_TE_CONFLICTING) != 0)
        appendStringInfo(buf, ", conflicting");
    if ((flags & PGPA_TE_FAILED) != 0)
        appendStringInfo(buf, ", failed");
}

References appendStringInfo(), Assert, buf, PGPA_TE_CONFLICTING, PGPA_TE_FAILED, PGPA_TE_INAPPLICABLE, PGPA_TE_MATCH_FULL, and PGPA_TE_MATCH_PARTIAL.

Referenced by pg_plan_advice_explain_feedback(), and pgpa_planner_feedback_warning().

pgpa_trove_entry_compare_key()

static bool pgpa_trove_entry_compare_key ( pgpa_trove_entry_key  a, pgpa_trove_entry_key  b  )

inlinestatic

Definition at line 90 of file pgpa_trove.c.

{
    if (strcmp(a.alias_name, b.alias_name) != 0)
        return false;
 
    if (!strings_equal_or_both_null(a.partition_name, b.partition_name))
        return false;
 
    if (!strings_equal_or_both_null(a.plan_name, b.plan_name))
        return false;
 
    return true;
}

References a, b, fb(), and strings_equal_or_both_null().

pgpa_trove_entry_hash_key()

static uint32 pgpa_trove_entry_hash_key ( pgpa_trove_entry_key  key )

static

Definition at line 454 of file pgpa_trove.c.

{
    fasthash_state hs;
    int         sp_len;
 
    fasthash_init(&hs, 0);
 
    /* alias_name may not be NULL */
    sp_len = fasthash_accum_cstring(&hs, key.alias_name);
 
    /* partition_name and plan_name, however, can be NULL */
    if (key.partition_name != NULL)
        sp_len += fasthash_accum_cstring(&hs, key.partition_name);
    if (key.plan_name != NULL)
        sp_len += fasthash_accum_cstring(&hs, key.plan_name);
 
    /*
     * hashfn_unstable.h recommends using string length as tweak. It's not
     * clear to me what to do if there are multiple strings, so for now I'm
     * just using the total of all of the lengths.
     */
    return fasthash_final32(&hs, sp_len);
}

References fasthash_accum_cstring(), fasthash_final32(), fasthash_init(), and fb().

pgpa_trove_lookup()

void pgpa_trove_lookup	(	pgpa_trove *	trove,
		pgpa_trove_lookup_type	type,
		int	nrids,
		pgpa_identifier *	rids,
		pgpa_trove_result *	result
	)

Definition at line 233 of file pgpa_trove.c.

{
    pgpa_trove_slice *tslice;
    Bitmapset  *indexes;
 
    Assert(nrids > 0);
 
    if (type == PGPA_TROVE_LOOKUP_SCAN)
        tslice = &trove->scan;
    else if (type == PGPA_TROVE_LOOKUP_JOIN)
        tslice = &trove->join;
    else
        tslice = &trove->rel;
 
    indexes = pgpa_trove_slice_lookup(tslice, &rids[0]);
    for (int i = 1; i < nrids; ++i)
    {
        Bitmapset  *other_indexes;
 
        /*
         * If the caller is asking about two relations that aren't part of the
         * same subquery, they've messed up.
         */
        Assert(strings_equal_or_both_null(rids[0].plan_name,
                                          rids[i].plan_name));
 
        other_indexes = pgpa_trove_slice_lookup(tslice, &rids[i]);
        indexes = bms_union(indexes, other_indexes);
    }
 
    result->entries = tslice->entries;
    result->indexes = indexes;
}

References Assert, bms_union(), pgpa_trove_result::entries, fb(), i, pgpa_trove_result::indexes, pgpa_trove::join, PGPA_TROVE_LOOKUP_JOIN, PGPA_TROVE_LOOKUP_SCAN, pgpa_trove_slice_lookup(), pgpa_trove::rel, pgpa_trove::scan, strings_equal_or_both_null(), and type.

Referenced by pgpa_build_simple_rel(), and pgpa_get_join_state().

pgpa_trove_lookup_all()

void pgpa_trove_lookup_all	(	pgpa_trove *	trove,
		pgpa_trove_lookup_type	type,
		pgpa_trove_entry **	entries,
		int *	nentries
	)

Definition at line 275 of file pgpa_trove.c.

{
    pgpa_trove_slice *tslice;
 
    if (type == PGPA_TROVE_LOOKUP_SCAN)
        tslice = &trove->scan;
    else if (type == PGPA_TROVE_LOOKUP_JOIN)
        tslice = &trove->join;
    else
        tslice = &trove->rel;
 
    *entries = tslice->entries;
    *nentries = tslice->nused;
}

References fb(), pgpa_trove::join, PGPA_TROVE_LOOKUP_JOIN, PGPA_TROVE_LOOKUP_SCAN, pgpa_trove::rel, pgpa_trove::scan, and type.

Referenced by pgpa_planner_append_feedback().

pgpa_trove_set_flags()

void pgpa_trove_set_flags	(	pgpa_trove_entry *	entries,
		Bitmapset *	indexes,
		int	flags
	)

Definition at line 326 of file pgpa_trove.c.

{
    int         i = -1;
 
    while ((i = bms_next_member(indexes, i)) >= 0)
    {
        pgpa_trove_entry *entry = &entries[i];
 
        entry->flags |= flags;
    }
}

References bms_next_member(), pgpa_trove_entry::flags, and i.

Referenced by pgpa_planner_apply_join_path_advice(), pgpa_planner_apply_joinrel_advice(), and pgpa_planner_apply_scan_advice().

pgpa_trove_slice_lookup()

static Bitmapset * pgpa_trove_slice_lookup ( pgpa_trove_slice *  tslice, pgpa_identifier *  rid  )

static

Definition at line 482 of file pgpa_trove.c.

{
    pgpa_trove_entry_key key;
    pgpa_trove_entry_element *element;
    Bitmapset  *result = NULL;
 
    Assert(rid->occurrence >= 1);
 
    key.alias_name = rid->alias_name;
    key.partition_name = rid->partrel;
    key.plan_name = rid->plan_name;
 
    element = pgpa_trove_entry_lookup(tslice->hash, key);
 
    if (element != NULL)
    {
        int         i = -1;
 
        while ((i = bms_next_member(element->indexes, i)) >= 0)
        {
            pgpa_trove_entry *entry = &tslice->entries[i];
 
            /*
             * We know that this target or one of its descendants matches the
             * identifier on the three key fields above, but we don't know
             * which descendant or whether the occurrence and schema also
             * match.
             */
            if (pgpa_identifier_matches_target(rid, entry->target))
                result = bms_add_member(result, i);
        }
    }
 
    return result;
}

References pgpa_identifier::alias_name, Assert, bms_add_member(), bms_next_member(), element(), fb(), i, pgpa_identifier::occurrence, pgpa_identifier::partrel, pgpa_identifier_matches_target(), pgpa_identifier::plan_name, and pgpa_trove_entry::target.

Referenced by pgpa_trove_lookup().