#include "postgres.h"
#include "common/hashfn.h"
#include "fmgr.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "pg_stash_advice.h"
#include "utils/builtins.h"
#include "utils/tuplestore.h"
#include "lib/simplehash.h"

Include dependency graph for stashfuncs.c:

Data Structures
struct	pgsa_stash_count

Macros
#define	SH_PREFIX pgsa_stash_count_table

#define	SH_ELEMENT_TYPE pgsa_stash_count

#define	SH_KEY_TYPE uint64

#define	SH_KEY pgsa_stash_id

#define	SH_HASH_KEY(tb, key) hash_bytes((const unsigned char *) &(key), sizeof(uint64))

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

#define	SH_SCOPE static inline

#define	SH_DEFINE

#define	SH_DECLARE

Typedefs
typedef struct pgsa_stash_count	pgsa_stash_count

Macro Definition Documentation

◆ SH_DECLARE

#define SH_DECLARE

Definition at line 44 of file stashfuncs.c.

◆ SH_DEFINE

#define SH_DEFINE

Definition at line 43 of file stashfuncs.c.

◆ SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE pgsa_stash_count

Definition at line 37 of file stashfuncs.c.

◆ SH_EQUAL

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

Definition at line 41 of file stashfuncs.c.

◆ SH_HASH_KEY

#define SH_HASH_KEY	(	tb,
		key
	)	hash_bytes((const unsigned char *) &(key), sizeof(uint64))

Definition at line 40 of file stashfuncs.c.

◆ SH_KEY

#define SH_KEY pgsa_stash_id

Definition at line 39 of file stashfuncs.c.

◆ SH_KEY_TYPE

#define SH_KEY_TYPE uint64

Definition at line 38 of file stashfuncs.c.

◆ SH_PREFIX

#define SH_PREFIX pgsa_stash_count_table

Definition at line 36 of file stashfuncs.c.

◆ SH_SCOPE

#define SH_SCOPE static inline

Definition at line 42 of file stashfuncs.c.

Typedef Documentation

◆ pgsa_stash_count

typedef struct pgsa_stash_count pgsa_stash_count

Function Documentation

◆ pg_create_advice_stash()

Datum pg_create_advice_stash ( PG_FUNCTION_ARGS )

Definition at line 51 of file stashfuncs.c.

{
    char       *stash_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    pgsa_check_stash_name(stash_name);
    if (unlikely(pgsa_entry_dshash == NULL))
        pgsa_attach();
    pgsa_check_lockout();
    LWLockAcquire(&pgsa_state->lock, LW_EXCLUSIVE);
    pgsa_create_stash(stash_name);
    LWLockRelease(&pgsa_state->lock);
    PG_RETURN_VOID();
}

References fb(), pgsa_shared_state::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PG_GETARG_TEXT_PP, PG_RETURN_VOID, pgsa_attach(), pgsa_check_lockout(), pgsa_check_stash_name(), pgsa_create_stash(), pgsa_entry_dshash, pgsa_state, text_to_cstring(), and unlikely.

◆ pg_drop_advice_stash()

Datum pg_drop_advice_stash ( PG_FUNCTION_ARGS )

Definition at line 69 of file stashfuncs.c.

{
    char       *stash_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    pgsa_check_stash_name(stash_name);
    if (unlikely(pgsa_entry_dshash == NULL))
        pgsa_attach();
    pgsa_check_lockout();
    LWLockAcquire(&pgsa_state->lock, LW_EXCLUSIVE);
    pgsa_drop_stash(stash_name);
    LWLockRelease(&pgsa_state->lock);
    PG_RETURN_VOID();
}

References fb(), pgsa_shared_state::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PG_GETARG_TEXT_PP, PG_RETURN_VOID, pgsa_attach(), pgsa_check_lockout(), pgsa_check_stash_name(), pgsa_drop_stash(), pgsa_entry_dshash, pgsa_state, text_to_cstring(), and unlikely.

