guc_tables.h File Reference

#include "lib/ilist.h"
#include "utils/guc.h"

Include dependency graph for guc_tables.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
union	config_var_val
struct	config_var_value
struct	guc_stack
struct	config_generic
struct	config_bool
struct	config_int
struct	config_real
struct	config_string
struct	config_enum

Macros
#define	GUC_IS_IN_FILE   0x0001 /* found it in config file */
#define	GUC_PENDING_RESTART   0x0002 /* changed value cannot be applied yet */
#define	GUC_NEEDS_REPORT   0x0004 /* new value must be reported to client */

Typedefs
typedef struct config_var_value	config_var_value
typedef struct guc_stack	GucStack

Enumerations
enum	config_type {   PGC_BOOL , PGC_INT , PGC_REAL , PGC_STRING ,   PGC_ENUM }
enum	config_group {   UNGROUPED , FILE_LOCATIONS , CONN_AUTH_SETTINGS , CONN_AUTH_TCP ,   CONN_AUTH_AUTH , CONN_AUTH_SSL , RESOURCES_MEM , RESOURCES_DISK ,   RESOURCES_KERNEL , RESOURCES_VACUUM_DELAY , RESOURCES_BGWRITER , RESOURCES_ASYNCHRONOUS ,   WAL_SETTINGS , WAL_CHECKPOINTS , WAL_ARCHIVING , WAL_RECOVERY ,   WAL_ARCHIVE_RECOVERY , WAL_RECOVERY_TARGET , REPLICATION_SENDING , REPLICATION_PRIMARY ,   REPLICATION_STANDBY , REPLICATION_SUBSCRIBERS , QUERY_TUNING_METHOD , QUERY_TUNING_COST ,   QUERY_TUNING_GEQO , QUERY_TUNING_OTHER , LOGGING_WHERE , LOGGING_WHEN ,   LOGGING_WHAT , PROCESS_TITLE , STATS_MONITORING , STATS_CUMULATIVE ,   AUTOVACUUM , CLIENT_CONN_STATEMENT , CLIENT_CONN_LOCALE , CLIENT_CONN_PRELOAD ,   CLIENT_CONN_OTHER , LOCK_MANAGEMENT , COMPAT_OPTIONS_PREVIOUS , COMPAT_OPTIONS_CLIENT ,   ERROR_HANDLING_OPTIONS , PRESET_OPTIONS , CUSTOM_OPTIONS , DEVELOPER_OPTIONS }
enum	GucStackState { GUC_SAVE , GUC_SET , GUC_LOCAL , GUC_SET_LOCAL }

Functions
struct config_generic *	find_option (const char *name, bool create_placeholders, bool skip_errors, int elevel)
struct config_generic **	get_explain_guc_options (int *num)
char *	ShowGUCOption (struct config_generic *record, bool use_units)
bool	ConfigOptionIsVisible (struct config_generic *conf)
struct config_generic **	get_guc_variables (int *num_vars)
void	build_guc_variables (void)
const char *	config_enum_lookup_by_value (struct config_enum *record, int val)
bool	config_enum_lookup_by_name (struct config_enum *record, const char *value, int *retval)
char *	config_enum_get_options (struct config_enum *record, const char *prefix, const char *suffix, const char *separator)

Variables
PGDLLIMPORT const char *const	config_group_names []
PGDLLIMPORT const char *const	config_type_names []
PGDLLIMPORT const char *const	GucContext_Names []
PGDLLIMPORT const char *const	GucSource_Names []
PGDLLIMPORT struct config_bool	ConfigureNamesBool []
PGDLLIMPORT struct config_int	ConfigureNamesInt []
PGDLLIMPORT struct config_real	ConfigureNamesReal []
PGDLLIMPORT struct config_string	ConfigureNamesString []
PGDLLIMPORT struct config_enum	ConfigureNamesEnum []

Macro Definition Documentation

GUC_IS_IN_FILE

#define GUC_IS_IN_FILE   0x0001 /* found it in config file */

Definition at line 186 of file guc_tables.h.

GUC_NEEDS_REPORT

#define GUC_NEEDS_REPORT   0x0004 /* new value must be reported to client */

Definition at line 192 of file guc_tables.h.

GUC_PENDING_RESTART

#define GUC_PENDING_RESTART   0x0002 /* changed value cannot be applied yet */

Definition at line 191 of file guc_tables.h.

Typedef Documentation

config_var_value

typedef struct config_var_value config_var_value

