guc_funcs.c File Reference

#include "postgres.h"
#include <sys/stat.h>
#include <unistd.h>
#include "access/xact.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_parameter_acl.h"
#include "catalog/pg_type_d.h"
#include "funcapi.h"
#include "guc_internal.h"
#include "miscadmin.h"
#include "parser/parse_type.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/guc_tables.h"
#include "utils/snapmgr.h"
#include "utils/tuplestore.h"

Include dependency graph for guc_funcs.c:

Go to the source code of this file.

Macros
#define	MAX_GUC_FLAGS   6
#define	NUM_PG_SETTINGS_ATTS   17
#define	NUM_PG_FILE_SETTINGS_ATTS   7

Functions
static char *	flatten_set_variable_args (const char *name, List *args)
static void	ShowGUCConfigOption (const char *name, DestReceiver *dest)
static void	ShowAllGUCConfig (DestReceiver *dest)
void	ExecSetVariableStmt (VariableSetStmt *stmt, bool isTopLevel)
char *	ExtractSetVariableArgs (VariableSetStmt *stmt)
void	SetPGVariable (const char *name, List *args, bool is_local)
Datum	set_config_by_name (PG_FUNCTION_ARGS)
void	GetPGVariable (const char *name, DestReceiver *dest)
TupleDesc	GetPGVariableResultDesc (const char *name)
Datum	pg_settings_get_flags (PG_FUNCTION_ARGS)
bool	ConfigOptionIsVisible (const struct config_generic *conf)
static void	GetConfigOptionValues (const struct config_generic *conf, const char **values)
Datum	show_config_by_name (PG_FUNCTION_ARGS)
Datum	show_config_by_name_missing_ok (PG_FUNCTION_ARGS)
Datum	show_all_settings (PG_FUNCTION_ARGS)
Datum	show_all_file_settings (PG_FUNCTION_ARGS)

Macro Definition Documentation

MAX_GUC_FLAGS

#define MAX_GUC_FLAGS   6

NUM_PG_FILE_SETTINGS_ATTS

#define NUM_PG_FILE_SETTINGS_ATTS   7

NUM_PG_SETTINGS_ATTS

#define NUM_PG_SETTINGS_ATTS   17

Definition at line 877 of file guc_funcs.c.

Function Documentation

ConfigOptionIsVisible()

bool ConfigOptionIsVisible

(

const struct config_generic *

conf

)

Definition at line 612 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 fb(), GetUserId(), GUC_SUPERUSER_ONLY, and has_privs_of_role().

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

ExecSetVariableStmt()

void ExecSetVariableStmt	(	VariableSetStmt *	stmt,
		bool	isTopLevel
	)

Definition at line 45 of file guc_funcs.c.