◆ PG_FUNCTION_INFO_V1() [1/6]

PG_FUNCTION_INFO_V1 ( pg_create_advice_stash )

◆ PG_FUNCTION_INFO_V1() [2/6]

PG_FUNCTION_INFO_V1 ( pg_drop_advice_stash )

◆ PG_FUNCTION_INFO_V1() [3/6]

PG_FUNCTION_INFO_V1 ( pg_get_advice_stash_contents )

◆ PG_FUNCTION_INFO_V1() [4/6]

PG_FUNCTION_INFO_V1 ( pg_get_advice_stashes )

◆ PG_FUNCTION_INFO_V1() [5/6]

PG_FUNCTION_INFO_V1 ( pg_set_stashed_advice )

◆ PG_FUNCTION_INFO_V1() [6/6]

PG_FUNCTION_INFO_V1 ( pg_start_stash_advice_worker )

◆ pg_get_advice_stash_contents()

Datum pg_get_advice_stash_contents ( PG_FUNCTION_ARGS )

Definition at line 150 of file stashfuncs.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    dshash_seq_status iterator;
    char       *stash_name = NULL;
    pgsa_stash_name_table_hash *nhash = NULL;
    uint64      stash_id = 0;
    pgsa_entry *entry;
 
    InitMaterializedSRF(fcinfo, 0);
 
    /* Attach to dynamic shared memory if not already done. */
    if (unlikely(pgsa_entry_dshash == NULL))
        pgsa_attach();
 
    /* If stash data is still being restored from disk, ignore. */
    if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready))
        return (Datum) 0;
 
    /* User can pass NULL for all stashes, or the name of a specific stash. */
    if (!PG_ARGISNULL(0))
    {
        stash_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
        pgsa_check_stash_name(stash_name);
        stash_id = pgsa_lookup_stash_id(stash_name);
 
        /* If the user specified a stash name, it should exist. */
        if (stash_id == 0)
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("advice stash \"%s\" does not exist", stash_name));
    }
    else
    {
        pgsa_stash *stash;
 
        /*
         * If we're dumping data about all stashes, we need an ID->name lookup
         * table.
         */
        nhash = pgsa_stash_name_table_create(CurrentMemoryContext, 64, NULL);
        dshash_seq_init(&iterator, pgsa_stash_dshash, true);
        while ((stash = dshash_seq_next(&iterator)) != NULL)
        {
            pgsa_stash_name *n;
            bool        found;
 
            n = pgsa_stash_name_table_insert(nhash,
                                             stash->pgsa_stash_id,
                                             &found);
            Assert(!found);
            n->name = pstrdup(stash->name);
        }
        dshash_seq_term(&iterator);
    }
 
    /* Now iterate over all the entries. */
    dshash_seq_init(&iterator, pgsa_entry_dshash, false);
    while ((entry = dshash_seq_next(&iterator)) != NULL)
    {
        Datum       values[3];
        bool        nulls[3];
        char       *this_stash_name;
        char       *advice_string;
 
        /* Skip incomplete entries where the advice string was never set. */
        if (entry->advice_string == InvalidDsaPointer)
            continue;
 
        if (stash_id != 0)
        {
            /*
             * We're only dumping data for one particular stash, so skip
             * entries for any other stash and use the stash name specified by
             * the user.
             */
            if (stash_id != entry->key.pgsa_stash_id)
                continue;
            this_stash_name = stash_name;
        }
        else
        {
            pgsa_stash_name *n;
 
            /*
             * We're dumping data for all stashes, so look up the correct name
             * to use in the hash table. If nothing is found, which is
             * possible due to race conditions, make up a string to use.
             */
            n = pgsa_stash_name_table_lookup(nhash, entry->key.pgsa_stash_id);
            if (n != NULL)
                this_stash_name = n->name;
            else
                this_stash_name = psprintf("<stash %" PRIu64 ">",
                                           entry->key.pgsa_stash_id);
        }
 
        /* Work out tuple values. */
        values[0] = CStringGetTextDatum(this_stash_name);
        nulls[0] = false;
        values[1] = Int64GetDatum(entry->key.queryId);
        nulls[1] = false;
        advice_string = dsa_get_address(pgsa_dsa_area, entry->advice_string);
        values[2] = CStringGetTextDatum(advice_string);
        nulls[2] = false;
 
        /* Emit the tuple. */
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values,
                             nulls);
    }
    dshash_seq_term(&iterator);
 
    return (Datum) 0;
}