GucStack

typedef struct guc_stack GucStack

Enumeration Type Documentation

config_group

enum config_group

Enumerator
UNGROUPED
FILE_LOCATIONS
CONN_AUTH_SETTINGS
CONN_AUTH_TCP
CONN_AUTH_AUTH
CONN_AUTH_SSL
RESOURCES_MEM
RESOURCES_DISK
RESOURCES_KERNEL
RESOURCES_VACUUM_DELAY
RESOURCES_BGWRITER
RESOURCES_ASYNCHRONOUS
WAL_SETTINGS
WAL_CHECKPOINTS
WAL_ARCHIVING
WAL_RECOVERY
WAL_ARCHIVE_RECOVERY
WAL_RECOVERY_TARGET
REPLICATION_SENDING
REPLICATION_PRIMARY
REPLICATION_STANDBY
REPLICATION_SUBSCRIBERS
QUERY_TUNING_METHOD
QUERY_TUNING_COST
QUERY_TUNING_GEQO
QUERY_TUNING_OTHER
LOGGING_WHERE
LOGGING_WHEN
LOGGING_WHAT
PROCESS_TITLE
STATS_MONITORING
STATS_CUMULATIVE
AUTOVACUUM
CLIENT_CONN_STATEMENT
CLIENT_CONN_LOCALE
CLIENT_CONN_PRELOAD
CLIENT_CONN_OTHER
LOCK_MANAGEMENT
COMPAT_OPTIONS_PREVIOUS
COMPAT_OPTIONS_CLIENT
ERROR_HANDLING_OPTIONS
PRESET_OPTIONS
CUSTOM_OPTIONS
DEVELOPER_OPTIONS

Definition at line 55 of file guc_tables.h.

{
    UNGROUPED,                  /* use for options not shown in pg_settings */
    FILE_LOCATIONS,
    CONN_AUTH_SETTINGS,
    CONN_AUTH_TCP,
    CONN_AUTH_AUTH,
    CONN_AUTH_SSL,
    RESOURCES_MEM,
    RESOURCES_DISK,
    RESOURCES_KERNEL,
    RESOURCES_VACUUM_DELAY,
    RESOURCES_BGWRITER,
    RESOURCES_ASYNCHRONOUS,
    WAL_SETTINGS,
    WAL_CHECKPOINTS,
    WAL_ARCHIVING,
    WAL_RECOVERY,
    WAL_ARCHIVE_RECOVERY,
    WAL_RECOVERY_TARGET,
    REPLICATION_SENDING,
    REPLICATION_PRIMARY,
    REPLICATION_STANDBY,
    REPLICATION_SUBSCRIBERS,
    QUERY_TUNING_METHOD,
    QUERY_TUNING_COST,
    QUERY_TUNING_GEQO,
    QUERY_TUNING_OTHER,
    LOGGING_WHERE,
    LOGGING_WHEN,
    LOGGING_WHAT,
    PROCESS_TITLE,
    STATS_MONITORING,
    STATS_CUMULATIVE,
    AUTOVACUUM,
    CLIENT_CONN_STATEMENT,
    CLIENT_CONN_LOCALE,
    CLIENT_CONN_PRELOAD,
    CLIENT_CONN_OTHER,
    LOCK_MANAGEMENT,
    COMPAT_OPTIONS_PREVIOUS,
    COMPAT_OPTIONS_CLIENT,
    ERROR_HANDLING_OPTIONS,
    PRESET_OPTIONS,
    CUSTOM_OPTIONS,
    DEVELOPER_OPTIONS
};

config_type

enum config_type

Enumerator
PGC_BOOL
PGC_INT
PGC_REAL
PGC_STRING
PGC_ENUM

Definition at line 23 of file guc_tables.h.

{
    PGC_BOOL,
    PGC_INT,
    PGC_REAL,
    PGC_STRING,
    PGC_ENUM
};

GucStackState

enum GucStackState

Enumerator
GUC_SAVE
GUC_SET
GUC_LOCAL
GUC_SET_LOCAL

Definition at line 107 of file guc_tables.h.

{
    /* This is almost GucAction, but we need a fourth state for SET+LOCAL */
    GUC_SAVE,                   /* entry caused by function SET option */
    GUC_SET,                    /* entry caused by plain SET command */
    GUC_LOCAL,                  /* entry caused by SET LOCAL command */
    GUC_SET_LOCAL               /* entry caused by SET then SET LOCAL */
} GucStackState;