{
    GucAction   action = stmt->is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET;
 
    /*
     * Workers synchronize these parameters at the start of the parallel
     * operation; then, we block SET during the operation.
     */
    if (IsInParallelMode())
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TRANSACTION_STATE),
                 errmsg("cannot set parameters during a parallel operation")));
 
    switch (stmt->kind)
    {
        case VAR_SET_VALUE:
        case VAR_SET_CURRENT:
            if (stmt->is_local)
                WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
            (void) set_config_option(stmt->name,
                                     ExtractSetVariableArgs(stmt),
                                     (superuser() ? PGC_SUSET : PGC_USERSET),
                                     PGC_S_SESSION,
                                     action, true, 0, false);
            break;
        case VAR_SET_MULTI:
 
            /*
             * Special-case SQL syntaxes.  The TRANSACTION and SESSION
             * CHARACTERISTICS cases effectively set more than one variable
             * per statement.  TRANSACTION SNAPSHOT only takes one argument,
             * but we put it here anyway since it's a special case and not
             * related to any GUC variable.
             */
            if (strcmp(stmt->name, "TRANSACTION") == 0)
            {
                ListCell   *head;
 
                WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
 
                foreach(head, stmt->args)
                {
                    DefElem    *item = (DefElem *) lfirst(head);
 
                    if (strcmp(item->defname, "transaction_isolation") == 0)
                        SetPGVariable("transaction_isolation",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_read_only") == 0)
                        SetPGVariable("transaction_read_only",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_deferrable") == 0)
                        SetPGVariable("transaction_deferrable",
                                      list_make1(item->arg), stmt->is_local);
                    else
                        elog(ERROR, "unexpected SET TRANSACTION element: %s",
                             item->defname);
                }
            }
            else if (strcmp(stmt->name, "SESSION CHARACTERISTICS") == 0)
            {
                ListCell   *head;
 
                foreach(head, stmt->args)
                {
                    DefElem    *item = (DefElem *) lfirst(head);
 
                    if (strcmp(item->defname, "transaction_isolation") == 0)
                        SetPGVariable("default_transaction_isolation",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_read_only") == 0)
                        SetPGVariable("default_transaction_read_only",
                                      list_make1(item->arg), stmt->is_local);
                    else if (strcmp(item->defname, "transaction_deferrable") == 0)
                        SetPGVariable("default_transaction_deferrable",
                                      list_make1(item->arg), stmt->is_local);
                    else
                        elog(ERROR, "unexpected SET SESSION element: %s",
                             item->defname);
                }
            }
            else if (strcmp(stmt->name, "TRANSACTION SNAPSHOT") == 0)
            {
                A_Const    *con = linitial_node(A_Const, stmt->args);
 
                if (stmt->is_local)
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("SET LOCAL TRANSACTION SNAPSHOT is not implemented")));
 
                WarnNoTransactionBlock(isTopLevel, "SET TRANSACTION");
                ImportSnapshot(strVal(&con->val));
            }
            else
                elog(ERROR, "unexpected SET MULTI element: %s",
                     stmt->name);
            break;
        case VAR_SET_DEFAULT:
            if (stmt->is_local)
                WarnNoTransactionBlock(isTopLevel, "SET LOCAL");
            pg_fallthrough;
        case VAR_RESET:
            (void) set_config_option(stmt->name,
                                     NULL,
                                     (superuser() ? PGC_SUSET : PGC_USERSET),
                                     PGC_S_SESSION,
                                     action, true, 0, false);
            break;
        case VAR_RESET_ALL:
            ResetAllOptions();
            break;
    }
 
    /* Invoke the post-alter hook for setting this GUC variable, by name. */
    InvokeObjectPostAlterHookArgStr(ParameterAclRelationId, stmt->name,
                                    ACL_SET, stmt->kind, false);
}

References ACL_SET, DefElem::arg, DefElem::defname, elog, ereport, errcode(), errmsg, ERROR, ExtractSetVariableArgs(), fb(), GUC_ACTION_LOCAL, GUC_ACTION_SET, ImportSnapshot(), InvokeObjectPostAlterHookArgStr, IsInParallelMode(), lfirst, linitial_node, list_make1, pg_fallthrough, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, ResetAllOptions(), set_config_option(), SetPGVariable(), stmt, strVal, superuser(), A_Const::val, VAR_RESET, VAR_RESET_ALL, VAR_SET_CURRENT, VAR_SET_DEFAULT, VAR_SET_MULTI, VAR_SET_VALUE, and WarnNoTransactionBlock().

Referenced by standard_ProcessUtility().

ExtractSetVariableArgs()

char * ExtractSetVariableArgs

(

VariableSetStmt *

stmt

)

Definition at line 169 of file guc_funcs.c.

{
    switch (stmt->kind)
    {
        case VAR_SET_VALUE:
            return flatten_set_variable_args(stmt->name, stmt->args);
        case VAR_SET_CURRENT:
            return GetConfigOptionByName(stmt->name, NULL, false);
        default:
            return NULL;
    }
}

References fb(), flatten_set_variable_args(), GetConfigOptionByName(), stmt, VAR_SET_CURRENT, and VAR_SET_VALUE.

Referenced by AlterSetting(), AlterSystemSetConfigFile(), ExecSetVariableStmt(), and update_proconfig_value().

flatten_set_variable_args()

static char * flatten_set_variable_args ( const char *  name, List *  args  )

static

Definition at line 194 of file guc_funcs.c.

