worries about funny characters.
/*-------------------------------------------------------------------------
*
* variable.c
- * Routines for handling of 'SET var TO',
- * 'SHOW var' and 'RESET var' statements.
+ * Routines for handling specialized SET variables.
+ *
*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.66 2002/05/06 19:47:30 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.67 2002/05/17 01:19:17 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/xact.h"
#include "catalog/pg_shadow.h"
-#include "catalog/pg_type.h"
#include "commands/variable.h"
#include "miscadmin.h"
-#include "optimizer/cost.h"
-#include "optimizer/paths.h"
-#include "parser/parse_type.h"
#include "utils/builtins.h"
-#include "utils/date.h"
#include "utils/guc.h"
+#include "utils/syscache.h"
#include "utils/tqual.h"
#ifdef MULTIBYTE
#endif
-static bool show_datestyle(void);
-static bool reset_datestyle(void);
-static bool parse_datestyle(List *);
-static bool show_timezone(void);
-static bool reset_timezone(void);
-static bool parse_timezone(List *);
-
-static bool show_XactIsoLevel(void);
-static bool reset_XactIsoLevel(void);
-static bool parse_XactIsoLevel(List *);
-static bool show_random_seed(void);
-static bool reset_random_seed(void);
-static bool parse_random_seed(List *);
-
-static bool show_client_encoding(void);
-static bool reset_client_encoding(void);
-static bool parse_client_encoding(List *);
-static bool show_server_encoding(void);
-static bool reset_server_encoding(void);
-static bool parse_server_encoding(List *);
-
-
/*
- * get_token
- * Obtain the next item in a comma-separated list of items,
- * where each item can be either "word" or "word=word".
- * The "word=word" form is only accepted if 'val' is not NULL.
- * Words are any sequences not containing whitespace, ',', or '='.
- * Whitespace can appear between the words and punctuation.
- *
- * 'tok': receives a pointer to first word of item, or NULL if none.
- * 'val': if not NULL, receives a pointer to second word, or NULL if none.
- * 'str': start of input string.
- *
- * Returns NULL if input string contained no more words, else pointer
- * to just past this item, which can be used as 'str' for next call.
- * (If this is the last item, returned pointer will point at a null char,
- * so caller can alternatively check for that instead of calling again.)
- *
- * NB: input string is destructively modified by placing null characters
- * at ends of words!
- *
- * A former version of this code avoided modifying the input string by
- * returning palloc'd copies of the words. However, we want to use this
- * code early in backend startup to parse the PGDATESTYLE environment var,
- * and palloc/pfree aren't initialized at that point. Cleanest answer
- * seems to be to palloc in SetPGVariable() so that we can treat the string
- * as modifiable here.
+ * DATESTYLE
*/
-static char *
-get_token(char **tok, char **val, char *str)
-{
- char ch;
-
- *tok = NULL;
- if (val != NULL)
- *val = NULL;
-
- if (!str || *str == '\0')
- return NULL;
-
- /* skip leading white space */
- while (isspace((unsigned char) *str))
- str++;
-
- /* end of string? then return NULL */
- if (*str == '\0')
- return NULL;
-
- if (*str == ',' || *str == '=')
- elog(ERROR, "Syntax error near \"%s\": empty setting", str);
-
- /* OK, at beginning of non-empty item */
- *tok = str;
-
- /* Advance to end of word */
- while (*str && !isspace((unsigned char) *str) &&
- *str != ',' && *str != '=')
- str++;
-
- /* Terminate word string for caller */
- ch = *str;
- *str = '\0';
-
- /* Skip any whitespace */
- while (isspace((unsigned char) ch))
- ch = *(++str);
-
- /* end of string? */
- if (ch == '\0')
- return str;
- /* delimiter? */
- if (ch == ',')
- return ++str;
-
- /* Had better be '=', and caller must be expecting it */
- if (val == NULL || ch != '=')
- elog(ERROR, "Syntax error near \"%s\"", str);
-
- /* '=': get the value */
- str++;
-
- /* skip whitespace after '=' */
- while (isspace((unsigned char) *str))
- str++;
-
- if (*str == ',' || *str == '\0')
- elog(ERROR, "Syntax error near \"=%s\"", str);
-
- /* OK, at beginning of non-empty value */
- *val = str;
-
- /* Advance to end of word */
- while (*str && !isspace((unsigned char) *str) && *str != ',')
- str++;
-
- /* Terminate word string for caller */
- ch = *str;
- *str = '\0';
-
- /* Skip any whitespace */
- while (isspace((unsigned char) ch))
- ch = *(++str);
-
- /* end of string? */
- if (ch == '\0')
- return str;
- /* delimiter? */
- if (ch == ',')
- return ++str;
-
- elog(ERROR, "Syntax error near \"%s\"", str);
-
- return str;
-}
-
/*
- * DATESTYLE
- *
- * NOTE: set_default_datestyle() is called during backend startup to check
- * if the PGDATESTYLE environment variable is set. We want the env var
- * to determine the value that "RESET DateStyle" will reset to!
+ * assign_datestyle: GUC assign_hook for datestyle
*/
-
-/* These get initialized from the "master" values in init/globals.c */
-static int DefaultDateStyle;
-static bool DefaultEuroDates;
-
-static bool
-parse_datestyle_internal(char *value)
+const char *
+assign_datestyle(const char *value, bool doit, bool interactive)
{
- char *tok;
+ int newDateStyle = DateStyle;
+ bool newEuroDates = EuroDates;
+ bool ok = true;
int dcnt = 0,
ecnt = 0;
+ char *rawstring;
+ char *result;
+ List *elemlist;
+ List *l;
- if (value == NULL)
- return reset_datestyle();
+ /* Need a modifiable copy of string */
+ rawstring = pstrdup(value);
- while ((value = get_token(&tok, NULL, value)) != 0)
+ /* Parse string into list of identifiers */
+ if (!SplitIdentifierString(rawstring, ',', &elemlist))
{
+ /* syntax error in list */
+ pfree(rawstring);
+ freeList(elemlist);
+ if (interactive)
+ elog(ERROR, "SET DATESTYLE: invalid list syntax");
+ return NULL;
+ }
+
+ foreach(l, elemlist)
+ {
+ char *tok = (char *) lfirst(l);
+
/* Ugh. Somebody ought to write a table driven version -- mjl */
- if (!strcasecmp(tok, "ISO"))
+ if (strcasecmp(tok, "ISO") == 0)
{
- DateStyle = USE_ISO_DATES;
+ newDateStyle = USE_ISO_DATES;
dcnt++;
}
- else if (!strcasecmp(tok, "SQL"))
+ else if (strcasecmp(tok, "SQL") == 0)
{
- DateStyle = USE_SQL_DATES;
+ newDateStyle = USE_SQL_DATES;
dcnt++;
}
- else if (!strncasecmp(tok, "POSTGRESQL", 8))
+ else if (strncasecmp(tok, "POSTGRESQL", 8) == 0)
{
- DateStyle = USE_POSTGRES_DATES;
+ newDateStyle = USE_POSTGRES_DATES;
dcnt++;
}
- else if (!strcasecmp(tok, "GERMAN"))
+ else if (strcasecmp(tok, "GERMAN") == 0)
{
- DateStyle = USE_GERMAN_DATES;
+ newDateStyle = USE_GERMAN_DATES;
dcnt++;
- if ((ecnt > 0) && (!EuroDates))
- ecnt++;
- EuroDates = TRUE;
+ if ((ecnt > 0) && (!newEuroDates))
+ ok = false;
+ newEuroDates = TRUE;
}
- else if (!strncasecmp(tok, "EURO", 4))
+ else if (strncasecmp(tok, "EURO", 4) == 0)
{
- EuroDates = TRUE;
- if ((dcnt <= 0) || (DateStyle != USE_GERMAN_DATES))
- ecnt++;
+ newEuroDates = TRUE;
+ ecnt++;
}
- else if ((!strcasecmp(tok, "US"))
- || (!strncasecmp(tok, "NONEURO", 7)))
+ else if (strcasecmp(tok, "US") == 0
+ || strncasecmp(tok, "NONEURO", 7) == 0)
{
- EuroDates = FALSE;
- if ((dcnt <= 0) || (DateStyle == USE_GERMAN_DATES))
- ecnt++;
+ newEuroDates = FALSE;
+ ecnt++;
+ if ((dcnt > 0) && (newDateStyle == USE_GERMAN_DATES))
+ ok = false;
}
- else if (!strcasecmp(tok, "DEFAULT"))
+ else if (strcasecmp(tok, "DEFAULT") == 0)
{
- DateStyle = DefaultDateStyle;
- EuroDates = DefaultEuroDates;
+ /*
+ * Easiest way to get the current DEFAULT state is to fetch
+ * the DEFAULT string from guc.c and recursively parse it.
+ *
+ * We can't simply "return assign_datestyle(...)" because we
+ * need to handle constructs like "DEFAULT, ISO".
+ */
+ int saveDateStyle = DateStyle;
+ bool saveEuroDates = EuroDates;
+ const char *subval;
+
+ subval = assign_datestyle(GetConfigOptionResetString("datestyle"),
+ true, interactive);
+ newDateStyle = DateStyle;
+ newEuroDates = EuroDates;
+ DateStyle = saveDateStyle;
+ EuroDates = saveEuroDates;
+ if (!subval)
+ {
+ ok = false;
+ break;
+ }
+ /* Here we know that our own return value is always malloc'd */
+ /* when doit is true */
+ free((char *) subval);
+ dcnt++;
ecnt++;
}
else
- elog(ERROR, "SET DATESTYLE bad value (%s)", tok);
+ {
+ if (interactive)
+ elog(ERROR, "SET DATESTYLE: unrecognized keyword %s", tok);
+ ok = false;
+ break;
+ }
}
if (dcnt > 1 || ecnt > 1)
- elog(WARNING, "SET DATESTYLE specified conflicting settings");
-
- return TRUE;
-}
-
-static bool
-parse_datestyle(List *args)
-{
- int rstat = FALSE;
- List *arg;
- char *value;
-
- if (args == NULL)
- return reset_datestyle();
+ ok = false;
- Assert(IsA(args, List));
+ pfree(rawstring);
+ freeList(elemlist);
- foreach(arg, args)
+ if (!ok)
{
- Node *n;
-
- Assert(IsA(arg, List));
- n = lfirst(arg);
-
- /* Require untyped, stringy constants for arguments. */
- if (IsA(n, A_Const))
- {
- A_Const *p = (A_Const *) n;
- TypeName *type = p->typename;
- Value *v = &(p->val);
-
- if (type != NULL)
- {
- Value *s;
- Assert(IsA(type->names, List));
- s = (Value *) lfirst(type->names);
- elog(ERROR, "SET DATESTYLE does not allow input of type %s"
- "\n\tUse an untyped string instead", s->val.str);
- }
+ if (interactive)
+ elog(ERROR, "SET DATESTYLE: conflicting specifications");
+ return NULL;
+ }
- value = v->val.str;
- }
- else
- {
- elog(ERROR, "SET DATESTYLE argument is not valid");
- value = NULL;
- }
+ /*
+ * If we aren't going to do the assignment, just return OK indicator.
+ */
+ if (!doit)
+ return value;
- rstat = parse_datestyle_internal(value);
+ /*
+ * Prepare the canonical string to return. GUC wants it malloc'd.
+ */
+ result = (char *) malloc(32);
+ if (!result)
+ return NULL;
- if (rstat != TRUE)
- return rstat;
+ switch (newDateStyle)
+ {
+ case USE_ISO_DATES:
+ strcpy(result, "ISO");
+ break;
+ case USE_SQL_DATES:
+ strcpy(result, "SQL");
+ break;
+ case USE_GERMAN_DATES:
+ strcpy(result, "GERMAN");
+ break;
+ default:
+ strcpy(result, "POSTGRESQL");
+ break;
}
+ strcat(result, newEuroDates ? ", EURO" : ", US");
+
+ /*
+ * Finally, it's safe to assign to the global variables;
+ * the assignment cannot fail now.
+ */
+ DateStyle = newDateStyle;
+ EuroDates = newEuroDates;
- return rstat;
+ return result;
}
-static bool
+/*
+ * show_datestyle: GUC show_hook for datestyle
+ */
+const char *
show_datestyle(void)
{
- char buf[64];
+ static char buf[64];
- strcpy(buf, "DateStyle is ");
switch (DateStyle)
{
case USE_ISO_DATES:
- strcat(buf, "ISO");
+ strcpy(buf, "ISO");
break;
case USE_SQL_DATES:
- strcat(buf, "SQL");
+ strcpy(buf, "SQL");
break;
case USE_GERMAN_DATES:
- strcat(buf, "German");
+ strcpy(buf, "German");
break;
default:
- strcat(buf, "Postgres");
+ strcpy(buf, "Postgres");
break;
};
strcat(buf, " with ");
strcat(buf, ((EuroDates) ? "European" : "US (NonEuropean)"));
strcat(buf, " conventions");
- elog(INFO, buf, NULL);
-
- return TRUE;
-}
-
-static bool
-reset_datestyle(void)
-{
- DateStyle = DefaultDateStyle;
- EuroDates = DefaultEuroDates;
-
- return TRUE;
-}
-
-void
-set_default_datestyle(void)
-{
- char *DBDate;
-
- /*
- * Initialize from compile-time defaults in init/globals.c. NB: this
- * is a necessary step; consider PGDATESTYLE="DEFAULT".
- */
- DefaultDateStyle = DateStyle;
- DefaultEuroDates = EuroDates;
-
- /* If the environment var is set, override compiled-in values */
- DBDate = getenv("PGDATESTYLE");
- if (DBDate == NULL)
- return;
-
- /*
- * Make a modifiable copy --- overwriting the env var doesn't seem
- * like a good idea, even though we currently won't look at it again.
- * Note that we cannot use palloc at this early stage of
- * initialization.
- */
- DBDate = strdup(DBDate);
-
- /*
- * Parse desired setting into DateStyle/EuroDates Use
- * parse_datestyle_internal() to avoid any palloc() issues per above -
- * thomas 2001-10-15
- */
- parse_datestyle_internal(DBDate);
-
- free(DBDate);
-
- /* And make it the default for future RESETs */
- DefaultDateStyle = DateStyle;
- DefaultEuroDates = EuroDates;
+ return buf;
}
-/* Timezone support
- * Working storage for strings is allocated with an arbitrary size of 64 bytes.
+/*
+ * TIMEZONE
*/
-static char *defaultTZ = NULL;
-static char TZvalue[64];
+/*
+ * Storage for TZ env var is allocated with an arbitrary size of 64 bytes.
+ */
static char tzbuf[64];
/*
- *
- * TIMEZONE
- *
- */
-/* parse_timezone()
- * Handle SET TIME ZONE...
- * Try to save existing TZ environment variable for later use in RESET TIME ZONE.
- * Accept an explicit interval per SQL9x, though this is less useful than a full time zone.
- * - thomas 2001-10-11
+ * assign_timezone: GUC assign_hook for timezone
*/
-static bool
-parse_timezone(List *args)
+const char *
+assign_timezone(const char *value, bool doit, bool interactive)
{
- List *arg;
- TypeName *type;
+ char *result;
+ char *endptr;
+ double hours;
- if (args == NULL)
- return reset_timezone();
-
- Assert(IsA(args, List));
-
- foreach(arg, args)
+ /*
+ * Check for INTERVAL 'foo'
+ */
+ if (strncasecmp(value, "interval", 8) == 0)
{
- A_Const *p;
-
- Assert(IsA(arg, List));
- p = lfirst(arg);
- Assert(IsA(p, A_Const));
-
- type = p->typename;
- if (type != NULL)
+ const char *valueptr = value;
+ char *val;
+ Interval *interval;
+
+ valueptr += 8;
+ while (isspace((unsigned char) *valueptr))
+ valueptr++;
+ if (*valueptr++ != '\'')
+ return NULL;
+ val = pstrdup(valueptr);
+ /* Check and remove trailing quote */
+ endptr = strchr(val, '\'');
+ if (!endptr || endptr[1] != '\0')
{
- Oid typeOid = typenameTypeId(type);
-
- if (typeOid == INTERVALOID)
- {
- Interval *interval;
-
- interval = DatumGetIntervalP(DirectFunctionCall3(interval_in,
- CStringGetDatum(p->val.val.str),
- ObjectIdGetDatum(InvalidOid),
- Int32GetDatum(type->typmod)));
- if (interval->month != 0)
- elog(ERROR, "SET TIME ZONE illegal INTERVAL; month not allowed");
- CTimeZone = interval->time;
- }
- else if (typeOid == FLOAT8OID)
+ pfree(val);
+ return NULL;
+ }
+ *endptr = '\0';
+ /*
+ * Try to parse it. XXX an invalid interval format will result in
+ * elog, which is not desirable for GUC. We did what we could to
+ * guard against this in flatten_set_variable_args, but a string
+ * coming in from postgresql.conf might contain anything.
+ */
+ interval = DatumGetIntervalP(DirectFunctionCall3(interval_in,
+ CStringGetDatum(val),
+ ObjectIdGetDatum(InvalidOid),
+ Int32GetDatum(-1)));
+ pfree(val);
+ if (interval->month != 0)
+ {
+ if (interactive)
+ elog(ERROR, "SET TIME ZONE: illegal INTERVAL; month not allowed");
+ pfree(interval);
+ return NULL;
+ }
+ if (doit)
+ {
+ CTimeZone = interval->time;
+ HasCTZSet = true;
+ }
+ pfree(interval);
+ }
+ else
+ {
+ /*
+ * Try it as a numeric number of hours (possibly fractional).
+ */
+ hours = strtod(value, &endptr);
+ if (endptr != value && *endptr == '\0')
+ {
+ if (doit)
{
- float8 time;
-
- time = DatumGetFloat8(DirectFunctionCall1(float8in, CStringGetDatum(p->val.val.str)));
- CTimeZone = time * 3600;
+ CTimeZone = hours * 3600;
+ HasCTZSet = true;
}
-
+ }
+ else if (strcasecmp(value, "UNKNOWN") == 0)
+ {
/*
- * We do not actually generate an integer constant in gram.y
- * so this is not used...
+ * Clear any TZ value we may have established.
+ *
+ * unsetenv() works fine, but is BSD, not POSIX, and is not
+ * available under Solaris, among others. Apparently putenv()
+ * called as below clears the process-specific environment
+ * variables. Other reasonable arguments to putenv() (e.g.
+ * "TZ=", "TZ", "") result in a core dump (under Linux anyway).
+ * - thomas 1998-01-26
*/
- else if (typeOid == INT4OID)
- {
- int32 time;
-
- time = p->val.val.ival;
- CTimeZone = time * 3600;
- }
- else
+ if (doit)
{
- elog(ERROR, "Unable to process SET TIME ZONE command; internal coding error");
+ if (tzbuf[0] == 'T')
+ {
+ strcpy(tzbuf, "=");
+ if (putenv(tzbuf) != 0)
+ elog(ERROR, "Unable to clear TZ environment variable");
+ tzset();
+ }
+ HasCTZSet = false;
}
-
- HasCTZSet = true;
}
else
{
- char *tok;
- char *value;
-
- value = p->val.val.str;
-
- while ((value = get_token(&tok, NULL, value)) != 0)
+ /*
+ * Otherwise assume it is a timezone name.
+ *
+ * XXX unfortunately we have no reasonable way to check whether a
+ * timezone name is good, so we have to just assume that it is.
+ */
+ if (doit)
{
- /* Not yet tried to save original value from environment? */
- if (defaultTZ == NULL)
- {
- /* found something? then save it for later */
- if ((defaultTZ = getenv("TZ")) != NULL)
- strcpy(TZvalue, defaultTZ);
-
- /* found nothing so mark with an invalid pointer */
- else
- defaultTZ = (char *) -1;
- }
-
strcpy(tzbuf, "TZ=");
- strcat(tzbuf, tok);
- if (putenv(tzbuf) != 0)
- elog(ERROR, "Unable to set TZ environment variable to %s", tok);
-
+ strncat(tzbuf, value, sizeof(tzbuf)-4);
+ if (putenv(tzbuf) != 0) /* shouldn't happen? */
+ elog(LOG, "assign_timezone: putenv failed");
tzset();
+ HasCTZSet = false;
}
-
- HasCTZSet = false;
}
}
- return TRUE;
-} /* parse_timezone() */
+ /*
+ * If we aren't going to do the assignment, just return OK indicator.
+ */
+ if (!doit)
+ return value;
+
+ /*
+ * Prepare the canonical string to return. GUC wants it malloc'd.
+ */
+ result = (char *) malloc(sizeof(tzbuf));
+ if (!result)
+ return NULL;
+
+ if (HasCTZSet)
+ {
+ snprintf(result, sizeof(tzbuf), "%.5f",
+ (double) CTimeZone / 3600.0);
+ }
+ else if (tzbuf[0] == 'T')
+ {
+ strcpy(result, tzbuf + 3);
+ }
+ else
+ {
+ strcpy(result, "UNKNOWN");
+ }
+
+ return result;
+}
-static bool
+/*
+ * show_timezone: GUC show_hook for timezone
+ */
+const char *
show_timezone(void)
{
char *tzn;
interval.month = 0;
interval.time = CTimeZone;
- tzn = DatumGetCString(DirectFunctionCall1(interval_out, IntervalPGetDatum(&interval)));
+ tzn = DatumGetCString(DirectFunctionCall1(interval_out,
+ IntervalPGetDatum(&interval)));
}
else
tzn = getenv("TZ");
if (tzn != NULL)
- elog(INFO, "Time zone is '%s'", tzn);
- else
- elog(INFO, "Time zone is unset");
-
- return TRUE;
-} /* show_timezone() */
-
-/* reset_timezone()
- * Set TZ environment variable to original value.
- * Note that if TZ was originally not set, TZ should be cleared.
- * unsetenv() works fine, but is BSD, not POSIX, and is not available
- * under Solaris, among others. Apparently putenv() called as below
- * clears the process-specific environment variables.
- * Other reasonable arguments to putenv() (e.g. "TZ=", "TZ", "") result
- * in a core dump (under Linux anyway).
- * - thomas 1998-01-26
- */
-static bool
-reset_timezone(void)
-{
- if (HasCTZSet)
- HasCTZSet = false;
-
- /* no time zone has been set in this session? */
- else if (defaultTZ == NULL)
- {
- }
-
- /* time zone was set and original explicit time zone available? */
- else if (defaultTZ != (char *) -1)
- {
- strcpy(tzbuf, "TZ=");
- strcat(tzbuf, TZvalue);
- if (putenv(tzbuf) != 0)
- elog(ERROR, "Unable to set TZ environment variable to %s", TZvalue);
- tzset();
- }
-
- /*
- * otherwise, time zone was set but no original explicit time zone
- * available
- */
- else
- {
- strcpy(tzbuf, "=");
- if (putenv(tzbuf) != 0)
- elog(ERROR, "Unable to clear TZ environment variable");
- tzset();
- }
-
- return TRUE;
-} /* reset_timezone() */
+ return tzn;
+ return "unknown";
+}
/*
- *
- * SET TRANSACTION
- *
+ * SET TRANSACTION ISOLATION LEVEL
*/
-static bool
-parse_XactIsoLevel(List *args)
+const char *
+assign_XactIsoLevel(const char *value, bool doit, bool interactive)
{
- char *value;
-
- if (args == NULL)
- return reset_XactIsoLevel();
-
- Assert(IsA(args, List));
- Assert(IsA(lfirst(args), A_Const));
- /* Should only get one argument from the parser */
- if (lnext(args) != NIL)
- elog(ERROR, "SET TRANSACTION ISOLATION LEVEL takes only one argument");
-
- Assert(((A_Const *) lfirst(args))->val.type = T_String);
- value = ((A_Const *) lfirst(args))->val.val.str;
-
- if (SerializableSnapshot != NULL)
- {
+ if (doit && interactive && SerializableSnapshot != NULL)
elog(ERROR, "SET TRANSACTION ISOLATION LEVEL must be called before any query");
- return TRUE;
- }
if (strcmp(value, "serializable") == 0)
- XactIsoLevel = XACT_SERIALIZABLE;
+ { if (doit) XactIsoLevel = XACT_SERIALIZABLE; }
else if (strcmp(value, "read committed") == 0)
- XactIsoLevel = XACT_READ_COMMITTED;
+ { if (doit) XactIsoLevel = XACT_READ_COMMITTED; }
+ else if (strcmp(value, "default") == 0)
+ { if (doit) XactIsoLevel = DefaultXactIsoLevel; }
else
- elog(ERROR, "invalid transaction isolation level: %s", value);
+ return NULL;
- return TRUE;
+ return value;
}
-static bool
+const char *
show_XactIsoLevel(void)
{
-
if (XactIsoLevel == XACT_SERIALIZABLE)
- elog(INFO, "TRANSACTION ISOLATION LEVEL is SERIALIZABLE");
+ return "SERIALIZABLE";
else
- elog(INFO, "TRANSACTION ISOLATION LEVEL is READ COMMITTED");
- return TRUE;
-}
-
-static bool
-reset_XactIsoLevel(void)
-{
-
- if (SerializableSnapshot != NULL)
- {
- elog(ERROR, "SET TRANSACTION ISOLATION LEVEL must be called before any query");
- return TRUE;
- }
-
- XactIsoLevel = DefaultXactIsoLevel;
-
- return TRUE;
+ return "READ COMMITTED";
}
/*
* Random number seed
*/
-static bool
-parse_random_seed(List *args)
-{
- A_Const *p;
- double seed = 0;
-
- if (args == NULL)
- return reset_random_seed();
-
- Assert(IsA(args, List));
- /* Should only get one argument from the parser */
- if (lnext(args) != NIL)
- elog(ERROR, "SET SEED takes only one argument");
-
- p = lfirst(args);
- Assert(IsA(p, A_Const));
- if ((p->val.type == T_String)
- || (p->val.type == T_Float))
- {
- seed = DatumGetFloat8(DirectFunctionCall1(float8in, CStringGetDatum(p->val.val.str)));
- }
- else if (p->val.type == T_Integer)
- {
- seed = p->val.val.ival;
- }
- else
- {
- elog(ERROR, "SET SEED internal coding error");
- }
-
- DirectFunctionCall1(setseed, Float8GetDatum(seed));
-
- return (TRUE);
-}
-
-static bool
-show_random_seed(void)
+bool
+assign_random_seed(double value, bool doit, bool interactive)
{
- elog(INFO, "Seed for random number generator is unavailable");
- return (TRUE);
+ /* Can't really roll back on error, so ignore non-interactive setting */
+ if (doit && interactive)
+ DirectFunctionCall1(setseed, Float8GetDatum(value));
+ return true;
}
-static bool
-reset_random_seed(void)
+const char *
+show_random_seed(void)
{
- double seed = 0.5;
-
- DirectFunctionCall1(setseed, Float8GetDatum(seed));
- return (TRUE);
+ return "unavailable";
}
* clients.
*/
-static bool
-parse_client_encoding(List *args)
+const char *
+assign_client_encoding(const char *value, bool doit, bool interactive)
{
- char *value;
-
#ifdef MULTIBYTE
int encoding;
-#endif
-
- if (args == NULL)
- return reset_client_encoding();
-
- if (lnext(args) != NIL)
- elog(ERROR, "SET CLIENT ENCODING takes only one argument");
-
- Assert(IsA(lfirst(args), A_Const));
- if (((A_Const *) lfirst(args))->val.type != T_String)
- {
- elog(ERROR, "SET CLIENT_ENCODING requires an encoding name");
- }
-
- value = ((A_Const *) lfirst(args))->val.val.str;
+ int old_encoding = 0;
-#ifdef MULTIBYTE
encoding = pg_valid_client_encoding(value);
if (encoding < 0)
+ return NULL;
+ /*
+ * Ugly API here ... can't test validity without setting new encoding...
+ */
+ if (!doit)
+ old_encoding = pg_get_client_encoding();
+ if (pg_set_client_encoding(encoding) < 0)
{
- if (value)
- elog(ERROR, "Client encoding '%s' is not supported", value);
- else
- elog(ERROR, "No client encoding is specified");
- }
- else
- {
- if (pg_set_client_encoding(encoding) < 0)
- {
+ if (interactive)
elog(ERROR, "Conversion between %s and %s is not supported",
value, GetDatabaseEncodingName());
- }
+ return NULL;
}
+ if (!doit)
+ pg_set_client_encoding(old_encoding);
#else
- if (value &&
- strcasecmp(value, pg_get_client_encoding_name()) != 0)
- elog(ERROR, "Client encoding %s is not supported", value);
-#endif
- return TRUE;
-}
-
-static bool
-show_client_encoding(void)
-{
- elog(INFO, "Current client encoding is '%s'",
- pg_get_client_encoding_name());
- return TRUE;
-}
-
-static bool
-reset_client_encoding(void)
-{
-#ifdef MULTIBYTE
- int encoding;
- char *env = getenv("PGCLIENTENCODING");
-
- if (env)
- {
- encoding = pg_char_to_encoding(env);
- if (encoding < 0)
- encoding = GetDatabaseEncoding();
- }
- else
- encoding = GetDatabaseEncoding();
-
- pg_set_client_encoding(encoding);
+ if (strcasecmp(value, pg_get_client_encoding_name()) != 0)
+ return NULL;
#endif
- return TRUE;
-}
-/* Called during MULTIBYTE backend startup ... */
-void
-set_default_client_encoding(void)
-{
- reset_client_encoding();
+ return value;
}
-static bool
-parse_server_encoding(List *args)
+const char *
+assign_server_encoding(const char *value, bool doit, bool interactive)
{
- elog(INFO, "SET SERVER_ENCODING is not supported");
- return TRUE;
+ if (interactive)
+ elog(ERROR, "SET SERVER_ENCODING is not supported");
+ /* Pretend never to fail in noninteractive case */
+ return value;
}
-static bool
+const char *
show_server_encoding(void)
{
- elog(INFO, "Current server encoding is '%s'", GetDatabaseEncodingName());
- return TRUE;
-}
-
-static bool
-reset_server_encoding(void)
-{
- elog(INFO, "RESET SERVER_ENCODING is not supported");
- return TRUE;
+ return GetDatabaseEncodingName();
}
-static bool
-show_session_authorization(void)
+/*
+ * SET SESSION AUTHORIZATION
+ *
+ * Note: when resetting session auth after an error, we can't expect to do
+ * catalog lookups. Hence, the stored form of the value is always a numeric
+ * userid that can be re-used directly.
+ */
+const char *
+assign_session_authorization(const char *value, bool doit, bool interactive)
{
- elog(INFO, "Current session authorization is '%s'",
- GetUserName(GetSessionUserId()));
- return TRUE;
-}
+ Oid usesysid;
+ char *endptr;
+ char *result;
+ usesysid = (Oid) strtoul(value, &endptr, 10);
-
-/* SetPGVariable()
- * Dispatcher for handling SET commands.
- * Special cases ought to be removed and handled separately by TCOP
- */
-void
-SetPGVariable(const char *name, List *args)
-{
- if (strcasecmp(name, "datestyle") == 0)
- parse_datestyle(args);
- else if (strcasecmp(name, "timezone") == 0)
- parse_timezone(args);
- else if (strcasecmp(name, "XactIsoLevel") == 0)
- parse_XactIsoLevel(args);
- else if (strcasecmp(name, "client_encoding") == 0)
- parse_client_encoding(args);
- else if (strcasecmp(name, "server_encoding") == 0)
- parse_server_encoding(args);
- else if (strcasecmp(name, "seed") == 0)
- parse_random_seed(args);
+ if (endptr != value && *endptr == '\0' && OidIsValid(usesysid))
+ {
+ /* use the numeric user ID */
+ }
else
{
- /*
- * For routines defined somewhere else, go ahead and extract the
- * string argument to match the original interface definition.
- * Later, we can change this code too...
- */
- char *value;
+ HeapTuple userTup;
- if (args != NULL)
+ userTup = SearchSysCache(SHADOWNAME,
+ PointerGetDatum(value),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(userTup))
{
- A_Const *n;
-
- /* Ensure one argument only... */
- if (lnext(args) != NIL)
- elog(ERROR, "SET %s takes only one argument", name);
-
- n = (A_Const *) lfirst(args);
- if ((n->val.type == T_String)
- || (n->val.type == T_Float))
- {
- value = n->val.val.str;
- }
- else if (n->val.type == T_Integer)
- {
- /* We should convert back to a string. */
- value = DatumGetCString(DirectFunctionCall1(int4out, Int32GetDatum(n->val.val.ival)));
- }
- else
- {
- elog(ERROR, "SET %s accepts a string argument for this parameter"
- name);
- value = NULL;
- }
- }
- else
- {
- value = NULL;
+ if (interactive)
+ elog(ERROR, "user \"%s\" does not exist", value);
+ return NULL;
}
- if (strcasecmp(name, "session_authorization") == 0)
- SetSessionAuthorization(value);
- else
- SetConfigOption(name,
- value,
- (superuser() ? PGC_SUSET : PGC_USERSET),
- PGC_S_SESSION);
- }
- return;
-}
+ usesysid = ((Form_pg_shadow) GETSTRUCT(userTup))->usesysid;
-void
-GetPGVariable(const char *name)
-{
- if (strcasecmp(name, "datestyle") == 0)
- show_datestyle();
- else if (strcasecmp(name, "timezone") == 0)
- show_timezone();
- else if (strcasecmp(name, "XactIsoLevel") == 0)
- show_XactIsoLevel();
- else if (strcasecmp(name, "client_encoding") == 0)
- show_client_encoding();
- else if (strcasecmp(name, "server_encoding") == 0)
- show_server_encoding();
- else if (strcasecmp(name, "seed") == 0)
- show_random_seed();
- else if (strcasecmp(name, "session_authorization") == 0)
- show_session_authorization();
- else if (strcasecmp(name, "all") == 0)
- {
- ShowAllGUCConfig();
- show_datestyle();
- show_timezone();
- show_XactIsoLevel();
- show_client_encoding();
- show_server_encoding();
- show_random_seed();
+ ReleaseSysCache(userTup);
}
- else
- {
- const char *val = GetConfigOption(name);
- elog(INFO, "%s is %s", name, val);
- }
+ if (doit)
+ SetSessionAuthorization(usesysid);
+
+ result = (char *) malloc(32);
+ if (!result)
+ return NULL;
+
+ snprintf(result, 32, "%lu", (unsigned long) usesysid);
+
+ return result;
}
-void
-ResetPGVariable(const char *name)
+const char *
+show_session_authorization(void)
{
- if (strcasecmp(name, "datestyle") == 0)
- reset_datestyle();
- else if (strcasecmp(name, "timezone") == 0)
- reset_timezone();
- else if (strcasecmp(name, "XactIsoLevel") == 0)
- reset_XactIsoLevel();
- else if (strcasecmp(name, "client_encoding") == 0)
- reset_client_encoding();
- else if (strcasecmp(name, "server_encoding") == 0)
- reset_server_encoding();
- else if (strcasecmp(name, "seed") == 0)
- reset_random_seed();
- else if (strcasecmp(name, "session_authorization") == 0)
- SetSessionAuthorization(NULL);
- else if (strcasecmp(name, "all") == 0)
- {
- reset_random_seed();
- /* reset_server_encoding(); */
- reset_client_encoding();
- reset_datestyle();
- reset_timezone();
- /* should we reset session authorization here? */
-
- ResetAllOptions(false);
- }
- else
- SetConfigOption(name, NULL,
- superuser() ? PGC_SUSET : PGC_USERSET,
- PGC_S_SESSION);
+ return GetUserName(GetSessionUserId());
}
*
* Support for grand unified configuration scheme, including SET
* command, configuration file, and command line options.
+ * See src/backend/utils/misc/README for more information.
*
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.67 2002/05/14 13:05:43 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.68 2002/05/17 01:19:18 tgl Exp $
*
* Copyright 2000 by PostgreSQL Global Development Group
* Written by Peter Eisentraut
. #include "access/xlog.h"
#include "catalog/namespace.h"
#include "commands/async.h"
+#include "commands/variable.h"
#include "fmgr.h"
#include "libpq/auth.h"
#include "libpq/pqcomm.h"
#ifdef HAVE_SYSLOG
extern char *Syslog_facility;
extern char *Syslog_ident;
-static bool check_facility(const char *facility);
-#endif
-
-static char *default_iso_level_string;
-static bool check_defaultxactisolevel(const char *value);
-static void assign_defaultxactisolevel(const char *value);
+static const char *assign_facility(const char *facility,
+ bool doit, bool interactive);
+#endif
/*
* Debugging options
#define PG_KRB_SRVTAB ""
#endif
-static bool guc_session_init = false; /* XXX mildly bogus */
+/*
+ * These variables are all dummies that don't do anything, except in some
+ * cases provide the value for SHOW to display. The real state is elsewhere
+ * and is kept in sync by assign_hooks.
+ */
+static double phony_random_seed;
+static char *client_encoding_string;
+static char *datestyle_string;
+static char *default_iso_level_string;
+static char *server_encoding_string;
+static char *session_authorization_string;
+static char *timezone_string;
+static char *XactIsoLevel_string;
+
+static const char *assign_defaultxactisolevel(const char *newval,
+ bool doit, bool interactive);
+
/*
* Declarations for GUC tables
+ *
+ * See src/backend/utils/misc/README for design notes.
*/
enum config_type
{
- PGC_NONE = 0,
PGC_BOOL,
PGC_INT,
PGC_REAL,
PGC_STRING
};
-
+/* Generic fields applicable to all types of variables */
struct config_generic
{
- const char *name;
- GucContext context;
- GucSource source;
- void *variable;
+ /* constant fields, must be set correctly in initial value: */
+ const char *name; /* name of variable - MUST BE FIRST */
+ GucContext context; /* context required to set the variable */
+ int flags; /* flag bits, see below */
+ /* variable fields, initialized at runtime: */
+ enum config_type vartype; /* type of variable (set only at startup) */
+ int status; /* status bits, see below */
+ GucSource reset_source; /* source of the reset_value */
+ GucSource session_source; /* source of the session_value */
+ GucSource tentative_source; /* source of the tentative_value */
+ GucSource source; /* source of the current actual value */
};
+/* bit values in flags field */
+#define GUC_LIST_INPUT 0x0001 /* input can be list format */
+#define GUC_LIST_QUOTE 0x0002 /* double-quote list elements */
+#define GUC_NO_SHOW_ALL 0x0004 /* exclude from SHOW ALL */
+#define GUC_NO_RESET_ALL 0x0008 /* exclude from RESET ALL */
+
+/* bit values in status field */
+#define GUC_HAVE_TENTATIVE 0x0001 /* tentative value is defined */
+#define GUC_HAVE_LOCAL 0x0002 /* a SET LOCAL has been executed */
+
+
+/* GUC records for specific variable types */
struct config_bool
{
- const char *name;
- GucContext context;
- GucSource source;
+ struct config_generic gen;
+ /* these fields must be set correctly in initial value: */
+ /* (all but reset_val are constants) */
bool *variable;
- bool default_val;
- /* No need for parse_hook ... presumably both values are legal */
- void (*assign_hook) (bool newval);
+ bool reset_val;
+ bool (*assign_hook) (bool newval, bool doit, bool interactive);
+ const char *(*show_hook) (void);
+ /* variable fields, initialized at runtime: */
+ bool session_val;
+ bool tentative_val;
};
-
struct config_int
{
- const char *name;
- GucContext context;
- GucSource source;
+ struct config_generic gen;
+ /* these fields must be set correctly in initial value: */
+ /* (all but reset_val are constants) */
int *variable;
- int default_val;
+ int reset_val;
int min;
int max;
- bool (*parse_hook) (int proposed);
- void (*assign_hook) (int newval);
+ bool (*assign_hook) (int newval, bool doit, bool interactive);
+ const char *(*show_hook) (void);
+ /* variable fields, initialized at runtime: */
+ int session_val;
+ int tentative_val;
};
-
struct config_real
{
- const char *name;
- GucContext context;
- GucSource source;
+ struct config_generic gen;
+ /* these fields must be set correctly in initial value: */
+ /* (all but reset_val are constants) */
double *variable;
- double default_val;
+ double reset_val;
double min;
double max;
- bool (*parse_hook) (double proposed);
- void (*assign_hook) (double newval);
+ bool (*assign_hook) (double newval, bool doit, bool interactive);
+ const char *(*show_hook) (void);
+ /* variable fields, initialized at runtime: */
+ double session_val;
+ double tentative_val;
};
-/*
- * String value options are allocated with strdup, not with the
- * pstrdup/palloc mechanisms. That is because configuration settings
- * are already in place before the memory subsystem is up. It would
- * perhaps be an idea to change that sometime.
- */
struct config_string
{
- const char *name;
- GucContext context;
- GucSource source;
+ struct config_generic gen;
+ /* these fields must be set correctly in initial value: */
+ /* (all are constants) */
char **variable;
- const char *boot_default_val;
- bool (*parse_hook) (const char *proposed);
- void (*assign_hook) (const char *newval);
- char *default_val;
+ const char *boot_val;
+ const char *(*assign_hook) (const char *newval, bool doit, bool interactive);
+ const char *(*show_hook) (void);
+ /* variable fields, initialized at runtime: */
+ char *reset_val;
+ char *session_val;
+ char *tentative_val;
};
+/* Macros for freeing malloc'd pointers only if appropriate to do so */
+/* Some of these tests are probably redundant, but be safe ... */
+#define SET_STRING_VARIABLE(rec, newval) \
+ do { \
+ if (*(rec)->variable && \
+ *(rec)->variable != (rec)->reset_val && \
+ *(rec)->variable != (rec)->session_val && \
+ *(rec)->variable != (rec)->tentative_val) \
+ free(*(rec)->variable); \
+ *(rec)->variable = (newval); \
+ } while (0)
+#define SET_STRING_RESET_VAL(rec, newval) \
+ do { \
+ if ((rec)->reset_val && \
+ (rec)->reset_val != *(rec)->variable && \
+ (rec)->reset_val != (rec)->session_val && \
+ (rec)->reset_val != (rec)->tentative_val) \
+ free((rec)->reset_val); \
+ (rec)->reset_val = (newval); \
+ } while (0)
+#define SET_STRING_SESSION_VAL(rec, newval) \
+ do { \
+ if ((rec)->session_val && \
+ (rec)->session_val != *(rec)->variable && \
+ (rec)->session_val != (rec)->reset_val && \
+ (rec)->session_val != (rec)->tentative_val) \
+ free((rec)->session_val); \
+ (rec)->session_val = (newval); \
+ } while (0)
+#define SET_STRING_TENTATIVE_VAL(rec, newval) \
+ do { \
+ if ((rec)->tentative_val && \
+ (rec)->tentative_val != *(rec)->variable && \
+ (rec)->tentative_val != (rec)->reset_val && \
+ (rec)->tentative_val != (rec)->session_val) \
+ free((rec)->tentative_val); \
+ (rec)->tentative_val = (newval); \
+ } while (0)
+
+
/*
* TO ADD AN OPTION:
*/
-/******** option names follow ********/
+/******** option records follow ********/
static struct config_bool
ConfigureNamesBool[] =
{
{
- "enable_seqscan", PGC_USERSET, PGC_S_DEFAULT, &enable_seqscan, true, NULL
+ { "enable_seqscan", PGC_USERSET }, &enable_seqscan,
+ true, NULL, NULL
},
{
- "enable_indexscan", PGC_USERSET, PGC_S_DEFAULT, &enable_indexscan, true, NULL
+ { "enable_indexscan", PGC_USERSET }, &enable_indexscan,
+ true, NULL, NULL
},
{
- "enable_tidscan", PGC_USERSET, PGC_S_DEFAULT, &enable_tidscan, true, NULL
+ { "enable_tidscan", PGC_USERSET }, &enable_tidscan,
+ true, NULL, NULL
},
{
- "enable_sort", PGC_USERSET, PGC_S_DEFAULT, &enable_sort, true, NULL
+ { "enable_sort", PGC_USERSET }, &enable_sort,
+ true, NULL, NULL
},
{
- "enable_nestloop", PGC_USERSET, PGC_S_DEFAULT, &enable_nestloop, true, NULL
+ { "enable_nestloop", PGC_USERSET }, &enable_nestloop,
+ true, NULL, NULL
},
{
- "enable_mergejoin", PGC_USERSET, PGC_S_DEFAULT, &enable_mergejoin, true, NULL
+ { "enable_mergejoin", PGC_USERSET }, &enable_mergejoin,
+ true, NULL, NULL
},
{
- "enable_hashjoin", PGC_USERSET, PGC_S_DEFAULT, &enable_hashjoin, true, NULL
+ { "enable_hashjoin", PGC_USERSET }, &enable_hashjoin,
+ true, NULL, NULL
},
{
- "ksqo", PGC_USERSET, PGC_S_DEFAULT, &_use_keyset_query_optimizer, false, NULL
+ { "ksqo", PGC_USERSET }, &_use_keyset_query_optimizer,
+ false, NULL, NULL
},
{
- "geqo", PGC_USERSET, PGC_S_DEFAULT, &enable_geqo, true, NULL
+ { "geqo", PGC_USERSET }, &enable_geqo,
+ true, NULL, NULL
},
{
- "tcpip_socket", PGC_POSTMASTER, PGC_S_DEFAULT, &NetServer, false, NULL
+ { "tcpip_socket", PGC_POSTMASTER }, &NetServer,
+ false, NULL, NULL
},
{
- "ssl", PGC_POSTMASTER, PGC_S_DEFAULT, &EnableSSL, false, NULL
+ { "ssl", PGC_POSTMASTER }, &EnableSSL,
+ false, NULL, NULL
},
{
- "fsync", PGC_SIGHUP, PGC_S_DEFAULT, &enableFsync, true, NULL
+ { "fsync", PGC_SIGHUP }, &enableFsync,
+ true, NULL, NULL
},
{
- "silent_mode", PGC_POSTMASTER, PGC_S_DEFAULT, &SilentMode, false, NULL
+ { "silent_mode", PGC_POSTMASTER }, &SilentMode,
+ false, NULL, NULL
},
{
- "log_connections", PGC_BACKEND, PGC_S_DEFAULT, &Log_connections, false, NULL
+ { "log_connections", PGC_BACKEND }, &Log_connections,
+ false, NULL, NULL
},
{
- "log_timestamp", PGC_SIGHUP, PGC_S_DEFAULT, &Log_timestamp, false, NULL
+ { "log_timestamp", PGC_SIGHUP }, &Log_timestamp,
+ false, NULL, NULL
},
{
- "log_pid", PGC_SIGHUP, PGC_S_DEFAULT, &Log_pid, false, NULL
+ { "log_pid", PGC_SIGHUP }, &Log_pid,
+ false, NULL, NULL
},
#ifdef USE_ASSERT_CHECKING
{
- "debug_assertions", PGC_USERSET, PGC_S_DEFAULT, &assert_enabled, true, NULL
+ { "debug_assertions", PGC_USERSET }, &assert_enabled,
+ true, NULL, NULL
},
#endif
{
- "debug_print_query", PGC_USERSET, PGC_S_DEFAULT, &Debug_print_query, false, NULL
+ { "debug_print_query", PGC_USERSET }, &Debug_print_query,
+ false, NULL, NULL
},
{
- "debug_print_parse", PGC_USERSET, PGC_S_DEFAULT, &Debug_print_parse, false, NULL
+ { "debug_print_parse", PGC_USERSET }, &Debug_print_parse,
+ false, NULL, NULL
},
{
- "debug_print_rewritten", PGC_USERSET, PGC_S_DEFAULT, &Debug_print_rewritten, false, NULL
+ { "debug_print_rewritten", PGC_USERSET }, &Debug_print_rewritten,
+ false, NULL, NULL
},
{
- "debug_print_plan", PGC_USERSET, PGC_S_DEFAULT, &Debug_print_plan, false, NULL
+ { "debug_print_plan", PGC_USERSET }, &Debug_print_plan,
+ false, NULL, NULL
},
{
- "debug_pretty_print", PGC_USERSET, PGC_S_DEFAULT, &Debug_pretty_print, false, NULL
+ { "debug_pretty_print", PGC_USERSET }, &Debug_pretty_print,
+ false, NULL, NULL
},
{
- "show_parser_stats", PGC_USERSET, PGC_S_DEFAULT, &Show_parser_stats, false, NULL
+ { "show_parser_stats", PGC_USERSET }, &Show_parser_stats,
+ false, NULL, NULL
},
{
- "show_planner_stats", PGC_USERSET, PGC_S_DEFAULT, &Show_planner_stats, false, NULL
+ { "show_planner_stats", PGC_USERSET }, &Show_planner_stats,
+ false, NULL, NULL
},
{
- "show_executor_stats", PGC_USERSET, PGC_S_DEFAULT, &Show_executor_stats, false, NULL
+ { "show_executor_stats", PGC_USERSET }, &Show_executor_stats,
+ false, NULL, NULL
},
{
- "show_query_stats", PGC_USERSET, PGC_S_DEFAULT, &Show_query_stats, false, NULL
+ { "show_query_stats", PGC_USERSET }, &Show_query_stats,
+ false, NULL, NULL
},
#ifdef BTREE_BUILD_STATS
{
- "show_btree_build_stats", PGC_SUSET, PGC_S_DEFAULT, &Show_btree_build_stats, false, NULL
+ { "show_btree_build_stats", PGC_SUSET }, &Show_btree_build_stats,
+ false, NULL, NULL
},
#endif
{
- "explain_pretty_print", PGC_USERSET, PGC_S_DEFAULT, &Explain_pretty_print, true, NULL
+ { "explain_pretty_print", PGC_USERSET }, &Explain_pretty_print,
+ true, NULL, NULL
},
{
- "stats_start_collector", PGC_POSTMASTER, PGC_S_DEFAULT, &pgstat_collect_startcollector, true, NULL
+ { "stats_start_collector", PGC_POSTMASTER }, &pgstat_collect_startcollector,
+ true, NULL, NULL
},
{
- "stats_reset_on_server_start", PGC_POSTMASTER, PGC_S_DEFAULT, &pgstat_collect_resetonpmstart, true, NULL
+ { "stats_reset_on_server_start", PGC_POSTMASTER }, &pgstat_collect_resetonpmstart,
+ true, NULL, NULL
},
{
- "stats_command_string", PGC_SUSET, PGC_S_DEFAULT, &pgstat_collect_querystring, false, NULL
+ { "stats_command_string", PGC_SUSET }, &pgstat_collect_querystring,
+ false, NULL, NULL
},
{
- "stats_row_level", PGC_SUSET, PGC_S_DEFAULT, &pgstat_collect_tuplelevel, false, NULL
+ { "stats_row_level", PGC_SUSET }, &pgstat_collect_tuplelevel,
+ false, NULL, NULL
},
{
- "stats_block_level", PGC_SUSET, PGC_S_DEFAULT, &pgstat_collect_blocklevel, false, NULL
+ { "stats_block_level", PGC_SUSET }, &pgstat_collect_blocklevel,
+ false, NULL, NULL
},
{
- "trace_notify", PGC_USERSET, PGC_S_DEFAULT, &Trace_notify, false, NULL
+ { "trace_notify", PGC_USERSET }, &Trace_notify,
+ false, NULL, NULL
},
#ifdef LOCK_DEBUG
{
- "trace_locks", PGC_SUSET, PGC_S_DEFAULT, &Trace_locks, false, NULL
+ { "trace_locks", PGC_SUSET }, &Trace_locks,
+ false, NULL, NULL
},
{
- "trace_userlocks", PGC_SUSET, PGC_S_DEFAULT, &Trace_userlocks, false, NULL
+ { "trace_userlocks", PGC_SUSET }, &Trace_userlocks,
+ false, NULL, NULL
},
{
- "trace_lwlocks", PGC_SUSET, PGC_S_DEFAULT, &Trace_lwlocks, false, NULL
+ { "trace_lwlocks", PGC_SUSET }, &Trace_lwlocks,
+ false, NULL, NULL
},
{
- "debug_deadlocks", PGC_SUSET, PGC_S_DEFAULT, &Debug_deadlocks, false, NULL
+ { "debug_deadlocks", PGC_SUSET }, &Debug_deadlocks,
+ false, NULL, NULL
},
#endif
{
- "hostname_lookup", PGC_SIGHUP, PGC_S_DEFAULT, &HostnameLookup, false, NULL
+ { "hostname_lookup", PGC_SIGHUP }, &HostnameLookup,
+ false, NULL, NULL
},
{
- "show_source_port", PGC_SIGHUP, PGC_S_DEFAULT, &ShowPortNumber, false, NULL
+ { "show_source_port", PGC_SIGHUP }, &ShowPortNumber,
+ false, NULL, NULL
},
{
- "sql_inheritance", PGC_USERSET, PGC_S_DEFAULT, &SQL_inheritance, true, NULL
+ { "sql_inheritance", PGC_USERSET }, &SQL_inheritance,
+ true, NULL, NULL
},
{
- "australian_timezones", PGC_USERSET, PGC_S_DEFAULT, &Australian_timezones, false, ClearDateCache
+ { "australian_timezones", PGC_USERSET }, &Australian_timezones,
+ false, ClearDateCache, NULL
},
{
- "fixbtree", PGC_POSTMASTER, PGC_S_DEFAULT, &FixBTree, true, NULL
+ { "fixbtree", PGC_POSTMASTER }, &FixBTree,
+ true, NULL, NULL
},
{
- "password_encryption", PGC_USERSET, PGC_S_DEFAULT, &Password_encryption, false, NULL
+ { "password_encryption", PGC_USERSET }, &Password_encryption,
+ false, NULL, NULL
},
{
- "transform_null_equals", PGC_USERSET, PGC_S_DEFAULT, &Transform_null_equals, false, NULL
+ { "transform_null_equals", PGC_USERSET }, &Transform_null_equals,
+ false, NULL, NULL
},
{
- NULL, 0, 0, NULL, false, NULL
+ { NULL, 0 }, NULL, false, NULL, NULL
}
};
ConfigureNamesInt[] =
{
{
- "geqo_threshold", PGC_USERSET, PGC_S_DEFAULT, &geqo_rels,
+ { "geqo_threshold", PGC_USERSET }, &geqo_rels,
DEFAULT_GEQO_RELS, 2, INT_MAX, NULL, NULL
},
{
- "geqo_pool_size", PGC_USERSET, PGC_S_DEFAULT, &Geqo_pool_size,
+ { "geqo_pool_size", PGC_USERSET }, &Geqo_pool_size,
DEFAULT_GEQO_POOL_SIZE, 0, MAX_GEQO_POOL_SIZE, NULL, NULL
},
{
- "geqo_effort", PGC_USERSET, PGC_S_DEFAULT, &Geqo_effort,
+ { "geqo_effort", PGC_USERSET }, &Geqo_effort,
1, 1, INT_MAX, NULL, NULL
},
{
- "geqo_generations", PGC_USERSET, PGC_S_DEFAULT, &Geqo_generations,
+ { "geqo_generations", PGC_USERSET }, &Geqo_generations,
0, 0, INT_MAX, NULL, NULL
},
{
- "geqo_random_seed", PGC_USERSET, PGC_S_DEFAULT, &Geqo_random_seed,
+ { "geqo_random_seed", PGC_USERSET }, &Geqo_random_seed,
-1, INT_MIN, INT_MAX, NULL, NULL
},
{
- "deadlock_timeout", PGC_POSTMASTER, PGC_S_DEFAULT, &DeadlockTimeout,
+ { "deadlock_timeout", PGC_POSTMASTER }, &DeadlockTimeout,
1000, 0, INT_MAX, NULL, NULL
},
#ifdef HAVE_SYSLOG
{
- "syslog", PGC_SIGHUP, PGC_S_DEFAULT, &Use_syslog,
+ { "syslog", PGC_SIGHUP }, &Use_syslog,
0, 0, 2, NULL, NULL
},
#endif
* constraints here are partially unused.
*/
{
- "max_connections", PGC_POSTMASTER, PGC_S_DEFAULT, &MaxBackends,
+ { "max_connections", PGC_POSTMASTER }, &MaxBackends,
DEF_MAXBACKENDS, 1, INT_MAX, NULL, NULL
},
{
- "shared_buffers", PGC_POSTMASTER, PGC_S_DEFAULT, &NBuffers,
+ { "shared_buffers", PGC_POSTMASTER }, &NBuffers,
DEF_NBUFFERS, 16, INT_MAX, NULL, NULL
},
{
- "port", PGC_POSTMASTER, PGC_S_DEFAULT, &PostPortNumber,
+ { "port", PGC_POSTMASTER }, &PostPortNumber,
DEF_PGPORT, 1, 65535, NULL, NULL
},
{
- "unix_socket_permissions", PGC_POSTMASTER, PGC_S_DEFAULT, &Unix_socket_permissions,
+ { "unix_socket_permissions", PGC_POSTMASTER }, &Unix_socket_permissions,
0777, 0000, 0777, NULL, NULL
},
{
- "sort_mem", PGC_USERSET, PGC_S_DEFAULT, &SortMem,
+ { "sort_mem", PGC_USERSET }, &SortMem,
512, 4 * BLCKSZ / 1024, INT_MAX, NULL, NULL
},
{
- "vacuum_mem", PGC_USERSET, PGC_S_DEFAULT, &VacuumMem,
+ { "vacuum_mem", PGC_USERSET }, &VacuumMem,
8192, 1024, INT_MAX, NULL, NULL
},
{
- "max_files_per_process", PGC_BACKEND, PGC_S_DEFAULT, &max_files_per_process,
+ { "max_files_per_process", PGC_BACKEND }, &max_files_per_process,
1000, 25, INT_MAX, NULL, NULL
},
#ifdef LOCK_DEBUG
{
- "trace_lock_oidmin", PGC_SUSET, PGC_S_DEFAULT, &Trace_lock_oidmin,
+ { "trace_lock_oidmin", PGC_SUSET }, &Trace_lock_oidmin,
BootstrapObjectIdData, 1, INT_MAX, NULL, NULL
},
{
- "trace_lock_table", PGC_SUSET, PGC_S_DEFAULT, &Trace_lock_table,
+ { "trace_lock_table", PGC_SUSET }, &Trace_lock_table,
0, 0, INT_MAX, NULL, NULL
},
#endif
{
- "max_expr_depth", PGC_USERSET, PGC_S_DEFAULT, &max_expr_depth,
+ { "max_expr_depth", PGC_USERSET }, &max_expr_depth,
DEFAULT_MAX_EXPR_DEPTH, 10, INT_MAX, NULL, NULL
},
{
- "max_fsm_relations", PGC_POSTMASTER, PGC_S_DEFAULT, &MaxFSMRelations,
+ { "max_fsm_relations", PGC_POSTMASTER }, &MaxFSMRelations,
100, 10, INT_MAX, NULL, NULL
},
{
- "max_fsm_pages", PGC_POSTMASTER, PGC_S_DEFAULT, &MaxFSMPages,
+ { "max_fsm_pages", PGC_POSTMASTER }, &MaxFSMPages,
10000, 1000, INT_MAX, NULL, NULL
},
{
- "max_locks_per_transaction", PGC_POSTMASTER, PGC_S_DEFAULT, &max_locks_per_xact,
+ { "max_locks_per_transaction", PGC_POSTMASTER }, &max_locks_per_xact,
64, 10, INT_MAX, NULL, NULL
},
{
- "authentication_timeout", PGC_SIGHUP, PGC_S_DEFAULT, &AuthenticationTimeout,
+ { "authentication_timeout", PGC_SIGHUP }, &AuthenticationTimeout,
60, 1, 600, NULL, NULL
},
{
- "pre_auth_delay", PGC_SIGHUP, PGC_S_DEFAULT, &PreAuthDelay,
+ { "pre_auth_delay", PGC_SIGHUP }, &PreAuthDelay,
0, 0, 60, NULL, NULL
},
{
- "checkpoint_segments", PGC_SIGHUP, PGC_S_DEFAULT, &CheckPointSegments,
+ { "checkpoint_segments", PGC_SIGHUP }, &CheckPointSegments,
3, 1, INT_MAX, NULL, NULL
},
{
- "checkpoint_timeout", PGC_SIGHUP, PGC_S_DEFAULT, &CheckPointTimeout,
+ { "checkpoint_timeout", PGC_SIGHUP }, &CheckPointTimeout,
300, 30, 3600, NULL, NULL
},
{
- "wal_buffers", PGC_POSTMASTER, PGC_S_DEFAULT, &XLOGbuffers,
+ { "wal_buffers", PGC_POSTMASTER }, &XLOGbuffers,
8, 4, INT_MAX, NULL, NULL
},
{
- "wal_files", PGC_SIGHUP, PGC_S_DEFAULT, &XLOGfiles,
+ { "wal_files", PGC_SIGHUP }, &XLOGfiles,
0, 0, 64, NULL, NULL
},
{
- "wal_debug", PGC_SUSET, PGC_S_DEFAULT, &XLOG_DEBUG,
+ { "wal_debug", PGC_SUSET }, &XLOG_DEBUG,
0, 0, 16, NULL, NULL
},
{
- "commit_delay", PGC_USERSET, PGC_S_DEFAULT, &CommitDelay,
+ { "commit_delay", PGC_USERSET }, &CommitDelay,
0, 0, 100000, NULL, NULL
},
{
- "commit_siblings", PGC_USERSET, PGC_S_DEFAULT, &CommitSiblings,
+ { "commit_siblings", PGC_USERSET }, &CommitSiblings,
5, 1, 1000, NULL, NULL
},
{
- NULL, 0, 0, NULL, 0, 0, 0, NULL, NULL
+ { NULL, 0 }, NULL, 0, 0, 0, NULL, NULL
}
};
ConfigureNamesReal[] =
{
{
- "effective_cache_size", PGC_USERSET, PGC_S_DEFAULT, &effective_cache_size,
+ { "effective_cache_size", PGC_USERSET }, &effective_cache_size,
DEFAULT_EFFECTIVE_CACHE_SIZE, 0, DBL_MAX, NULL, NULL
},
{
- "random_page_cost", PGC_USERSET, PGC_S_DEFAULT, &random_page_cost,
+ { "random_page_cost", PGC_USERSET }, &random_page_cost,
DEFAULT_RANDOM_PAGE_COST, 0, DBL_MAX, NULL, NULL
},
{
- "cpu_tuple_cost", PGC_USERSET, PGC_S_DEFAULT, &cpu_tuple_cost,
+ { "cpu_tuple_cost", PGC_USERSET }, &cpu_tuple_cost,
DEFAULT_CPU_TUPLE_COST, 0, DBL_MAX, NULL, NULL
},
{
- "cpu_index_tuple_cost", PGC_USERSET, PGC_S_DEFAULT, &cpu_index_tuple_cost,
+ { "cpu_index_tuple_cost", PGC_USERSET }, &cpu_index_tuple_cost,
DEFAULT_CPU_INDEX_TUPLE_COST, 0, DBL_MAX, NULL, NULL
},
{
- "cpu_operator_cost", PGC_USERSET, PGC_S_DEFAULT, &cpu_operator_cost,
+ { "cpu_operator_cost", PGC_USERSET }, &cpu_operator_cost,
DEFAULT_CPU_OPERATOR_COST, 0, DBL_MAX, NULL, NULL
},
{
- "geqo_selection_bias", PGC_USERSET, PGC_S_DEFAULT, &Geqo_selection_bias,
+ { "geqo_selection_bias", PGC_USERSET }, &Geqo_selection_bias,
DEFAULT_GEQO_SELECTION_BIAS, MIN_GEQO_SELECTION_BIAS,
MAX_GEQO_SELECTION_BIAS, NULL, NULL
},
{
- NULL, 0, 0, NULL, 0.0, 0.0, 0.0, NULL, NULL
+ { "seed", PGC_USERSET, GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL },
+ &phony_random_seed,
+ 0.5, 0.0, 1.0, assign_random_seed, show_random_seed
+ },
+
+ {
+ { NULL, 0 }, NULL, 0.0, 0.0, 0.0, NULL, NULL
}
};
ConfigureNamesString[] =
{
{
- "client_min_messages", PGC_USERSET, PGC_S_DEFAULT, &client_min_messages_str,
- client_min_messages_str_default, check_client_min_messages,
- assign_client_min_messages
+ { "client_encoding", PGC_USERSET }, &client_encoding_string,
+ "SQL_ASCII", assign_client_encoding, NULL
},
{
- "default_transaction_isolation", PGC_USERSET, PGC_S_DEFAULT, &default_iso_level_string,
- "read committed", check_defaultxactisolevel, assign_defaultxactisolevel
+ { "client_min_messages", PGC_USERSET }, &client_min_messages_str,
+ client_min_messages_str_default, assign_client_min_messages, NULL
},
{
- "dynamic_library_path", PGC_SUSET, PGC_S_DEFAULT, &Dynamic_library_path,
- "$libdir", NULL, NULL
+ { "DateStyle", PGC_USERSET, GUC_LIST_INPUT }, &datestyle_string,
+ "ISO, US", assign_datestyle, show_datestyle
},
{
- "search_path", PGC_USERSET, PGC_S_DEFAULT, &namespace_search_path,
- "$user,public", check_search_path, assign_search_path
+ { "default_transaction_isolation", PGC_USERSET }, &default_iso_level_string,
+ "read committed", assign_defaultxactisolevel, NULL
},
{
- "krb_server_keyfile", PGC_POSTMASTER, PGC_S_DEFAULT, &pg_krb_server_keyfile,
+ { "dynamic_library_path", PGC_SUSET }, &Dynamic_library_path,
+ "$libdir", NULL, NULL
+ },
+
+ {
+ { "krb_server_keyfile", PGC_POSTMASTER }, &pg_krb_server_keyfile,
PG_KRB_SRVTAB, NULL, NULL
},
{
- "lc_messages", PGC_SUSET, PGC_S_DEFAULT, &locale_messages,
- "", locale_messages_check, locale_messages_assign
+ { "lc_messages", PGC_SUSET }, &locale_messages,
+ "", locale_messages_assign, NULL
+ },
+
+ {
+ { "lc_monetary", PGC_USERSET }, &locale_monetary,
+ "", locale_monetary_assign, NULL
+ },
+
+ {
+ { "lc_numeric", PGC_USERSET }, &locale_numeric,
+ "", locale_numeric_assign, NULL
+ },
+
+ {
+ { "lc_time", PGC_USERSET }, &locale_time,
+ "", locale_time_assign, NULL
},
{
- "lc_monetary", PGC_USERSET, PGC_S_DEFAULT, &locale_monetary,
- "", locale_monetary_check, locale_monetary_assign
+ { "search_path", PGC_USERSET, GUC_LIST_INPUT | GUC_LIST_QUOTE },
+ &namespace_search_path,
+ "$user,public", assign_search_path, NULL
},
{
- "lc_numeric", PGC_USERSET, PGC_S_DEFAULT, &locale_numeric,
- "", locale_numeric_check, locale_numeric_assign
+ { "server_encoding", PGC_USERSET }, &server_encoding_string,
+ "SQL_ASCII", assign_server_encoding, show_server_encoding
},
{
- "lc_time", PGC_USERSET, PGC_S_DEFAULT, &locale_time,
- "", locale_time_check, locale_time_assign
+ { "server_min_messages", PGC_USERSET }, &server_min_messages_str,
+ server_min_messages_str_default, assign_server_min_messages, NULL
},
{
- "server_min_messages", PGC_USERSET, PGC_S_DEFAULT, &server_min_messages_str,
- server_min_messages_str_default, check_server_min_messages,
- assign_server_min_messages
+ { "session_authorization", PGC_USERSET, GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL },
+ &session_authorization_string,
+ NULL, assign_session_authorization, show_session_authorization
},
#ifdef HAVE_SYSLOG
{
- "syslog_facility", PGC_POSTMASTER, PGC_S_DEFAULT, &Syslog_facility,
- "LOCAL0", check_facility, NULL
+ { "syslog_facility", PGC_POSTMASTER }, &Syslog_facility,
+ "LOCAL0", assign_facility, NULL
},
{
- "syslog_ident", PGC_POSTMASTER, PGC_S_DEFAULT, &Syslog_ident,
+ { "syslog_ident", PGC_POSTMASTER }, &Syslog_ident,
"postgres", NULL, NULL
},
#endif
{
- "unix_socket_group", PGC_POSTMASTER, PGC_S_DEFAULT, &Unix_socket_group,
+ { "TimeZone", PGC_USERSET }, &timezone_string,
+ "UNKNOWN", assign_timezone, show_timezone
+ },
+
+ {
+ { "TRANSACTION ISOLATION LEVEL", PGC_USERSET, GUC_NO_RESET_ALL },
+ &XactIsoLevel_string,
+ NULL, assign_XactIsoLevel, show_XactIsoLevel
+ },
+
+ {
+ { "unix_socket_group", PGC_POSTMASTER }, &Unix_socket_group,
"", NULL, NULL
},
{
- "unix_socket_directory", PGC_POSTMASTER, PGC_S_DEFAULT, &UnixSocketDir,
+ { "unix_socket_directory", PGC_POSTMASTER }, &UnixSocketDir,
"", NULL, NULL
},
{
- "virtual_host", PGC_POSTMASTER, PGC_S_DEFAULT, &VirtualHost,
+ { "virtual_host", PGC_POSTMASTER }, &VirtualHost,
"", NULL, NULL
},
{
- "wal_sync_method", PGC_SIGHUP, PGC_S_DEFAULT, &XLOG_sync_method,
- XLOG_sync_method_default, check_xlog_sync_method,
- assign_xlog_sync_method
+ { "wal_sync_method", PGC_SIGHUP }, &XLOG_sync_method,
+ XLOG_sync_method_default, assign_xlog_sync_method, NULL
},
{
- NULL, 0, 0, NULL, NULL, NULL, NULL
+ { NULL, 0 }, NULL, NULL, NULL, NULL
}
};
/******** end of options list ********/
-
/*
- * Look up option NAME. If it exists, return it's data type, else
- * PGC_NONE (zero). If record is not NULL, store the description of
- * the option there.
+ * Actual lookup of variables is done through this single, sorted array.
*/
-static enum config_type
-find_option(const char *name, struct config_generic ** record)
-{
- int i;
-
- Assert(name);
+static struct config_generic **guc_variables;
+static int num_guc_variables;
- for (i = 0; ConfigureNamesBool[i].name; i++)
- if (strcasecmp(ConfigureNamesBool[i].name, name) == 0)
- {
- if (record)
- *record = (struct config_generic *) & ConfigureNamesBool[i];
- return PGC_BOOL;
- }
-
- for (i = 0; ConfigureNamesInt[i].name; i++)
- if (strcasecmp(ConfigureNamesInt[i].name, name) == 0)
- {
- if (record)
- *record = (struct config_generic *) & ConfigureNamesInt[i];
- return PGC_INT;
- }
-
- for (i = 0; ConfigureNamesReal[i].name; i++)
- if (strcasecmp(ConfigureNamesReal[i].name, name) == 0)
- {
- if (record)
- *record = (struct config_generic *) & ConfigureNamesReal[i];
- return PGC_REAL;
- }
+static bool guc_dirty; /* TRUE if need to do commit/abort work */
- for (i = 0; ConfigureNamesString[i].name; i++)
- if (strcasecmp(ConfigureNamesString[i].name, name) == 0)
- {
- if (record)
- *record = (struct config_generic *) & ConfigureNamesString[i];
- return PGC_STRING;
- }
+static char *guc_string_workspace; /* for avoiding memory leaks */
- return PGC_NONE;
-}
+static int guc_var_compare(const void *a, const void *b);
+static void _ShowOption(struct config_generic *record);
/*
- * Reset all options to their specified default values. Must be called
- * with isStartup = true at program startup. May be called later with
- * isStartup = false to reset all resettable options.
+ * Build the sorted array. This is split out so that it could be
+ * re-executed after startup (eg, we could allow loadable modules to
+ * add vars, and then we'd need to re-sort).
*/
-void
-ResetAllOptions(bool isStartup)
+static void
+build_guc_variables(void)
{
+ int num_vars = 0;
+ struct config_generic **guc_vars;
int i;
- for (i = 0; ConfigureNamesBool[i].name; i++)
+ for (i = 0; ConfigureNamesBool[i].gen.name; i++)
{
struct config_bool *conf = &ConfigureNamesBool[i];
- if (isStartup ||
- conf->context == PGC_SUSET || conf->context == PGC_USERSET)
- {
- if (conf->assign_hook)
- (conf->assign_hook) (conf->default_val);
- *conf->variable = conf->default_val;
- }
+ /* Rather than requiring vartype to be filled in by hand, do this: */
+ conf->gen.vartype = PGC_BOOL;
+ num_vars++;
}
- for (i = 0; ConfigureNamesInt[i].name; i++)
+ for (i = 0; ConfigureNamesInt[i].gen.name; i++)
{
struct config_int *conf = &ConfigureNamesInt[i];
- if (isStartup ||
- conf->context == PGC_SUSET || conf->context == PGC_USERSET)
- {
- if (conf->assign_hook)
- (conf->assign_hook) (conf->default_val);
- *conf->variable = conf->default_val;
- }
+ conf->gen.vartype = PGC_INT;
+ num_vars++;
}
- for (i = 0; ConfigureNamesReal[i].name; i++)
+ for (i = 0; ConfigureNamesReal[i].gen.name; i++)
{
struct config_real *conf = &ConfigureNamesReal[i];
- if (isStartup ||
- conf->context == PGC_SUSET || conf->context == PGC_USERSET)
- {
- if (conf->assign_hook)
- (conf->assign_hook) (conf->default_val);
- *conf->variable = conf->default_val;
- }
+ conf->gen.vartype = PGC_REAL;
+ num_vars++;
}
- for (i = 0; ConfigureNamesString[i].name; i++)
+ for (i = 0; ConfigureNamesString[i].gen.name; i++)
{
struct config_string *conf = &ConfigureNamesString[i];
- if (isStartup ||
- conf->context == PGC_SUSET || conf->context == PGC_USERSET)
- {
- char *str = NULL;
-
- if (conf->default_val == NULL &&
- conf->boot_default_val)
- {
- str = strdup(conf->boot_default_val);
- if (str == NULL)
- elog(ERROR, "out of memory");
- conf->default_val = str;
- }
- if (conf->default_val)
- {
- str = strdup(conf->default_val);
- if (str == NULL)
- elog(ERROR, "out of memory");
- }
- if (conf->assign_hook)
- (conf->assign_hook) (str);
- if (*conf->variable)
- free(*conf->variable);
- *conf->variable = str;
- }
+ conf->gen.vartype = PGC_STRING;
+ num_vars++;
}
-}
+ guc_vars = (struct config_generic **)
+ malloc(num_vars * sizeof(struct config_generic *));
+ if (!guc_vars)
+ elog(PANIC, "out of memory");
+ num_vars = 0;
-/*
- * Try to interpret value as boolean value. Valid values are: true,
- * false, yes, no, on, off, 1, 0. If the string parses okay, return
- * true, else false. If result is not NULL, return the parsing result
- * there.
- */
-static bool
-parse_bool(const char *value, bool *result)
-{
- size_t len = strlen(value);
+ for (i = 0; ConfigureNamesBool[i].gen.name; i++)
+ guc_vars[num_vars++] = & ConfigureNamesBool[i].gen;
- if (strncasecmp(value, "true", len) == 0)
- {
- if (result)
- *result = true;
- }
- else if (strncasecmp(value, "false", len) == 0)
- {
- if (result)
- *result = false;
- }
+ for (i = 0; ConfigureNamesInt[i].gen.name; i++)
+ guc_vars[num_vars++] = & ConfigureNamesInt[i].gen;
- else if (strncasecmp(value, "yes", len) == 0)
- {
- if (result)
- *result = true;
- }
- else if (strncasecmp(value, "no", len) == 0)
- {
- if (result)
- *result = false;
- }
+ for (i = 0; ConfigureNamesReal[i].gen.name; i++)
+ guc_vars[num_vars++] = & ConfigureNamesReal[i].gen;
- else if (strcasecmp(value, "on") == 0)
- {
- if (result)
- *result = true;
- }
- else if (strcasecmp(value, "off") == 0)
- {
- if (result)
- *result = false;
- }
+ for (i = 0; ConfigureNamesString[i].gen.name; i++)
+ guc_vars[num_vars++] = & ConfigureNamesString[i].gen;
- else if (strcasecmp(value, "1") == 0)
- {
- if (result)
- *result = true;
- }
- else if (strcasecmp(value, "0") == 0)
- {
- if (result)
- *result = false;
- }
+ qsort((void *) guc_vars, num_vars, sizeof(struct config_generic *),
+ guc_var_compare);
- else
- return false;
- return true;
+ if (guc_variables)
+ free(guc_variables);
+ guc_variables = guc_vars;
+ num_guc_variables = num_vars;
}
-
/*
- * Try to parse value as an integer. The accepted formats are the
- * usual decimal, octal, or hexadecimal formats. If the string parses
- * okay, return true, else false. If result is not NULL, return the
- * value there.
+ * Look up option NAME. If it exists, return a pointer to its record,
+ * else return NULL.
*/
-static bool
-parse_int(const char *value, int *result)
+static struct config_generic *
+find_option(const char *name)
{
- long val;
- char *endptr;
+ const char **key = &name;
+ struct config_generic **res;
- errno = 0;
- val = strtol(value, &endptr, 0);
- if (endptr == value || *endptr != '\0' || errno == ERANGE
-#ifdef HAVE_LONG_INT_64
- /* if long > 32 bits, check for overflow of int4 */
- || val != (long) ((int32) val)
-#endif
- )
- return false;
- if (result)
- *result = (int) val;
- return true;
-}
+ Assert(name);
+ /*
+ * by equating const char ** with struct config_generic *, we are
+ * assuming the name field is first in config_generic.
+ */
+ res = (struct config_generic**) bsearch((void *) &key,
+ (void *) guc_variables,
+ num_guc_variables,
+ sizeof(struct config_generic *),
+ guc_var_compare);
+ if (res)
+ return *res;
+ return NULL;
+}
/*
- * Try to parse value as a floating point constant in the usual
- * format. If the value parsed okay return true, else false. If
- * result is not NULL, return the semantic value there.
+ * comparator for qsorting and bsearching guc_variables array
*/
-static bool
-parse_real(const char *value, double *result)
+static int
+guc_var_compare(const void *a, const void *b)
{
- double val;
- char *endptr;
+ struct config_generic *confa = *(struct config_generic **) a;
+ struct config_generic *confb = *(struct config_generic **) b;
+ char namea[NAMEDATALEN];
+ char nameb[NAMEDATALEN];
+ int len,
+ i;
- errno = 0;
- val = strtod(value, &endptr);
- if (endptr == value || *endptr != '\0' || errno == ERANGE)
- return false;
- if (result)
- *result = val;
- return true;
-}
+ /*
+ * The temptation to use strcasecmp() here must be resisted, because
+ * the array ordering has to remain stable across setlocale() calls.
+ * So, apply an ASCII-only downcasing to both names and use strcmp().
+ */
+ len = strlen(confa->name);
+ if (len >= NAMEDATALEN)
+ len = NAMEDATALEN-1;
+ for (i = 0; i < len; i++)
+ {
+ char ch = confa->name[i];
+
+ if (ch >= 'A' && ch <= 'Z')
+ ch += 'a' - 'A';
+ namea[i] = ch;
+ }
+ namea[len] = '\0';
+
+ len = strlen(confb->name);
+ if (len >= NAMEDATALEN)
+ len = NAMEDATALEN-1;
+ for (i = 0; i < len; i++)
+ {
+ char ch = confb->name[i];
+
+ if (ch >= 'A' && ch <= 'Z')
+ ch += 'a' - 'A';
+ nameb[i] = ch;
+ }
+ nameb[len] = '\0';
+ return strcmp(namea, nameb);
+}
/*
- * Sets option `name' to given value. The value should be a string
- * which is going to be parsed and converted to the appropriate data
- * type. Parameter context should indicate in which context this
- * function is being called so it can apply the access restrictions
- * properly.
- *
- * If value is NULL, set the option to its default value. If the
- * parameter DoIt is false then don't really set the option but do all
- * the checks to see if it would work.
- *
- * If there is an error (non-existing option, invalid value) then an
- * elog(ERROR) is thrown *unless* this is called as part of the
- * configuration file re-read in the SIGHUP handler, in which case we
- * simply write the error message via elog(DEBUG) and return false. In
- * all other cases the function returns true. This is working around
- * the deficiencies in the elog mechanism, so don't blame me.
- *
- * See also SetConfigOption for an external interface.
+ * Initialize GUC options during program startup.
*/
-bool
-set_config_option(const char *name, const char *value,
- GucContext context, bool DoIt, GucSource source)
+void
+InitializeGUCOptions(void)
{
- struct config_generic *record;
- enum config_type type;
- int elevel;
- bool makeDefault;
-
- if (context == PGC_SIGHUP || source == PGC_S_DEFAULT)
- elevel = DEBUG1;
- else if (guc_session_init)
- elevel = INFO;
- else
- elevel = ERROR;
-
- type = find_option(name, &record);
- if (type == PGC_NONE)
- {
- elog(elevel, "'%s' is not a valid option name", name);
- return false;
- }
+ int i;
+ char *env;
- if (record->source > source)
- {
- elog(DEBUG2, "setting %s refused because previous source is higher",
- name);
- return false;
- }
- makeDefault = source < PGC_S_SESSION;
+ /*
+ * Build sorted array of all GUC variables.
+ */
+ build_guc_variables();
/*
- * Check if the option can be set at this time. See guc.h for the
- * precise rules. Note that we don't want to throw errors if we're in
- * the SIGHUP context. In that case we just ignore the attempt.
+ * Load all variables with their compiled-in defaults, and initialize
+ * status fields as needed.
+ *
+ * Note: any errors here are reported with plain ol' printf, since we
+ * shouldn't assume that elog will work before we've initialized its
+ * config variables. An error here would be unexpected anyway...
*/
- switch (record->context)
+ for (i = 0; i < num_guc_variables; i++)
{
- case PGC_POSTMASTER:
- if (context == PGC_SIGHUP)
- return true;
- if (context != PGC_POSTMASTER)
- elog(ERROR, "'%s' cannot be changed after server start", name);
- break;
- case PGC_SIGHUP:
- if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
- elog(ERROR, "'%s' cannot be changed now", name);
+ struct config_generic *gconf = guc_variables[i];
- /*
- * Hmm, the idea of the SIGHUP context is "ought to be global,
- * but can be changed after postmaster start". But there's
- * nothing that prevents a crafty administrator from sending
- * SIGHUP signals to individual backends only.
- */
- break;
- case PGC_BACKEND:
- if (context == PGC_SIGHUP)
+ gconf->status = 0;
+ gconf->reset_source = PGC_S_DEFAULT;
+ gconf->session_source = PGC_S_DEFAULT;
+ gconf->tentative_source = PGC_S_DEFAULT;
+ gconf->source = PGC_S_DEFAULT;
+
+ switch (gconf->vartype)
+ {
+ case PGC_BOOL:
{
- /*
- * If a PGC_BACKEND parameter is changed in the config
- * file, we want to accept the new value in the postmaster
- * (whence it will propagate to subsequently-started
- * backends), but ignore it in existing backends. This is
- * a tad klugy, but necessary because we don't re-read the
- * config file during backend start.
- */
- if (IsUnderPostmaster)
- return true;
+ struct config_bool *conf = (struct config_bool *) gconf;
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->reset_val, true, false))
+ fprintf(stderr, "Failed to initialize %s",
+ conf->gen.name);
+ *conf->variable = conf->reset_val;
+ conf->session_val = conf->reset_val;
+ break;
+ }
+ case PGC_INT:
+ {
+ struct config_int *conf = (struct config_int *) gconf;
+
+ Assert(conf->reset_val >= conf->min);
+ Assert(conf->reset_val <= conf->max);
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->reset_val, true, false))
+ fprintf(stderr, "Failed to initialize %s",
+ conf->gen.name);
+ *conf->variable = conf->reset_val;
+ conf->session_val = conf->reset_val;
+ break;
+ }
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
+
+ Assert(conf->reset_val >= conf->min);
+ Assert(conf->reset_val <= conf->max);
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->reset_val, true, false))
+ fprintf(stderr, "Failed to initialize %s",
+ conf->gen.name);
+ *conf->variable = conf->reset_val;
+ conf->session_val = conf->reset_val;
+ break;
+ }
+ case PGC_STRING:
+ {
+ struct config_string *conf = (struct config_string *) gconf;
+ char *str;
+
+ *conf->variable = NULL;
+ conf->reset_val = NULL;
+ conf->session_val = NULL;
+ conf->tentative_val = NULL;
+
+ if (conf->boot_val == NULL)
+ {
+ /* Cannot set value yet */
+ break;
+ }
+
+ str = strdup(conf->boot_val);
+ if (str == NULL)
+ elog(PANIC, "out of memory");
+ conf->reset_val = str;
+
+ if (conf->assign_hook)
+ {
+ const char *newstr;
+
+ newstr = (*conf->assign_hook) (str, true, false);
+ if (newstr == NULL)
+ {
+ fprintf(stderr, "Failed to initialize %s",
+ conf->gen.name);
+ }
+ else if (newstr != str)
+ {
+ free(str);
+ /* See notes in set_config_option about casting */
+ str = (char *) newstr;
+ conf->reset_val = str;
+ }
+ }
+ *conf->variable = str;
+ conf->session_val = str;
+ break;
+ }
+ }
+ }
+
+ guc_dirty = false;
+
+ guc_string_workspace = NULL;
+
+ /*
+ * Prevent any attempt to override TRANSACTION ISOLATION LEVEL from
+ * non-interactive sources.
+ */
+ SetConfigOption("TRANSACTION ISOLATION LEVEL", "default",
+ PGC_POSTMASTER, PGC_S_OVERRIDE);
+
+ /*
+ * For historical reasons, some GUC parameters can receive defaults
+ * from environment variables. Process those settings.
+ */
+
+ env = getenv("PGPORT");
+ if (env != NULL)
+ SetConfigOption("port", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
+
+ env = getenv("PGDATESTYLE");
+ if (env != NULL)
+ SetConfigOption("datestyle", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
+
+ env = getenv("TZ");
+ if (env != NULL)
+ SetConfigOption("timezone", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
+
+#ifdef MULTIBYTE
+ env = getenv("PGCLIENTENCODING");
+ if (env != NULL)
+ SetConfigOption("client_encoding", env, PGC_POSTMASTER, PGC_S_ENV_VAR);
+#endif
+}
+
+
+/*
+ * Reset all options to their saved default values (implements RESET ALL)
+ */
+void
+ResetAllOptions(void)
+{
+ int i;
+
+ for (i = 0; i < num_guc_variables; i++)
+ {
+ struct config_generic *gconf = guc_variables[i];
+
+ /* Don't reset non-SET-able values */
+ if (gconf->context != PGC_SUSET && gconf->context != PGC_USERSET)
+ continue;
+ /* Don't reset if special exclusion from RESET ALL */
+ if (gconf->flags & GUC_NO_RESET_ALL)
+ continue;
+ /* No need to reset if wasn't SET */
+ if (gconf->source <= PGC_S_OVERRIDE)
+ continue;
+
+ switch (gconf->vartype)
+ {
+ case PGC_BOOL:
+ {
+ struct config_bool *conf = (struct config_bool *) gconf;
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->reset_val, true, true))
+ elog(ERROR, "Failed to reset %s", conf->gen.name);
+ *conf->variable = conf->reset_val;
+ conf->tentative_val = conf->reset_val;
+ conf->gen.source = conf->gen.reset_source;
+ conf->gen.tentative_source = conf->gen.reset_source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
+ break;
+ }
+ case PGC_INT:
+ {
+ struct config_int *conf = (struct config_int *) gconf;
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->reset_val, true, true))
+ elog(ERROR, "Failed to reset %s", conf->gen.name);
+ *conf->variable = conf->reset_val;
+ conf->tentative_val = conf->reset_val;
+ conf->gen.source = conf->gen.reset_source;
+ conf->gen.tentative_source = conf->gen.reset_source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
+ break;
+ }
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->reset_val, true, true))
+ elog(ERROR, "Failed to reset %s", conf->gen.name);
+ *conf->variable = conf->reset_val;
+ conf->tentative_val = conf->reset_val;
+ conf->gen.source = conf->gen.reset_source;
+ conf->gen.tentative_source = conf->gen.reset_source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
+ break;
+ }
+ case PGC_STRING:
+ {
+ struct config_string *conf = (struct config_string *) gconf;
+ char *str;
+
+ if (conf->reset_val == NULL)
+ {
+ /* Nothing to reset to, as yet; so do nothing */
+ break;
+ }
+
+ str = strdup(conf->reset_val);
+ if (str == NULL)
+ elog(ERROR, "out of memory");
+
+ /*
+ * Remember string in workspace, so that we can free it
+ * and avoid a permanent memory leak if hook elogs.
+ */
+ if (guc_string_workspace)
+ free(guc_string_workspace);
+ guc_string_workspace = str;
+
+ if (conf->assign_hook)
+ {
+ const char *newstr;
+
+ newstr = (*conf->assign_hook) (str, true, true);
+ if (newstr == NULL)
+ elog(ERROR, "Failed to reset %s", conf->gen.name);
+ else if (newstr != str)
+ {
+ free(str);
+ /* See notes in set_config_option about casting */
+ str = (char *) newstr;
+ }
+ }
+
+ guc_string_workspace = NULL;
+
+ SET_STRING_VARIABLE(conf, str);
+ SET_STRING_TENTATIVE_VAL(conf, str);
+ conf->gen.source = conf->gen.reset_source;
+ conf->gen.tentative_source = conf->gen.reset_source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
+ break;
+ }
+ }
+ }
+}
+
+
+/*
+ * Do GUC processing at transaction commit or abort.
+ */
+void
+AtEOXact_GUC(bool isCommit)
+{
+ int i;
+
+ /* Quick exit if nothing's changed in this transaction */
+ if (!guc_dirty)
+ return;
+
+ /* Prevent memory leak if elog during an assign_hook */
+ if (guc_string_workspace)
+ {
+ free(guc_string_workspace);
+ guc_string_workspace = NULL;
+ }
+
+ for (i = 0; i < num_guc_variables; i++)
+ {
+ struct config_generic *gconf = guc_variables[i];
+
+ /* Skip if nothing's happened to this var in this transaction */
+ if (gconf->status == 0)
+ continue;
+
+ switch (gconf->vartype)
+ {
+ case PGC_BOOL:
+ {
+ struct config_bool *conf = (struct config_bool *) gconf;
+
+ if (isCommit && (conf->gen.status & GUC_HAVE_TENTATIVE))
+ {
+ conf->session_val = conf->tentative_val;
+ conf->gen.session_source = conf->gen.tentative_source;
+ }
+
+ if (*conf->variable != conf->session_val)
+ {
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->session_val,
+ true, false))
+ elog(LOG, "Failed to commit %s", conf->gen.name);
+ *conf->variable = conf->session_val;
+ }
+ conf->gen.source = conf->gen.session_source;
+ conf->gen.status = 0;
+ break;
+ }
+ case PGC_INT:
+ {
+ struct config_int *conf = (struct config_int *) gconf;
+
+ if (isCommit && (conf->gen.status & GUC_HAVE_TENTATIVE))
+ {
+ conf->session_val = conf->tentative_val;
+ conf->gen.session_source = conf->gen.tentative_source;
+ }
+
+ if (*conf->variable != conf->session_val)
+ {
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->session_val,
+ true, false))
+ elog(LOG, "Failed to commit %s", conf->gen.name);
+ *conf->variable = conf->session_val;
+ }
+ conf->gen.source = conf->gen.session_source;
+ conf->gen.status = 0;
+ break;
+ }
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
+
+ if (isCommit && (conf->gen.status & GUC_HAVE_TENTATIVE))
+ {
+ conf->session_val = conf->tentative_val;
+ conf->gen.session_source = conf->gen.tentative_source;
+ }
+
+ if (*conf->variable != conf->session_val)
+ {
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->session_val,
+ true, false))
+ elog(LOG, "Failed to commit %s", conf->gen.name);
+ *conf->variable = conf->session_val;
+ }
+ conf->gen.source = conf->gen.session_source;
+ conf->gen.status = 0;
+ break;
+ }
+ case PGC_STRING:
+ {
+ struct config_string *conf = (struct config_string *) gconf;
+
+ if (isCommit && (conf->gen.status & GUC_HAVE_TENTATIVE))
+ {
+ SET_STRING_SESSION_VAL(conf, conf->tentative_val);
+ conf->gen.session_source = conf->gen.tentative_source;
+ conf->tentative_val = NULL; /* transfer ownership */
+ }
+ else
+ {
+ SET_STRING_TENTATIVE_VAL(conf, NULL);
+ }
+
+ if (*conf->variable != conf->session_val)
+ {
+ char *str = conf->session_val;
+
+ if (conf->assign_hook)
+ {
+ const char *newstr;
+
+ newstr = (*conf->assign_hook) (str, true, false);
+ if (newstr == NULL)
+ elog(LOG, "Failed to commit %s", conf->gen.name);
+ else if (newstr != str)
+ {
+ /* See notes in set_config_option about casting */
+ str = (char *) newstr;
+ SET_STRING_SESSION_VAL(conf, str);
+ }
+ }
+
+ SET_STRING_VARIABLE(conf, str);
+ }
+ conf->gen.source = conf->gen.session_source;
+ conf->gen.status = 0;
+ break;
+ }
+ }
+ }
+
+ guc_dirty = false;
+}
+
+
+/*
+ * Try to interpret value as boolean value. Valid values are: true,
+ * false, yes, no, on, off, 1, 0. If the string parses okay, return
+ * true, else false. If result is not NULL, return the parsing result
+ * there.
+ */
+static bool
+parse_bool(const char *value, bool *result)
+{
+ size_t len = strlen(value);
+
+ if (strncasecmp(value, "true", len) == 0)
+ {
+ if (result)
+ *result = true;
+ }
+ else if (strncasecmp(value, "false", len) == 0)
+ {
+ if (result)
+ *result = false;
+ }
+
+ else if (strncasecmp(value, "yes", len) == 0)
+ {
+ if (result)
+ *result = true;
+ }
+ else if (strncasecmp(value, "no", len) == 0)
+ {
+ if (result)
+ *result = false;
+ }
+
+ else if (strcasecmp(value, "on") == 0)
+ {
+ if (result)
+ *result = true;
+ }
+ else if (strcasecmp(value, "off") == 0)
+ {
+ if (result)
+ *result = false;
+ }
+
+ else if (strcasecmp(value, "1") == 0)
+ {
+ if (result)
+ *result = true;
+ }
+ else if (strcasecmp(value, "0") == 0)
+ {
+ if (result)
+ *result = false;
+ }
+
+ else
+ return false;
+ return true;
+}
+
+
+
+/*
+ * Try to parse value as an integer. The accepted formats are the
+ * usual decimal, octal, or hexadecimal formats. If the string parses
+ * okay, return true, else false. If result is not NULL, return the
+ * value there.
+ */
+static bool
+parse_int(const char *value, int *result)
+{
+ long val;
+ char *endptr;
+
+ errno = 0;
+ val = strtol(value, &endptr, 0);
+ if (endptr == value || *endptr != '\0' || errno == ERANGE
+#ifdef HAVE_LONG_INT_64
+ /* if long > 32 bits, check for overflow of int4 */
+ || val != (long) ((int32) val)
+#endif
+ )
+ return false;
+ if (result)
+ *result = (int) val;
+ return true;
+}
+
+
+
+/*
+ * Try to parse value as a floating point constant in the usual
+ * format. If the value parsed okay return true, else false. If
+ * result is not NULL, return the semantic value there.
+ */
+static bool
+parse_real(const char *value, double *result)
+{
+ double val;
+ char *endptr;
+
+ errno = 0;
+ val = strtod(value, &endptr);
+ if (endptr == value || *endptr != '\0' || errno == ERANGE)
+ return false;
+ if (result)
+ *result = val;
+ return true;
+}
+
+
+
+/*
+ * Sets option `name' to given value. The value should be a string
+ * which is going to be parsed and converted to the appropriate data
+ * type. The context and source parameters indicate in which context this
+ * function is being called so it can apply the access restrictions
+ * properly.
+ *
+ * If value is NULL, set the option to its default value. If the
+ * parameter DoIt is false then don't really set the option but do all
+ * the checks to see if it would work.
+ *
+ * If there is an error (non-existing option, invalid value) then an
+ * elog(ERROR) is thrown *unless* this is called in a context where we
+ * don't want to elog (currently, startup or SIGHUP config file reread).
+ * In that case we write a suitable error message via elog(DEBUG) and
+ * return false. This is working around the deficiencies in the elog
+ * mechanism, so don't blame me. In all other cases, the function
+ * returns true, including cases where the input is valid but we chose
+ * not to apply it because of context or source-priority considerations.
+ *
+ * See also SetConfigOption for an external interface.
+ */
+bool
+set_config_option(const char *name, const char *value,
+ GucContext context, GucSource source,
+ bool isLocal, bool DoIt)
+{
+ struct config_generic *record;
+ int elevel;
+ bool interactive;
+ bool makeDefault;
+
+ if (context == PGC_SIGHUP || source == PGC_S_DEFAULT)
+ elevel = DEBUG1;
+ else if (source == PGC_S_DATABASE || source == PGC_S_USER)
+ elevel = INFO;
+ else
+ elevel = ERROR;
+
+ record = find_option(name);
+ if (record == NULL)
+ {
+ elog(elevel, "'%s' is not a valid option name", name);
+ return false;
+ }
+
+ /*
+ * Check if the option can be set at this time. See guc.h for the
+ * precise rules. Note that we don't want to throw errors if we're in
+ * the SIGHUP context. In that case we just ignore the attempt and
+ * return true.
+ */
+ switch (record->context)
+ {
+ case PGC_POSTMASTER:
+ if (context == PGC_SIGHUP)
+ return true;
+ if (context != PGC_POSTMASTER)
+ {
+ elog(elevel, "'%s' cannot be changed after server start",
+ name);
+ return false;
+ }
+ break;
+ case PGC_SIGHUP:
+ if (context != PGC_SIGHUP && context != PGC_POSTMASTER)
+ {
+ elog(elevel, "'%s' cannot be changed now", name);
+ return false;
+ }
+
+ /*
+ * Hmm, the idea of the SIGHUP context is "ought to be global,
+ * but can be changed after postmaster start". But there's
+ * nothing that prevents a crafty administrator from sending
+ * SIGHUP signals to individual backends only.
+ */
+ break;
+ case PGC_BACKEND:
+ if (context == PGC_SIGHUP)
+ {
+ /*
+ * If a PGC_BACKEND parameter is changed in the config
+ * file, we want to accept the new value in the postmaster
+ * (whence it will propagate to subsequently-started
+ * backends), but ignore it in existing backends. This is
+ * a tad klugy, but necessary because we don't re-read the
+ * config file during backend start.
+ */
+ if (IsUnderPostmaster)
+ return true;
+ }
+ else if (context != PGC_BACKEND && context != PGC_POSTMASTER)
+ {
+ elog(elevel, "'%s' cannot be set after connection start",
+ name);
+ return false;
+ }
+ break;
+ case PGC_SUSET:
+ if (context == PGC_USERSET || context == PGC_BACKEND)
+ {
+ elog(elevel, "'%s': permission denied", name);
+ return false;
}
- else if (context != PGC_BACKEND && context != PGC_POSTMASTER)
- elog(ERROR, "'%s' cannot be set after connection start", name);
- break;
- case PGC_SUSET:
- if (context == PGC_USERSET || context == PGC_BACKEND)
- elog(ERROR, "permission denied");
break;
case PGC_USERSET:
/* always okay */
break;
}
+ interactive = (source >= PGC_S_SESSION);
+ makeDefault = (source <= PGC_S_OVERRIDE) && (value != NULL);
+
+ /*
+ * Ignore attempted set if overridden by previously processed setting.
+ * However, if DoIt is false then plow ahead anyway since we are trying
+ * to find out if the value is potentially good, not actually use it.
+ * Also keep going if makeDefault is true, since we may want to set
+ * the reset/session values even if we can't set the variable itself.
+ */
+ if (record->source > source)
+ {
+ if (DoIt && !makeDefault)
+ {
+ elog(DEBUG2, "setting %s ignored because previous source is higher",
+ name);
+ return true;
+ }
+ DoIt = false; /* we won't change the variable itself */
+ }
+
/*
* Evaluate value and set variable
*/
- switch (type)
+ switch (record->vartype)
{
case PGC_BOOL:
{
struct config_bool *conf = (struct config_bool *) record;
+ bool newval;
if (value)
{
- bool boolval;
+ if (!parse_bool(value, &newval))
+ {
+ elog(elevel, "option '%s' requires a boolean value",
+ name);
+ return false;
+ }
+ }
+ else
+ {
+ newval = conf->reset_val;
+ source = conf->gen.reset_source;
+ }
- if (!parse_bool(value, &boolval))
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (newval, DoIt, interactive))
{
- elog(elevel, "option '%s' requires a boolean value", name);
+ elog(elevel, "invalid value for option '%s': %d",
+ name, (int) newval);
return false;
}
- /* no parse_hook needed for booleans */
+
+ if (DoIt || makeDefault)
+ {
if (DoIt)
{
- if (conf->assign_hook)
- (conf->assign_hook) (boolval);
- *conf->variable = boolval;
- if (makeDefault)
- conf->default_val = boolval;
- conf->source = source;
+ *conf->variable = newval;
+ conf->gen.source = source;
+ }
+ if (makeDefault)
+ {
+ if (conf->gen.reset_source <= source)
+ {
+ conf->reset_val = newval;
+ conf->gen.reset_source = source;
+ }
+ if (conf->gen.session_source <= source)
+ {
+ conf->session_val = newval;
+ conf->gen.session_source = source;
+ }
+ }
+ else if (isLocal)
+ {
+ conf->gen.status |= GUC_HAVE_LOCAL;
+ guc_dirty = true;
+ }
+ else
+ {
+ conf->tentative_val = newval;
+ conf->gen.tentative_source = source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
}
- }
- else if (DoIt)
- {
- if (conf->assign_hook)
- (conf->assign_hook) (conf->default_val);
- *conf->variable = conf->default_val;
}
break;
}
case PGC_INT:
{
struct config_int *conf = (struct config_int *) record;
+ int newval;
if (value)
{
- int intval;
-
- if (!parse_int(value, &intval))
+ if (!parse_int(value, &newval))
{
- elog(elevel, "option '%s' expects an integer value", name);
+ elog(elevel, "option '%s' expects an integer value",
+ name);
return false;
}
- if (intval < conf->min || intval > conf->max)
+ if (newval < conf->min || newval > conf->max)
{
elog(elevel, "option '%s' value %d is outside"
" of permissible range [%d .. %d]",
- name, intval, conf->min, conf->max);
+ name, newval, conf->min, conf->max);
return false;
}
- if (conf->parse_hook && !(conf->parse_hook) (intval))
+ }
+ else
+ {
+ newval = conf->reset_val;
+ source = conf->gen.reset_source;
+ }
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (newval, DoIt, interactive))
{
elog(elevel, "invalid value for option '%s': %d",
- name, intval);
+ name, newval);
return false;
}
+
+ if (DoIt || makeDefault)
+ {
if (DoIt)
{
- if (conf->assign_hook)
- (conf->assign_hook) (intval);
- *conf->variable = intval;
- if (makeDefault)
- conf->default_val = intval;
- conf->source = source;
+ *conf->variable = newval;
+ conf->gen.source = source;
+ }
+ if (makeDefault)
+ {
+ if (conf->gen.reset_source <= source)
+ {
+ conf->reset_val = newval;
+ conf->gen.reset_source = source;
+ }
+ if (conf->gen.session_source <= source)
+ {
+ conf->session_val = newval;
+ conf->gen.session_source = source;
+ }
+ }
+ else if (isLocal)
+ {
+ conf->gen.status |= GUC_HAVE_LOCAL;
+ guc_dirty = true;
+ }
+ else
+ {
+ conf->tentative_val = newval;
+ conf->gen.tentative_source = source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
}
- }
- else if (DoIt)
- {
- if (conf->assign_hook)
- (conf->assign_hook) (conf->default_val);
- *conf->variable = conf->default_val;
}
break;
}
case PGC_REAL:
{
struct config_real *conf = (struct config_real *) record;
+ double newval;
if (value)
{
- double dval;
-
- if (!parse_real(value, &dval))
+ if (!parse_real(value, &newval))
{
- elog(elevel, "option '%s' expects a real number", name);
+ elog(elevel, "option '%s' expects a real number",
+ name);
return false;
}
- if (dval < conf->min || dval > conf->max)
+ if (newval < conf->min || newval > conf->max)
{
elog(elevel, "option '%s' value %g is outside"
" of permissible range [%g .. %g]",
- name, dval, conf->min, conf->max);
+ name, newval, conf->min, conf->max);
return false;
}
- if (conf->parse_hook && !(conf->parse_hook) (dval))
+ }
+ else
+ {
+ newval = conf->reset_val;
+ source = conf->gen.reset_source;
+ }
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (newval, DoIt, interactive))
{
elog(elevel, "invalid value for option '%s': %g",
- name, dval);
+ name, newval);
return false;
}
+
+ if (DoIt || makeDefault)
+ {
if (DoIt)
{
- if (conf->assign_hook)
- (conf->assign_hook) (dval);
- *conf->variable = dval;
- if (makeDefault)
- conf->default_val = dval;
- conf->source = source;
+ *conf->variable = newval;
+ conf->gen.source = source;
+ }
+ if (makeDefault)
+ {
+ if (conf->gen.reset_source <= source)
+ {
+ conf->reset_val = newval;
+ conf->gen.reset_source = source;
+ }
+ if (conf->gen.session_source <= source)
+ {
+ conf->session_val = newval;
+ conf->gen.session_source = source;
+ }
+ }
+ else if (isLocal)
+ {
+ conf->gen.status |= GUC_HAVE_LOCAL;
+ guc_dirty = true;
+ }
+ else
+ {
+ conf->tentative_val = newval;
+ conf->gen.tentative_source = source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
}
- }
- else if (DoIt)
- {
- if (conf->assign_hook)
- (conf->assign_hook) (conf->default_val);
- *conf->variable = conf->default_val;
}
break;
}
case PGC_STRING:
{
struct config_string *conf = (struct config_string *) record;
+ char *newval;
if (value)
{
- if (conf->parse_hook && !(conf->parse_hook) (value))
+ newval = strdup(value);
+ if (newval == NULL)
+ {
+ elog(elevel, "out of memory");
+ return false;
+ }
+ }
+ else if (conf->reset_val)
+ {
+ newval = strdup(conf->reset_val);
+ if (newval == NULL)
+ {
+ elog(elevel, "out of memory");
+ return false;
+ }
+ source = conf->gen.reset_source;
+ }
+ else
+ {
+ /* Nothing to reset to, as yet; so do nothing */
+ break;
+ }
+
+ /*
+ * Remember string in workspace, so that we can free it
+ * and avoid a permanent memory leak if hook elogs.
+ */
+ if (guc_string_workspace)
+ free(guc_string_workspace);
+ guc_string_workspace = newval;
+
+ if (conf->assign_hook)
+ {
+ const char *hookresult;
+
+ hookresult = (*conf->assign_hook) (newval,
+ DoIt, interactive);
+ guc_string_workspace = NULL;
+ if (hookresult == NULL)
{
+ free(newval);
elog(elevel, "invalid value for option '%s': '%s'",
- name, value);
+ name, value ? value : "");
return false;
}
- if (DoIt)
+ else if (hookresult != newval)
{
- char *str;
+ free(newval);
+ /*
+ * Having to cast away const here is annoying, but the
+ * alternative is to declare assign_hooks as returning
+ * char*, which would mean they'd have to cast away
+ * const, or as both taking and returning char*, which
+ * doesn't seem attractive either --- we don't want
+ * them to scribble on the passed str.
+ */
+ newval = (char *) hookresult;
+ }
+ }
+
+ guc_string_workspace = NULL;
- str = strdup(value);
- if (str == NULL)
+ if (DoIt || makeDefault)
+ {
+ if (DoIt)
+ {
+ SET_STRING_VARIABLE(conf, newval);
+ conf->gen.source = source;
+ }
+ if (makeDefault)
+ {
+ if (conf->gen.reset_source <= source)
{
- elog(elevel, "out of memory");
- return false;
+ SET_STRING_RESET_VAL(conf, newval);
+ conf->gen.reset_source = source;
}
- if (conf->assign_hook)
- (conf->assign_hook) (str);
- if (*conf->variable)
- free(*conf->variable);
- *conf->variable = str;
- if (makeDefault)
+ if (conf->gen.session_source <= source)
{
- str = strdup(value);
- if (str == NULL)
- {
- elog(elevel, "out of memory");
- return false;
- }
- if (conf->default_val)
- free(conf->default_val);
- conf->default_val = str;
+ SET_STRING_SESSION_VAL(conf, newval);
+ conf->gen.session_source = source;
}
- conf->source = source;
+ /* Perhaps we didn't install newval anywhere */
+ if (newval != *conf->variable &&
+ newval != conf->session_val &&
+ newval != conf->reset_val)
+ free(newval);
}
- }
- else if (DoIt)
- {
- char *str;
-
- if (!conf->default_val && conf->boot_default_val)
+ else if (isLocal)
{
- str = strdup(conf->boot_default_val);
- if (str == NULL)
- {
- elog(elevel, "out of memory");
- return false;
- }
- conf->default_val = str;
+ conf->gen.status |= GUC_HAVE_LOCAL;
+ guc_dirty = true;
}
- str = strdup(conf->default_val);
- if (str == NULL)
+ else
{
- elog(elevel, "out of memory");
- return false;
+ SET_STRING_TENTATIVE_VAL(conf, newval);
+ conf->gen.tentative_source = source;
+ conf->gen.status |= GUC_HAVE_TENTATIVE;
+ guc_dirty = true;
}
- if (conf->assign_hook)
- (conf->assign_hook) (str);
- if (*conf->variable)
- free(*conf->variable);
- *conf->variable = str;
+ }
+ else
+ {
+ free(newval);
}
break;
}
-
- default:;
}
+
return true;
}
/*
* Set a config option to the given value. See also set_config_option,
- * this is just the wrapper to be called from the outside.
+ * this is just the wrapper to be called from outside GUC. NB: this
+ * is used only for non-transactional operations.
*/
void
SetConfigOption(const char *name, const char *value,
GucContext context, GucSource source)
{
- (void) set_config_option(name, value, context, true, source);
+ (void) set_config_option(name, value, context, source, false, true);
}
/*
- * This is more or less the SHOW command. It returns a string with the
- * value of the option `name'. If the option doesn't exist, throw an
- * elog and don't return.
+ * Fetch the current value of the option `name'. If the option doesn't exist,
+ * throw an elog and don't return.
*
* The string is *not* allocated for modification and is really only
* valid until the next call to configuration related functions.
{
struct config_generic *record;
static char buffer[256];
- enum config_type opttype;
- opttype = find_option(name, &record);
- if (opttype == PGC_NONE)
+ record = find_option(name);
+ if (record == NULL)
elog(ERROR, "Option '%s' is not recognized", name);
- switch (opttype)
+ switch (record->vartype)
{
case PGC_BOOL:
return *((struct config_bool *) record)->variable ? "on" : "off";
case PGC_STRING:
return *((struct config_string *) record)->variable;
-
- default:
- ;
}
return NULL;
}
-static void
-_ShowOption(enum config_type opttype, struct config_generic * record)
+/*
+ * Get the RESET value associated with the given option.
+ */
+const char *
+GetConfigOptionResetString(const char *name)
{
- char buffer[256];
- char *val;
+ struct config_generic *record;
+ static char buffer[256];
- switch (opttype)
+ record = find_option(name);
+ if (record == NULL)
+ elog(ERROR, "Option '%s' is not recognized", name);
+
+ switch (record->vartype)
{
case PGC_BOOL:
- val = *((struct config_bool *) record)->variable ? "on" : "off";
- break;
+ return ((struct config_bool *) record)->reset_val ? "on" : "off";
case PGC_INT:
snprintf(buffer, sizeof(buffer), "%d",
- *((struct config_int *) record)->variable);
- val = buffer;
- break;
+ ((struct config_int *) record)->reset_val);
+ return buffer;
case PGC_REAL:
snprintf(buffer, sizeof(buffer), "%g",
- *((struct config_real *) record)->variable);
- val = buffer;
- break;
+ ((struct config_real *) record)->reset_val);
+ return buffer;
case PGC_STRING:
- val = strlen(*((struct config_string *) record)->variable) != 0 ?
- *((struct config_string *) record)->variable : "unset";
- break;
+ return ((struct config_string *) record)->reset_val;
+ }
+ return NULL;
+}
- default:
- val = "???";
+
+
+/*
+ * flatten_set_variable_args
+ * Given a parsenode List as emitted by the grammar for SET,
+ * convert to the flat string representation used by GUC.
+ *
+ * We need to be told the name of the variable the args are for, because
+ * the flattening rules vary (ugh).
+ *
+ * The result is NULL if input is NIL (ie, SET ... TO DEFAULT), otherwise
+ * a palloc'd string.
+ */
+char *
+flatten_set_variable_args(const char *name, List *args)
+{
+ struct config_generic *record;
+ int flags;
+ StringInfoData buf;
+ List *l;
+
+ /* Fast path if just DEFAULT */
+ if (args == NIL)
+ return NULL;
+
+ record = find_option(name);
+ if (record == NULL)
+ flags = 0; /* default assumptions */
+ else
+ flags = record->flags;
+
+ /* Complain if list input and non-list variable */
+ if ((flags & GUC_LIST_INPUT) == 0 &&
+ lnext(args) != NIL)
+ elog(ERROR, "SET %s takes only one argument", name);
+
+ initStringInfo(&buf);
+
+ foreach(l, args)
+ {
+ A_Const *arg = (A_Const *) lfirst(l);
+ char *val;
+
+ if (l != args)
+ appendStringInfo(&buf, ", ");
+
+ if (!IsA(arg, A_Const))
+ elog(ERROR, "flatten_set_variable_args: unexpected input");
+
+ switch (nodeTag(&arg->val))
+ {
+ case T_Integer:
+ appendStringInfo(&buf, "%ld", intVal(&arg->val));
+ break;
+ case T_Float:
+ /* represented as a string, so just copy it */
+ appendStringInfo(&buf, "%s", strVal(&arg->val));
+ break;
+ case T_String:
+ val = strVal(&arg->val);
+ if (arg->typename != NULL)
+ {
+ /*
+ * Must be a ConstInterval argument for TIME ZONE.
+ * Coerce to interval and back to normalize the value
+ * and account for any typmod.
+ */
+ Datum interval;
+ char *intervalout;
+
+ interval =
+ DirectFunctionCall3(interval_in,
+ CStringGetDatum(val),
+ ObjectIdGetDatum(InvalidOid),
+ Int32GetDatum(arg->typename->typmod));
+
+ intervalout =
+ DatumGetCString(DirectFunctionCall3(interval_out,
+ interval,
+ ObjectIdGetDatum(InvalidOid),
+ Int32GetDatum(-1)));
+ 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)
+ appendStringInfo(&buf, "%s", quote_identifier(val));
+ else
+ appendStringInfo(&buf, "%s", val);
+ }
+ break;
+ default:
+ elog(ERROR, "flatten_set_variable_args: unexpected input");
+ break;
+ }
}
- elog(INFO, "%s is %s", record->name, val);
+
+ return buf.data;
+}
+
+
+/*
+ * SET command
+ */
+void
+SetPGVariable(const char *name, List *args, bool is_local)
+{
+ char *argstring = flatten_set_variable_args(name, args);
+
+ /* Note SET DEFAULT (argstring == NULL) is equivalent to RESET */
+ set_config_option(name,
+ argstring,
+ (superuser() ? PGC_SUSET : PGC_USERSET),
+ PGC_S_SESSION,
+ is_local,
+ true);
+}
+
+/*
+ * SHOW command
+ */
+void
+GetPGVariable(const char *name)
+{
+ if (strcasecmp(name, "all") == 0)
+ ShowAllGUCConfig();
+ else
+ ShowGUCConfigOption(name);
+}
+
+/*
+ * RESET command
+ */
+void
+ResetPGVariable(const char *name)
+{
+ if (strcasecmp(name, "all") == 0)
+ ResetAllOptions();
+ else
+ set_config_option(name,
+ NULL,
+ (superuser() ? PGC_SUSET : PGC_USERSET),
+ PGC_S_SESSION,
+ false,
+ true);
+}
+
+
+/*
+ * SHOW command
+ */
+void
+ShowGUCConfigOption(const char *name)
+{
+ struct config_generic *record;
+
+ record = find_option(name);
+ if (record == NULL)
+ elog(ERROR, "Option '%s' is not recognized", name);
+
+ _ShowOption(record);
}
+/*
+ * SHOW ALL command
+ */
void
ShowAllGUCConfig(void)
{
int i;
- for (i = 0; ConfigureNamesBool[i].name; i++)
- _ShowOption(PGC_BOOL, (struct config_generic *) & ConfigureNamesBool[i]);
+ for (i = 0; i < num_guc_variables; i++)
+ {
+ struct config_generic *conf = guc_variables[i];
+
+ if ((conf->flags & GUC_NO_SHOW_ALL) == 0)
+ _ShowOption(conf);
+ }
+}
- for (i = 0; ConfigureNamesInt[i].name; i++)
- _ShowOption(PGC_INT, (struct config_generic *) & ConfigureNamesInt[i]);
+static void
+_ShowOption(struct config_generic *record)
+{
+ char buffer[256];
+ const char *val;
- for (i = 0; ConfigureNamesReal[i].name; i++)
- _ShowOption(PGC_REAL, (struct config_generic *) & ConfigureNamesReal[i]);
+ switch (record->vartype)
+ {
+ case PGC_BOOL:
+ {
+ struct config_bool *conf = (struct config_bool *) record;
- for (i = 0; ConfigureNamesString[i].name; i++)
- _ShowOption(PGC_STRING, (struct config_generic *) & ConfigureNamesString[i]);
-}
+ 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
+ {
+ snprintf(buffer, sizeof(buffer), "%d",
+ *conf->variable);
+ val = buffer;
+ }
+ }
+ break;
+
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) record;
+
+ if (conf->show_hook)
+ val = (*conf->show_hook) ();
+ else
+ {
+ snprintf(buffer, sizeof(buffer), "%g",
+ *conf->variable);
+ 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 = "unset";
+ }
+ break;
+ default:
+ /* just to keep compiler quiet */
+ val = "???";
+ break;
+ }
+ elog(INFO, "%s is %s", record->name, val);
+}
/*
#ifdef HAVE_SYSLOG
-static bool
-check_facility(const char *facility)
+static const char *
+assign_facility(const char *facility, bool doit, bool interactive)
{
if (strcasecmp(facility, "LOCAL0") == 0)
- return true;
+ return facility;
if (strcasecmp(facility, "LOCAL1") == 0)
- return true;
+ return facility;
if (strcasecmp(facility, "LOCAL2") == 0)
- return true;
+ return facility;
if (strcasecmp(facility, "LOCAL3") == 0)
- return true;
+ return facility;
if (strcasecmp(facility, "LOCAL4") == 0)
- return true;
+ return facility;
if (strcasecmp(facility, "LOCAL5") == 0)
- return true;
+ return facility;
if (strcasecmp(facility, "LOCAL6") == 0)
- return true;
+ return facility;
if (strcasecmp(facility, "LOCAL7") == 0)
- return true;
- return false;
+ return facility;
+ return NULL;
}
-#endif
-
-
-static bool
-check_defaultxactisolevel(const char *value)
-{
- return (strcasecmp(value, "read committed") == 0
- || strcasecmp(value, "serializable") == 0)
- ? true : false;
-}
+#endif
-static void
-assign_defaultxactisolevel(const char *value)
+static const char *
+assign_defaultxactisolevel(const char *newval, bool doit, bool interactive)
{
- if (strcasecmp(value, "serializable") == 0)
- DefaultXactIsoLevel = XACT_SERIALIZABLE;
- else if (strcasecmp(value, "read committed") == 0)
- DefaultXactIsoLevel = XACT_READ_COMMITTED;
+ if (strcasecmp(newval, "serializable") == 0)
+ { if (doit) DefaultXactIsoLevel = XACT_SERIALIZABLE; }
+ else if (strcasecmp(newval, "read committed") == 0)
+ { if (doit) DefaultXactIsoLevel = XACT_READ_COMMITTED; }
else
- elog(ERROR, "bogus transaction isolation level");
+ return NULL;
+ return newval;
}
-
+/*
+ * Handle options fetched from pg_database.datconfig or pg_shadow.useconfig.
+ */
void
ProcessGUCArray(ArrayType *array, GucSource source)
{
int i;
- Assert(array);
+ Assert(array != NULL);
+ Assert(source == PGC_S_DATABASE || source == PGC_S_USER);
for (i = 1; i <= ARR_DIMS(array)[0]; i++)
{
continue;
}
- /* prevent errors from incorrect options */
- guc_session_init = true;
-
+ /*
+ * We process all these options at SUSET level. We assume that the
+ * right to insert an option into pg_database or pg_shadow was
+ * checked when it was inserted.
+ */
SetConfigOption(name, value, PGC_SUSET, source);
-
- guc_session_init = false;
}
}
/* test if the option is valid */
set_config_option(name, value,
superuser() ? PGC_SUSET : PGC_USERSET,
- false, PGC_S_INFINITY);
+ PGC_S_SESSION, false, false);
newval = palloc(strlen(name) + 1 + strlen(value) + 1);
sprintf(newval, "%s=%s", name, value);
/* test if the option is valid */
set_config_option(name, NULL,
superuser() ? PGC_SUSET : PGC_USERSET,
- false, PGC_S_INFINITY);
+ PGC_S_SESSION, false, false);
newarray = construct_array(NULL, 0, false, -1, 'i');
index = 1;
projects / postgresql.git / commitdiff