Function Documentation

build_guc_variables()

void build_guc_variables

(

void

)

Definition at line 895 of file guc.c.

{
    int         size_vars;
    int         num_vars = 0;
    HASHCTL     hash_ctl;
    GUCHashEntry *hentry;
    bool        found;
    int         i;
 
    /*
     * Create the memory context that will hold all GUC-related data.
     */
    Assert(GUCMemoryContext == NULL);
    GUCMemoryContext = AllocSetContextCreate(TopMemoryContext,
                                             "GUCMemoryContext",
                                             ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Count all the built-in variables, and set their vartypes correctly.
     */
    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
    {
        struct config_bool *conf = &ConfigureNamesBool[i];
 
        /* Rather than requiring vartype to be filled in by hand, do this: */
        conf->gen.vartype = PGC_BOOL;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
    {
        struct config_int *conf = &ConfigureNamesInt[i];
 
        conf->gen.vartype = PGC_INT;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
    {
        struct config_real *conf = &ConfigureNamesReal[i];
 
        conf->gen.vartype = PGC_REAL;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesString[i].gen.name; i++)
    {
        struct config_string *conf = &ConfigureNamesString[i];
 
        conf->gen.vartype = PGC_STRING;
        num_vars++;
    }
 
    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
    {
        struct config_enum *conf = &ConfigureNamesEnum[i];
 
        conf->gen.vartype = PGC_ENUM;
        num_vars++;
    }
 
    /*
     * Create hash table with 20% slack
     */
    size_vars = num_vars + num_vars / 4;
 
    hash_ctl.keysize = sizeof(char *);
    hash_ctl.entrysize = sizeof(GUCHashEntry);
    hash_ctl.hash = guc_name_hash;
    hash_ctl.match = guc_name_match;
    hash_ctl.hcxt = GUCMemoryContext;
    guc_hashtab = hash_create("GUC hash table",
                              size_vars,
                              &hash_ctl,
                              HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT);
 
    for (i = 0; ConfigureNamesBool[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesInt[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesReal[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesString[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesString[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
    {
        struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
 
        hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                              &gucvar->name,
                                              HASH_ENTER,
                                              &found);
        Assert(!found);
        hentry->gucvar = gucvar;
    }
 
    Assert(num_vars == hash_get_num_entries(guc_hashtab));
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), ConfigureNamesBool, ConfigureNamesEnum, ConfigureNamesInt, ConfigureNamesReal, ConfigureNamesString, HASHCTL::entrysize, config_bool::gen, config_int::gen, config_real::gen, config_string::gen, config_enum::gen, guc_hashtab, guc_name_hash(), guc_name_match(), GUCMemoryContext, GUCHashEntry::gucvar, HASHCTL::hash, HASH_COMPARE, HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_ENTER, HASH_FUNCTION, hash_get_num_entries(), hash_search(), HASHCTL::hcxt, i, HASHCTL::keysize, HASHCTL::match, config_generic::name, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, TopMemoryContext, and config_generic::vartype.

Referenced by GucInfoMain(), and InitializeGUCOptions().

config_enum_get_options()

char* config_enum_get_options	(	struct config_enum *	record,
		const char *	prefix,
		const char *	suffix,
		const char *	separator
	)

Definition at line 3024 of file guc.c.

{
    const struct config_enum_entry *entry;
    StringInfoData retstr;
    int         seplen;
 
    initStringInfo(&retstr);
    appendStringInfoString(&retstr, prefix);
 
    seplen = strlen(separator);
    for (entry = record->options; entry && entry->name; entry++)
    {
        if (!entry->hidden)
        {
            appendStringInfoString(&retstr, entry->name);
            appendBinaryStringInfo(&retstr, separator, seplen);
        }
    }
 
    /*
     * All the entries may have been hidden, leaving the string empty if no
     * prefix was given. This indicates a broken GUC setup, since there is no
     * use for an enum without any values, so we just check to make sure we
     * don't write to invalid memory instead of actually trying to do
     * something smart with it.
     */
    if (retstr.len >= seplen)
    {
        /* Replace final separator */
        retstr.data[retstr.len - seplen] = '\0';
        retstr.len -= seplen;
    }
 
    appendStringInfoString(&retstr, suffix);
 
    return retstr.data;
}

References appendBinaryStringInfo(), appendStringInfoString(), StringInfoData::data, config_enum_entry::hidden, initStringInfo(), StringInfoData::len, config_enum_entry::name, and config_enum::options.

Referenced by GetConfigOptionValues(), and parse_and_validate_value().

config_enum_lookup_by_name()

bool config_enum_lookup_by_name	(	struct config_enum *	record,
		const char *	value,
		int *	retval
	)

Definition at line 2998 of file guc.c.

{
    const struct config_enum_entry *entry;
 
    for (entry = record->options; entry && entry->name; entry++)
    {
        if (pg_strcasecmp(value, entry->name) == 0)
        {
            *retval = entry->val;
            return true;
        }
    }
 
    *retval = 0;
    return false;
}

References config_enum_entry::name, config_enum::options, pg_strcasecmp(), config_enum_entry::val, and value.

Referenced by parse_and_validate_value().

config_enum_lookup_by_value()

const char* config_enum_lookup_by_value	(	struct config_enum *	record,
		int	val
	)

Definition at line 2975 of file guc.c.

{
    const struct config_enum_entry *entry;
 
    for (entry = record->options; entry && entry->name; entry++)
    {
        if (entry->val == val)
            return entry->name;
    }
 
    elog(ERROR, "could not find enum option %d for %s",
         val, record->gen.name);
    return NULL;                /* silence compiler */
}

References elog(), ERROR, config_enum::gen, config_enum_entry::name, config_generic::name, config_enum::options, config_enum_entry::val, and val.

Referenced by call_enum_check_hook(), estimate_variable_size(), GetConfigOption(), GetConfigOptionResetString(), GetConfigOptionValues(), serialize_variable(), and ShowGUCOption().

ConfigOptionIsVisible()

bool ConfigOptionIsVisible

(

struct config_generic *

conf

)

Definition at line 591 of file guc_funcs.c.

{
    if ((conf->flags & GUC_SUPERUSER_ONLY) &&
        !has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
        return false;
    else
        return true;
}

References config_generic::flags, GetUserId(), GUC_SUPERUSER_ONLY, and has_privs_of_role().

Referenced by get_explain_guc_options(), GetConfigOption(), GetConfigOptionByName(), GetConfigOptionResetString(), show_all_settings(), and ShowAllGUCConfig().

find_option()

struct config_generic* find_option	(	const char *	name,
		bool	create_placeholders,
		bool	skip_errors,
		int	elevel
	)

Definition at line 1162 of file guc.c.

{
    GUCHashEntry *hentry;
    int         i;
 
    Assert(name);
 
    /* Look it up using the hash table. */
    hentry = (GUCHashEntry *) hash_search(guc_hashtab,
                                          &name,
                                          HASH_FIND,
                                          NULL);
    if (hentry)
        return hentry->gucvar;
 
    /*
     * See if the name is an obsolete name for a variable.  We assume that the
     * set of supported old names is short enough that a brute-force search is
     * the best way.
     */
    for (i = 0; map_old_guc_names[i] != NULL; i += 2)
    {
        if (guc_name_compare(name, map_old_guc_names[i]) == 0)
            return find_option(map_old_guc_names[i + 1], false,
                               skip_errors, elevel);
    }
 
    if (create_placeholders)
    {
        /*
         * Check if the name is valid, and if so, add a placeholder.  If it
         * doesn't contain a separator, don't assume that it was meant to be a
         * placeholder.
         */
        const char *sep = strchr(name, GUC_QUALIFIER_SEPARATOR);
 
        if (sep != NULL)
        {
            size_t      classLen = sep - name;
            ListCell   *lc;
 
            /* The name must be syntactically acceptable ... */
            if (!valid_custom_variable_name(name))
            {
                if (!skip_errors)
                    ereport(elevel,
                            (errcode(ERRCODE_INVALID_NAME),
                             errmsg("invalid configuration parameter name \"%s\"",
                                    name),
                             errdetail("Custom parameter names must be two or more simple identifiers separated by dots.")));
                return NULL;
            }
            /* ... and it must not match any previously-reserved prefix */
            foreach(lc, reserved_class_prefix)
            {
                const char *rcprefix = lfirst(lc);
 
                if (strlen(rcprefix) == classLen &&
                    strncmp(name, rcprefix, classLen) == 0)
                {
                    if (!skip_errors)
                        ereport(elevel,
                                (errcode(ERRCODE_INVALID_NAME),
                                 errmsg("invalid configuration parameter name \"%s\"",
                                        name),
                                 errdetail("\"%s\" is a reserved prefix.",
                                           rcprefix)));
                    return NULL;
                }
            }
            /* OK, create it */
            return add_placeholder_variable(name, elevel);
        }
    }
 
    /* Unknown name */
    if (!skip_errors)
        ereport(elevel,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("unrecognized configuration parameter \"%s\"",
                        name)));
    return NULL;
}

References add_placeholder_variable(), Assert(), ereport, errcode(), errdetail(), errmsg(), guc_hashtab, guc_name_compare(), GUC_QUALIFIER_SEPARATOR, GUCHashEntry::gucvar, HASH_FIND, hash_search(), i, lfirst, map_old_guc_names, name, reserved_class_prefix, and valid_custom_variable_name().

Referenced by AlterSystemSetConfigFile(), check_GUC_name_for_parameter_acl(), ExtractSetVariableArgs(), flatten_set_variable_args(), GetConfigOption(), GetConfigOptionByName(), GetConfigOptionFlags(), GetConfigOptionResetString(), GUCArrayAdd(), GUCArrayDelete(), InitializeWalConsistencyChecking(), pg_settings_get_flags(), ProcessConfigFileInternal(), SelectConfigFiles(), set_config_option_ext(), set_config_sourcefile(), and validate_option_array_item().

get_explain_guc_options()

struct config_generic** get_explain_guc_options

(

int *

num

)

Definition at line 5154 of file guc.c.

{
    struct config_generic **result;
    dlist_iter  iter;
 
    *num = 0;
 
    /*
     * While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
     * it doesn't seem worth dynamically resizing this array.
     */
    result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
 
    /* We need only consider GUCs with source not PGC_S_DEFAULT */
    dlist_foreach(iter, &guc_nondef_list)
    {
        struct config_generic *conf = dlist_container(struct config_generic,
                                                      nondef_link, iter.cur);
        bool        modified;
 
        /* return only parameters marked for inclusion in explain */
        if (!(conf->flags & GUC_EXPLAIN))
            continue;
 
        /* return only options visible to the current user */
        if (!ConfigOptionIsVisible(conf))
            continue;
 
        /* return only options that are different from their boot values */
        modified = false;
 
        switch (conf->vartype)
        {
            case PGC_BOOL:
                {
                    struct config_bool *lconf = (struct config_bool *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            case PGC_INT:
                {
                    struct config_int *lconf = (struct config_int *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            case PGC_REAL:
                {
                    struct config_real *lconf = (struct config_real *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            case PGC_STRING:
                {
                    struct config_string *lconf = (struct config_string *) conf;
 
                    modified = (strcmp(lconf->boot_val, *(lconf->variable)) != 0);
                }
                break;
 
            case PGC_ENUM:
                {
                    struct config_enum *lconf = (struct config_enum *) conf;
 
                    modified = (lconf->boot_val != *(lconf->variable));
                }
                break;
 
            default:
                elog(ERROR, "unexpected GUC type: %d", conf->vartype);
        }
 
        if (!modified)
            continue;
 
        /* OK, report it */
        result[*num] = conf;
        *num = *num + 1;
    }
 
    return result;
}

References config_bool::boot_val, config_int::boot_val, config_real::boot_val, config_string::boot_val, config_enum::boot_val, ConfigOptionIsVisible(), dlist_iter::cur, dlist_container, dlist_foreach, elog(), ERROR, config_generic::flags, GUC_EXPLAIN, guc_hashtab, guc_nondef_list, hash_get_num_entries(), config_generic::nondef_link, palloc(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by ExplainPrintSettings().

get_guc_variables()

struct config_generic** get_guc_variables

(

int *

num_vars

)

Definition at line 864 of file guc.c.

{
    struct config_generic **result;
    HASH_SEQ_STATUS status;
    GUCHashEntry *hentry;
    int         i;
 
    *num_vars = hash_get_num_entries(guc_hashtab);
    result = palloc(sizeof(struct config_generic *) * *num_vars);
 
    /* Extract pointers from the hash table */
    i = 0;
    hash_seq_init(&status, guc_hashtab);
    while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
        result[i++] = hentry->gucvar;
    Assert(i == *num_vars);
 
    /* Sort by name */
    qsort(result, *num_vars,
          sizeof(struct config_generic *), guc_var_compare);
 
    return result;
}

References Assert(), guc_hashtab, guc_var_compare(), GUCHashEntry::gucvar, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), i, palloc(), qsort, and status().

Referenced by GucInfoMain(), show_all_settings(), and ShowAllGUCConfig().

ShowGUCOption()

char* ShowGUCOption	(	struct config_generic *	record,
		bool	use_units
	)

Definition at line 5280 of file guc.c.

{
    char        buffer[256];
    const char *val;
 
    switch (record->vartype)
    {
        case PGC_BOOL:
            {
                struct config_bool *conf = (struct config_bool *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                    val = *conf->variable ? "on" : "off";
            }
            break;
 
        case PGC_INT:
            {
                struct config_int *conf = (struct config_int *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                {
                    /*
                     * Use int64 arithmetic to avoid overflows in units
                     * conversion.
                     */
                    int64       result = *conf->variable;
                    const char *unit;
 
                    if (use_units && result > 0 && (record->flags & GUC_UNIT))
                        convert_int_from_base_unit(result,
                                                   record->flags & GUC_UNIT,
                                                   &result, &unit);
                    else
                        unit = "";
 
                    snprintf(buffer, sizeof(buffer), INT64_FORMAT "%s",
                             result, unit);
                    val = buffer;
                }
            }
            break;
 
        case PGC_REAL:
            {
                struct config_real *conf = (struct config_real *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                {
                    double      result = *conf->variable;
                    const char *unit;
 
                    if (use_units && result > 0 && (record->flags & GUC_UNIT))
                        convert_real_from_base_unit(result,
                                                    record->flags & GUC_UNIT,
                                                    &result, &unit);
                    else
                        unit = "";
 
                    snprintf(buffer, sizeof(buffer), "%g%s",
                             result, unit);
                    val = buffer;
                }
            }
            break;
 
        case PGC_STRING:
            {
                struct config_string *conf = (struct config_string *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else if (*conf->variable && **conf->variable)
                    val = *conf->variable;
                else
                    val = "";
            }
            break;
 
        case PGC_ENUM:
            {
                struct config_enum *conf = (struct config_enum *) record;
 
                if (conf->show_hook)
                    val = conf->show_hook();
                else
                    val = config_enum_lookup_by_value(conf, *conf->variable);
            }
            break;
 
        default:
            /* just to keep compiler quiet */
            val = "???";
            break;
    }
 
    return pstrdup(val);
}

References config_enum_lookup_by_value(), convert_int_from_base_unit(), convert_real_from_base_unit(), config_generic::flags, GUC_UNIT, INT64_FORMAT, PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_STRING, pstrdup(), config_bool::show_hook, config_int::show_hook, config_real::show_hook, config_string::show_hook, config_enum::show_hook, snprintf, val, config_bool::variable, config_int::variable, config_real::variable, config_string::variable, config_enum::variable, and config_generic::vartype.

Referenced by GetConfigOptionByName(), GetConfigOptionValues(), ReportGUCOption(), and ShowAllGUCConfig().

Variable Documentation

config_group_names

PGDLLIMPORT const char* const config_group_names[]

extern

Definition at line 644 of file guc_tables.c.

Referenced by GetConfigOptionValues().

config_type_names

PGDLLIMPORT const char* const config_type_names[]

extern

Definition at line 746 of file guc_tables.c.

Referenced by GetConfigOptionValues().

ConfigureNamesBool

PGDLLIMPORT struct config_bool ConfigureNamesBool[]

extern

Definition at line 755 of file guc_tables.c.

Referenced by build_guc_variables().

ConfigureNamesEnum

PGDLLIMPORT struct config_enum ConfigureNamesEnum[]

extern

Definition at line 755 of file guc_tables.c.

Referenced by build_guc_variables().

ConfigureNamesInt

PGDLLIMPORT struct config_int ConfigureNamesInt[]

extern

Definition at line 755 of file guc_tables.c.

Referenced by build_guc_variables().

ConfigureNamesReal

PGDLLIMPORT struct config_real ConfigureNamesReal[]

extern

Definition at line 755 of file guc_tables.c.

Referenced by build_guc_variables().

ConfigureNamesString

PGDLLIMPORT struct config_string ConfigureNamesString[]

extern

Definition at line 755 of file guc_tables.c.

Referenced by build_guc_variables().

GucContext_Names

PGDLLIMPORT const char* const GucContext_Names[]

extern

Definition at line 601 of file guc_tables.c.

Referenced by GetConfigOptionValues().

GucSource_Names

PGDLLIMPORT const char* const GucSource_Names[]

extern

Definition at line 620 of file guc_tables.c.

Referenced by GetConfigOptionValues().