{
    struct config_generic *record;
    int         flags;
    StringInfoData buf;
    ListCell   *l;
 
    /* Fast path if just DEFAULT */
    if (args == NIL)
        return NULL;
 
    /*
     * Get flags for the variable; if it's not known, use default flags.
     * (Caller might throw error later, but not our business to do so here.)
     */
    record = find_option(name, false, true, WARNING);
    if (record)
        flags = record->flags;
    else
        flags = 0;
 
    /*
     * Handle special cases for list input.
     */
    if (flags & GUC_LIST_INPUT)
    {
        /* NULL represents an empty list. */
        if (list_length(args) == 1)
        {
            Node       *arg = (Node *) linitial(args);
 
            if (IsA(arg, A_Const) &&
                ((A_Const *) arg)->isnull)
                return pstrdup("");
        }
    }
    else
    {
        /* Complain if list input and non-list variable. */
        if (list_length(args) != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("SET %s takes only one argument", name)));
    }
 
    initStringInfo(&buf);
 
    /*
     * Each list member may be a plain A_Const node, or an A_Const within a
     * TypeCast; the latter case is supported only for ConstInterval arguments
     * (for SET TIME ZONE).
     */
    foreach(l, args)
    {
        Node       *arg = (Node *) lfirst(l);
        char       *val;
        TypeName   *typeName = NULL;
        A_Const    *con;
 
        if (l != list_head(args))
            appendStringInfoString(&buf, ", ");
 
        if (IsA(arg, TypeCast))
        {
            TypeCast   *tc = (TypeCast *) arg;
 
            arg = tc->arg;
            typeName = tc->typeName;
        }
 
        if (!IsA(arg, A_Const))
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(arg));
        con = (A_Const *) arg;
 
        /* Complain if NULL is used with a non-list variable. */
        if (con->isnull)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("NULL is an invalid value for %s", name)));
 
        switch (nodeTag(&con->val))
        {
            case T_Integer:
                appendStringInfo(&buf, "%d", intVal(&con->val));
                break;
            case T_Float:
                /* represented as a string, so just copy it */
                appendStringInfoString(&buf, castNode(Float, &con->val)->fval);
                break;
            case T_String:
                val = strVal(&con->val);
                if (typeName != NULL)
                {
                    /*
                     * Must be a ConstInterval argument for TIME ZONE. Coerce
                     * to interval and back to normalize the value and account
                     * for any typmod.
                     */
                    Oid         typoid;
                    int32       typmod;
                    Datum       interval;
                    char       *intervalout;
 
                    /* gram.y ensures this is only reachable for TIME ZONE */
                    Assert(!(flags & GUC_LIST_QUOTE));
 
                    typenameTypeIdAndMod(NULL, typeName, &typoid, &typmod);
                    Assert(typoid == INTERVALOID);
 
                    interval =
                        DirectFunctionCall3(interval_in,
                                            CStringGetDatum(val),
                                            ObjectIdGetDatum(InvalidOid),
                                            Int32GetDatum(typmod));
 
                    intervalout =
                        DatumGetCString(DirectFunctionCall1(interval_out,
                                                            interval));
                    appendStringInfo(&buf, "INTERVAL '%s'", intervalout);
                }
                else
                {
                    /*
                     * Plain string literal or identifier.  For quote mode,
                     * quote it if it's not a vanilla identifier.
                     */
                    if (flags & GUC_LIST_QUOTE)
                        appendStringInfoString(&buf, quote_identifier(val));
                    else
                        appendStringInfoString(&buf, val);
                }
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(&con->val));
                break;
        }
    }
 
    return buf.data;
}

References appendStringInfo(), appendStringInfoString(), arg, TypeCast::arg, Assert, buf, castNode, CStringGetDatum(), DatumGetCString(), DirectFunctionCall1, DirectFunctionCall3, elog, ereport, errcode(), errmsg, ERROR, fb(), find_option(), config_generic::flags, GUC_LIST_INPUT, GUC_LIST_QUOTE, initStringInfo(), Int32GetDatum(), interval_in(), interval_out(), intVal, InvalidOid, IsA, A_Const::isnull, lfirst, linitial, list_head(), list_length(), name, NIL, nodeTag, ObjectIdGetDatum(), pstrdup(), quote_identifier(), strVal, typenameTypeIdAndMod(), A_Const::val, val, and WARNING.

Referenced by ExtractSetVariableArgs(), and SetPGVariable().

GetConfigOptionValues()

static void GetConfigOptionValues ( const struct config_generic *  conf, const char **  values  )

static

Definition at line 625 of file guc_funcs.c.