References pgsa_entry::advice_string, Assert, CStringGetTextDatum, CurrentMemoryContext, dsa_get_address(), dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), ereport, errcode(), errmsg, ERROR, fb(), InitMaterializedSRF(), Int64GetDatum(), InvalidDsaPointer, pgsa_entry::key, pgsa_stash_name::name, PG_ARGISNULL, pg_atomic_unlocked_test_flag(), PG_GETARG_TEXT_PP, pgsa_attach(), pgsa_check_stash_name(), pgsa_dsa_area, pgsa_entry_dshash, pgsa_lookup_stash_id(), pgsa_stash_dshash, pgsa_entry_key::pgsa_stash_id, pgsa_state, psprintf(), pstrdup(), pgsa_entry_key::queryId, pgsa_shared_state::stashes_ready, text_to_cstring(), tuplestore_putvalues(), unlikely, and values.

◆ pg_get_advice_stashes()

Datum pg_get_advice_stashes ( PG_FUNCTION_ARGS )

Definition at line 87 of file stashfuncs.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    dshash_seq_status iterator;
    pgsa_entry *entry;
    pgsa_stash *stash;
    pgsa_stash_count_table_hash *chash;
 
    InitMaterializedSRF(fcinfo, 0);
 
    /* Attach to dynamic shared memory if not already done. */
    if (unlikely(pgsa_entry_dshash == NULL))
        pgsa_attach();
 
    /* If stash data is still being restored from disk, ignore. */
    if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready))
        return (Datum) 0;
 
    /* Tally up the number of entries per stash. */
    chash = pgsa_stash_count_table_create(CurrentMemoryContext, 64, NULL);
    dshash_seq_init(&iterator, pgsa_entry_dshash, true);
    while ((entry = dshash_seq_next(&iterator)) != NULL)
    {
        pgsa_stash_count *c;
        bool        found;
 
        c = pgsa_stash_count_table_insert(chash,
                                          entry->key.pgsa_stash_id,
                                          &found);
        if (!found)
            c->num_entries = 1;
        else
            c->num_entries++;
    }
    dshash_seq_term(&iterator);
 
    /* Emit results. */
    dshash_seq_init(&iterator, pgsa_stash_dshash, true);
    while ((stash = dshash_seq_next(&iterator)) != NULL)
    {
        Datum       values[2];
        bool        nulls[2];
        pgsa_stash_count *c;
 
        values[0] = CStringGetTextDatum(stash->name);
        nulls[0] = false;
 
        c = pgsa_stash_count_table_lookup(chash, stash->pgsa_stash_id);
        values[1] = Int64GetDatum(c == NULL ? 0 : c->num_entries);
        nulls[1] = false;
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values,
                             nulls);
    }
    dshash_seq_term(&iterator);
 
    return (Datum) 0;
}

References CStringGetTextDatum, CurrentMemoryContext, dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), fb(), InitMaterializedSRF(), Int64GetDatum(), pgsa_entry::key, pg_atomic_unlocked_test_flag(), pgsa_attach(), pgsa_entry_dshash, pgsa_stash_dshash, pgsa_entry_key::pgsa_stash_id, pgsa_state, pgsa_shared_state::stashes_ready, tuplestore_putvalues(), unlikely, and values.

◆ pg_set_stashed_advice()

Datum pg_set_stashed_advice ( PG_FUNCTION_ARGS )