{
    char        buffer[256];
 
    /* first get the generic attributes */
 
    /* name */
    values[0] = conf->name;
 
    /* setting: use ShowGUCOption in order to avoid duplicating the logic */
    values[1] = ShowGUCOption(conf, false);
 
    /* unit, if any (NULL is fine) */
    values[2] = get_config_unit_name(conf->flags);
 
    /* group */
    values[3] = _(config_group_names[conf->group]);
 
    /* short_desc */
    values[4] = conf->short_desc != NULL ? _(conf->short_desc) : NULL;
 
    /* extra_desc */
    values[5] = conf->long_desc != NULL ? _(conf->long_desc) : NULL;
 
    /* context */
    values[6] = GucContext_Names[conf->context];
 
    /* vartype */
    values[7] = config_type_names[conf->vartype];
 
    /* source */
    values[8] = GucSource_Names[conf->source];
 
    /* now get the type specific attributes */
    switch (conf->vartype)
    {
        case PGC_BOOL:
            {
                const struct config_bool *lconf = &conf->_bool;
 
                /* min_val */
                values[9] = NULL;
 
                /* max_val */
                values[10] = NULL;
 
                /* enumvals */
                values[11] = NULL;
 
                /* boot_val */
                values[12] = pstrdup(lconf->boot_val ? "on" : "off");
 
                /* reset_val */
                values[13] = pstrdup(lconf->reset_val ? "on" : "off");
            }
            break;
 
        case PGC_INT:
            {
                const struct config_int *lconf = &conf->_int;
 
                /* min_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->min);
                values[9] = pstrdup(buffer);
 
                /* max_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->max);
                values[10] = pstrdup(buffer);
 
                /* enumvals */
                values[11] = NULL;
 
                /* boot_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->boot_val);
                values[12] = pstrdup(buffer);
 
                /* reset_val */
                snprintf(buffer, sizeof(buffer), "%d", lconf->reset_val);
                values[13] = pstrdup(buffer);
            }
            break;
 
        case PGC_REAL:
            {
                const struct config_real *lconf = &conf->_real;
 
                /* min_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->min);
                values[9] = pstrdup(buffer);
 
                /* max_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->max);
                values[10] = pstrdup(buffer);
 
                /* enumvals */
                values[11] = NULL;
 
                /* boot_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->boot_val);
                values[12] = pstrdup(buffer);
 
                /* reset_val */
                snprintf(buffer, sizeof(buffer), "%g", lconf->reset_val);
                values[13] = pstrdup(buffer);
            }
            break;
 
        case PGC_STRING:
            {
                const struct config_string *lconf = &conf->_string;
 
                /* min_val */
                values[9] = NULL;
 
                /* max_val */
                values[10] = NULL;
 
                /* enumvals */
                values[11] = NULL;
 
                /* boot_val */
                if (lconf->boot_val == NULL)
                    values[12] = NULL;
                else
                    values[12] = pstrdup(lconf->boot_val);
 
                /* reset_val */
                if (lconf->reset_val == NULL)
                    values[13] = NULL;
                else
                    values[13] = pstrdup(lconf->reset_val);
            }
            break;
 
        case PGC_ENUM:
            {
                const struct config_enum *lconf = &conf->_enum;
 
                /* min_val */
                values[9] = NULL;
 
                /* max_val */
                values[10] = NULL;
 
                /* enumvals */
 
                /*
                 * NOTE! enumvals with double quotes in them are not
                 * supported!
                 */
                values[11] = config_enum_get_options(lconf,
                                                     "{\"", "\"}", "\",\"");
 
                /* boot_val */
                values[12] = pstrdup(config_enum_lookup_by_value(conf,
                                                                 lconf->boot_val));
 
                /* reset_val */
                values[13] = pstrdup(config_enum_lookup_by_value(conf,
                                                                 lconf->reset_val));
            }
            break;
 
        default:
            {
                /*
                 * should never get here, but in case we do, set 'em to NULL
                 */
 
                /* min_val */
                values[9] = NULL;
 
                /* max_val */
                values[10] = NULL;
 
                /* enumvals */
                values[11] = NULL;
 
                /* boot_val */
                values[12] = NULL;
 
                /* reset_val */
                values[13] = NULL;
            }
            break;
    }
 
    /*
     * If the setting came from a config file, set the source location. For
     * security reasons, we don't show source file/line number for
     * insufficiently-privileged users.
     */
    if (conf->source == PGC_S_FILE &&
        has_privs_of_role(GetUserId(), ROLE_PG_READ_ALL_SETTINGS))
    {
        values[14] = conf->sourcefile;
        snprintf(buffer, sizeof(buffer), "%d", conf->sourceline);
        values[15] = pstrdup(buffer);
    }
    else
    {
        values[14] = NULL;
        values[15] = NULL;
    }
 
    values[16] = (conf->status & GUC_PENDING_RESTART) ? "t" : "f";
}

References _, config_enum_get_options(), config_enum_lookup_by_value(), config_group_names, config_type_names, fb(), get_config_unit_name(), GetUserId(), GUC_PENDING_RESTART, GucContext_Names, GucSource_Names, has_privs_of_role(), PGC_BOOL, PGC_ENUM, PGC_INT, PGC_REAL, PGC_S_FILE, PGC_STRING, pstrdup(), ShowGUCOption(), snprintf, and values.

Referenced by show_all_settings().

GetPGVariable()

void GetPGVariable	(	const char *	name,
		DestReceiver *	dest
	)

Definition at line 410 of file guc_funcs.c.

{
    if (guc_name_compare(name, "all") == 0)
        ShowAllGUCConfig(dest);
    else
        ShowGUCConfigOption(name, dest);
}

References guc_name_compare(), name, ShowAllGUCConfig(), and ShowGUCConfigOption().

Referenced by exec_replication_command(), and standard_ProcessUtility().

GetPGVariableResultDesc()

TupleDesc GetPGVariableResultDesc

(

const char *

name

)

Definition at line 422 of file guc_funcs.c.

{
    TupleDesc   tupdesc;
 
    if (guc_name_compare(name, "all") == 0)
    {
        /* need a tuple descriptor representing three TEXT columns */
        tupdesc = CreateTemplateTupleDesc(3);
        TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 2, "setting",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 3, "description",
                           TEXTOID, -1, 0);
    }
    else
    {
        const char *varname;
 
        /* Get the canonical spelling of name */
        (void) GetConfigOptionByName(name, &varname, false);
 
        /* need a tuple descriptor representing a single TEXT column */
        tupdesc = CreateTemplateTupleDesc(1);
        TupleDescInitEntry(tupdesc, (AttrNumber) 1, varname,
                           TEXTOID, -1, 0);
    }
    TupleDescFinalize(tupdesc);
    return tupdesc;
}

References CreateTemplateTupleDesc(), fb(), GetConfigOptionByName(), guc_name_compare(), name, TupleDescFinalize(), and TupleDescInitEntry().

Referenced by UtilityTupleDescriptor().

pg_settings_get_flags()

Datum pg_settings_get_flags

(

PG_FUNCTION_ARGS

)

Definition at line 573 of file guc_funcs.c.

{
#define MAX_GUC_FLAGS   6
    char       *varname = TextDatumGetCString(PG_GETARG_DATUM(0));
    struct config_generic *record;
    int         cnt = 0;
    Datum       flags[MAX_GUC_FLAGS];
    ArrayType  *a;
 
    record = find_option(varname, false, true, ERROR);
 
    /* return NULL if no such variable */
    if (record == NULL)
        PG_RETURN_NULL();
 
    if (record->flags & GUC_EXPLAIN)
        flags[cnt++] = CStringGetTextDatum("EXPLAIN");
    if (record->flags & GUC_NO_RESET)
        flags[cnt++] = CStringGetTextDatum("NO_RESET");
    if (record->flags & GUC_NO_RESET_ALL)
        flags[cnt++] = CStringGetTextDatum("NO_RESET_ALL");
    if (record->flags & GUC_NO_SHOW_ALL)
        flags[cnt++] = CStringGetTextDatum("NO_SHOW_ALL");
    if (record->flags & GUC_NOT_IN_SAMPLE)
        flags[cnt++] = CStringGetTextDatum("NOT_IN_SAMPLE");
    if (record->flags & GUC_RUNTIME_COMPUTED)
        flags[cnt++] = CStringGetTextDatum("RUNTIME_COMPUTED");
 
    Assert(cnt <= MAX_GUC_FLAGS);
 
    /* Returns the record as Datum */
    a = construct_array_builtin(flags, cnt, TEXTOID);
    PG_RETURN_ARRAYTYPE_P(a);
}

References a, Assert, construct_array_builtin(), CStringGetTextDatum, ERROR, fb(), find_option(), config_generic::flags, GUC_EXPLAIN, GUC_NO_RESET, GUC_NO_RESET_ALL, GUC_NO_SHOW_ALL, GUC_NOT_IN_SAMPLE, GUC_RUNTIME_COMPUTED, MAX_GUC_FLAGS, PG_GETARG_DATUM, PG_RETURN_ARRAYTYPE_P, PG_RETURN_NULL, and TextDatumGetCString.

set_config_by_name()

Datum set_config_by_name

(

PG_FUNCTION_ARGS

)

Definition at line 360 of file guc_funcs.c.