Definition at line 274 of file stashfuncs.c.

{
    char       *stash_name;
    int64       queryId;
 
    if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
        PG_RETURN_NULL();
 
    /* Get and check advice stash name. */
    stash_name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    pgsa_check_stash_name(stash_name);
 
    /*
     * Get and check query ID.
     *
     * Query ID 0 means no query ID was computed, so reject that.
     */
    queryId = PG_GETARG_INT64(1);
    if (queryId == 0)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("cannot set advice string for query ID 0"));
 
    /* Attach to dynamic shared memory if not already done. */
    if (unlikely(pgsa_entry_dshash == NULL))
        pgsa_attach();
 
    /* Don't allow writes if stash data is still being restored from disk. */
    pgsa_check_lockout();
 
    /* Now call the appropriate function to do the real work. */
    if (PG_ARGISNULL(2))
    {
        LWLockAcquire(&pgsa_state->lock, LW_SHARED);
        pgsa_clear_advice_string(stash_name, queryId);
        LWLockRelease(&pgsa_state->lock);
    }
    else
    {
        char       *advice_string = text_to_cstring(PG_GETARG_TEXT_PP(2));
 
        LWLockAcquire(&pgsa_state->lock, LW_SHARED);
        pgsa_set_advice_string(stash_name, queryId, advice_string);
        LWLockRelease(&pgsa_state->lock);
    }
 
    PG_RETURN_VOID();
}

References ereport, errcode(), errmsg, ERROR, fb(), pgsa_shared_state::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), PG_ARGISNULL, PG_GETARG_INT64, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_VOID, pgsa_attach(), pgsa_check_lockout(), pgsa_check_stash_name(), pgsa_clear_advice_string(), pgsa_entry_dshash, pgsa_set_advice_string(), pgsa_state, text_to_cstring(), and unlikely.

◆ pg_start_stash_advice_worker()

Datum pg_start_stash_advice_worker ( PG_FUNCTION_ARGS )

Definition at line 327 of file stashfuncs.c.

{
    pid_t       pid;
 
    if (unlikely(pgsa_entry_dshash == NULL))
        pgsa_attach();
 
    LWLockAcquire(&pgsa_state->lock, LW_SHARED);
    pid = pgsa_state->bgworker_pid;
    LWLockRelease(&pgsa_state->lock);
 
    if (pid != InvalidPid)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("pg_stash_advice worker is already running under PID %d",
                        (int) pid)));
 
    pgsa_start_worker();
 
    PG_RETURN_VOID();
}

References pgsa_shared_state::bgworker_pid, ereport, errcode(), errmsg, ERROR, fb(), InvalidPid, pgsa_shared_state::lock, LW_SHARED, LWLockAcquire(), LWLockRelease(), PG_RETURN_VOID, pgsa_attach(), pgsa_entry_dshash, pgsa_start_worker(), pgsa_state, and unlikely.

Functions
	PG_FUNCTION_INFO_V1 (pg_create_advice_stash)

	PG_FUNCTION_INFO_V1 (pg_drop_advice_stash)

	PG_FUNCTION_INFO_V1 (pg_get_advice_stash_contents)

	PG_FUNCTION_INFO_V1 (pg_get_advice_stashes)

	PG_FUNCTION_INFO_V1 (pg_set_stashed_advice)

	PG_FUNCTION_INFO_V1 (pg_start_stash_advice_worker)

Datum	pg_create_advice_stash (PG_FUNCTION_ARGS)

Datum	pg_drop_advice_stash (PG_FUNCTION_ARGS)

Datum	pg_get_advice_stashes (PG_FUNCTION_ARGS)

Datum	pg_get_advice_stash_contents (PG_FUNCTION_ARGS)

Datum	pg_set_stashed_advice (PG_FUNCTION_ARGS)

Datum	pg_start_stash_advice_worker (PG_FUNCTION_ARGS)

Data Structures

Macros

Typedefs

Functions