{
    char       *name;
    char       *value;
    char       *new_value;
    bool        is_local;
 
    if (PG_ARGISNULL(0))
        ereport(ERROR,
                (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                 errmsg("SET requires parameter name")));
 
    /* Get the GUC variable name */
    name = TextDatumGetCString(PG_GETARG_DATUM(0));
 
    /* Get the desired value or set to NULL for a reset request */
    if (PG_ARGISNULL(1))
        value = NULL;
    else
        value = TextDatumGetCString(PG_GETARG_DATUM(1));
 
    /*
     * Get the desired state of is_local. Default to false if provided value
     * is NULL
     */
    if (PG_ARGISNULL(2))
        is_local = false;
    else
        is_local = PG_GETARG_BOOL(2);
 
    /* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
    (void) set_config_option(name,
                             value,
                             (superuser() ? PGC_SUSET : PGC_USERSET),
                             PGC_S_SESSION,
                             is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
                             true, 0, false);
 
    /* get the new current value */
    new_value = GetConfigOptionByName(name, NULL, false);
 
    /* Convert return string to text */
    PG_RETURN_TEXT_P(cstring_to_text(new_value));
}

References cstring_to_text(), ereport, errcode(), errmsg, ERROR, fb(), GetConfigOptionByName(), GUC_ACTION_LOCAL, GUC_ACTION_SET, name, PG_ARGISNULL, PG_GETARG_BOOL, PG_GETARG_DATUM, PG_RETURN_TEXT_P, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, set_config_option(), superuser(), TextDatumGetCString, and value.

SetPGVariable()

void SetPGVariable	(	const char *	name,
		List *	args,
		bool	is_local
	)

Definition at line 343 of file guc_funcs.c.

{
    char       *argstring = flatten_set_variable_args(name, args);
 
    /* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
    (void) set_config_option(name,
                             argstring,
                             (superuser() ? PGC_SUSET : PGC_USERSET),
                             PGC_S_SESSION,
                             is_local ? GUC_ACTION_LOCAL : GUC_ACTION_SET,
                             true, 0, false);
}

References fb(), flatten_set_variable_args(), GUC_ACTION_LOCAL, GUC_ACTION_SET, name, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, set_config_option(), and superuser().

Referenced by DiscardAll(), ExecSetVariableStmt(), and standard_ProcessUtility().

show_all_file_settings()

Datum show_all_file_settings

(

PG_FUNCTION_ARGS

)

Definition at line 1017 of file guc_funcs.c.

{
#define NUM_PG_FILE_SETTINGS_ATTS 7
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    ConfigVariable *conf;
 
    /* Scan the config files using current context as workspace */
    conf = ProcessConfigFileInternal(PGC_SIGHUP, false, DEBUG3);
 
    /* Build a tuplestore to return our results in */
    InitMaterializedSRF(fcinfo, 0);
 
    /* Process the results and create a tuplestore */
    for (int seqno = 1; conf != NULL; conf = conf->next, seqno++)
    {
        Datum       values[NUM_PG_FILE_SETTINGS_ATTS];
        bool        nulls[NUM_PG_FILE_SETTINGS_ATTS];
 
        memset(values, 0, sizeof(values));
        memset(nulls, 0, sizeof(nulls));
 
        /* sourcefile */
        if (conf->filename)
            values[0] = PointerGetDatum(cstring_to_text(conf->filename));
        else
            nulls[0] = true;
 
        /* sourceline (not meaningful if no sourcefile) */
        if (conf->filename)
            values[1] = Int32GetDatum(conf->sourceline);
        else
            nulls[1] = true;
 
        /* seqno */
        values[2] = Int32GetDatum(seqno);
 
        /* name */
        if (conf->name)
            values[3] = PointerGetDatum(cstring_to_text(conf->name));
        else
            nulls[3] = true;
 
        /* setting */
        if (conf->value)
            values[4] = PointerGetDatum(cstring_to_text(conf->value));
        else
            nulls[4] = true;
 
        /* applied */
        values[5] = BoolGetDatum(conf->applied);
 
        /* error */
        if (conf->errmsg)
            values[6] = PointerGetDatum(cstring_to_text(conf->errmsg));
        else
            nulls[6] = true;
 
        /* shove row into tuplestore */
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
    }
 
    return (Datum) 0;
}

References BoolGetDatum(), cstring_to_text(), DEBUG3, fb(), InitMaterializedSRF(), Int32GetDatum(), NUM_PG_FILE_SETTINGS_ATTS, PGC_SIGHUP, PointerGetDatum(), ProcessConfigFileInternal(), tuplestore_putvalues(), and values.

show_all_settings()

Datum show_all_settings

(

PG_FUNCTION_ARGS

)

Definition at line 880 of file guc_funcs.c.

{
    FuncCallContext *funcctx;
    struct config_generic **guc_vars;
    int         num_vars;
    TupleDesc   tupdesc;
    int         call_cntr;
    int         max_calls;
    AttInMetadata *attinmeta;
    MemoryContext oldcontext;
 
    /* stuff done only on the first call of the function */
    if (SRF_IS_FIRSTCALL())
    {
        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();
 
        /*
         * switch to memory context appropriate for multiple function calls
         */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /*
         * need a tuple descriptor representing NUM_PG_SETTINGS_ATTS columns
         * of the appropriate types
         */
        tupdesc = CreateTemplateTupleDesc(NUM_PG_SETTINGS_ATTS);
        TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 2, "setting",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 3, "unit",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 4, "category",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 5, "short_desc",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 6, "extra_desc",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 7, "context",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 8, "vartype",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 9, "source",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 10, "min_val",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 11, "max_val",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 12, "enumvals",
                           TEXTARRAYOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 13, "boot_val",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 14, "reset_val",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 15, "sourcefile",
                           TEXTOID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 16, "sourceline",
                           INT4OID, -1, 0);
        TupleDescInitEntry(tupdesc, (AttrNumber) 17, "pending_restart",
                           BOOLOID, -1, 0);
 
        TupleDescFinalize(tupdesc);
 
        /*
         * Generate attribute metadata needed later to produce tuples from raw
         * C strings
         */
        attinmeta = TupleDescGetAttInMetadata(tupdesc);
        funcctx->attinmeta = attinmeta;
 
        /* collect the variables, in sorted order */
        guc_vars = get_guc_variables(&num_vars);
 
        /* use user_fctx to remember the array location */
        funcctx->user_fctx = guc_vars;
 
        /* total number of tuples to be returned */
        funcctx->max_calls = num_vars;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();
 
    guc_vars = (struct config_generic **) funcctx->user_fctx;
    call_cntr = funcctx->call_cntr;
    max_calls = funcctx->max_calls;
    attinmeta = funcctx->attinmeta;
 
    while (call_cntr < max_calls)   /* do when there is more left to send */
    {
        struct config_generic *conf = guc_vars[call_cntr];
        char       *values[NUM_PG_SETTINGS_ATTS];
        HeapTuple   tuple;
        Datum       result;
 
        /* skip if marked NO_SHOW_ALL or if not visible to current user */
        if ((conf->flags & GUC_NO_SHOW_ALL) ||
            !ConfigOptionIsVisible(conf))
        {
            call_cntr = ++funcctx->call_cntr;
            continue;
        }
 
        /* extract values for the current variable */
        GetConfigOptionValues(conf, (const char **) values);
 
        /* build a tuple */
        tuple = BuildTupleFromCStrings(attinmeta, values);
 
        /* make the tuple into a datum */
        result = HeapTupleGetDatum(tuple);
 
        SRF_RETURN_NEXT(funcctx, result);
    }
 
    /* do when there is no more left */
    SRF_RETURN_DONE(funcctx);
}

References BuildTupleFromCStrings(), ConfigOptionIsVisible(), CreateTemplateTupleDesc(), fb(), get_guc_variables(), GetConfigOptionValues(), GUC_NO_SHOW_ALL, HeapTupleGetDatum(), MemoryContextSwitchTo(), NUM_PG_SETTINGS_ATTS, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, TupleDescFinalize(), TupleDescGetAttInMetadata(), TupleDescInitEntry(), and values.

show_config_by_name()

Datum show_config_by_name

(

PG_FUNCTION_ARGS

)

Definition at line 838 of file guc_funcs.c.

{
    char       *varname = TextDatumGetCString(PG_GETARG_DATUM(0));
    char       *varval;
 
    /* Get the value */
    varval = GetConfigOptionByName(varname, NULL, false);
 
    /* Convert to text */
    PG_RETURN_TEXT_P(cstring_to_text(varval));
}

References cstring_to_text(), fb(), GetConfigOptionByName(), PG_GETARG_DATUM, PG_RETURN_TEXT_P, and TextDatumGetCString.

show_config_by_name_missing_ok()

Datum show_config_by_name_missing_ok

(

PG_FUNCTION_ARGS

)

Definition at line 856 of file guc_funcs.c.

{
    char       *varname = TextDatumGetCString(PG_GETARG_DATUM(0));
    bool        missing_ok = PG_GETARG_BOOL(1);
    char       *varval;
 
    /* Get the value */
    varval = GetConfigOptionByName(varname, NULL, missing_ok);
 
    /* return NULL if no such variable */
    if (varval == NULL)
        PG_RETURN_NULL();
 
    /* Convert to text */
    PG_RETURN_TEXT_P(cstring_to_text(varval));
}

References cstring_to_text(), fb(), GetConfigOptionByName(), PG_GETARG_BOOL, PG_GETARG_DATUM, PG_RETURN_NULL, PG_RETURN_TEXT_P, and TextDatumGetCString.

ShowAllGUCConfig()

static void ShowAllGUCConfig ( DestReceiver *  dest )

static

Definition at line 486 of file guc_funcs.c.

{
    struct config_generic **guc_vars;
    int         num_vars;
    TupOutputState *tstate;
    TupleDesc   tupdesc;
    Datum       values[3];
    bool        isnull[3] = {false, false, false};
 
    /* collect the variables, in sorted order */
    guc_vars = get_guc_variables(&num_vars);
 
    /* need a tuple descriptor representing three TEXT columns */
    tupdesc = CreateTemplateTupleDesc(3);
    TupleDescInitBuiltinEntry(tupdesc, (AttrNumber) 1, "name",
                              TEXTOID, -1, 0);
    TupleDescInitBuiltinEntry(tupdesc, (AttrNumber) 2, "setting",
                              TEXTOID, -1, 0);
    TupleDescInitBuiltinEntry(tupdesc, (AttrNumber) 3, "description",
                              TEXTOID, -1, 0);
    TupleDescFinalize(tupdesc);
 
    /* prepare for projection of tuples */
    tstate = begin_tup_output_tupdesc(dest, tupdesc, &TTSOpsVirtual);
 
    for (int i = 0; i < num_vars; i++)
    {
        struct config_generic *conf = guc_vars[i];
        char       *setting;
 
        /* skip if marked NO_SHOW_ALL */
        if (conf->flags & GUC_NO_SHOW_ALL)
            continue;
 
        /* return only options visible to the current user */
        if (!ConfigOptionIsVisible(conf))
            continue;
 
        /* assign to the values array */
        values[0] = PointerGetDatum(cstring_to_text(conf->name));
 
        setting = ShowGUCOption(conf, true);
        if (setting)
        {
            values[1] = PointerGetDatum(cstring_to_text(setting));
            isnull[1] = false;
        }
        else
        {
            values[1] = PointerGetDatum(NULL);
            isnull[1] = true;
        }
 
        if (conf->short_desc)
        {
            values[2] = PointerGetDatum(cstring_to_text(conf->short_desc));
            isnull[2] = false;
        }
        else
        {
            values[2] = PointerGetDatum(NULL);
            isnull[2] = true;
        }
 
        /* send it to dest */
        do_tup_output(tstate, values, isnull);
 
        /* clean up */
        pfree(DatumGetPointer(values[0]));
        if (setting)
        {
            pfree(setting);
            pfree(DatumGetPointer(values[1]));
        }
        if (conf->short_desc)
            pfree(DatumGetPointer(values[2]));
    }
 
    end_tup_output(tstate);
}

References begin_tup_output_tupdesc(), ConfigOptionIsVisible(), CreateTemplateTupleDesc(), cstring_to_text(), DatumGetPointer(), do_tup_output(), end_tup_output(), fb(), get_guc_variables(), GUC_NO_SHOW_ALL, i, pfree(), PointerGetDatum(), ShowGUCOption(), TTSOpsVirtual, TupleDescFinalize(), TupleDescInitBuiltinEntry(), and values.

Referenced by GetPGVariable().

ShowGUCConfigOption()

static void ShowGUCConfigOption ( const char *  name, DestReceiver *  dest  )

static

Definition at line 457 of file guc_funcs.c.

{
    TupOutputState *tstate;
    TupleDesc   tupdesc;
    const char *varname;
    char       *value;
 
    /* Get the value and canonical spelling of name */
    value = GetConfigOptionByName(name, &varname, false);
 
    /* need a tuple descriptor representing a single TEXT column */
    tupdesc = CreateTemplateTupleDesc(1);
    TupleDescInitBuiltinEntry(tupdesc, (AttrNumber) 1, varname,
                              TEXTOID, -1, 0);
    TupleDescFinalize(tupdesc);
 
    /* prepare for projection of tuples */
    tstate = begin_tup_output_tupdesc(dest, tupdesc, &TTSOpsVirtual);
 
    /* Send it */
    do_text_output_oneline(tstate, value);
 
    end_tup_output(tstate);
}

References begin_tup_output_tupdesc(), CreateTemplateTupleDesc(), do_text_output_oneline, end_tup_output(), fb(), GetConfigOptionByName(), name, TTSOpsVirtual, TupleDescFinalize(), TupleDescInitBuiltinEntry(), and value.

Referenced by GetPGVariable().