*
* Copyright (c) 2000-2007, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/backend/utils/misc/guc-file.l,v 1.50 2007/04/21 20:02:40 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/misc/guc-file.l,v 1.51 2007/09/10 00:57:21 tgl Exp $
*/
%{
{
int elevel;
struct name_value_pair *item, *head, *tail;
+ char *cvc = NULL;
+ struct config_string *cvc_struct;
+ const char *envvar;
int i;
- bool *in_conffile = NULL;
- const char *var;
Assert(context == PGC_POSTMASTER || context == PGC_SIGHUP);
else
elevel = ERROR;
+ /* Parse the file into a list of option names and values */
head = tail = NULL;
if (!ParseConfigFile(ConfigFileName, NULL,
&head, &tail))
goto cleanup_list;
- /* Check if all options are valid */
- for (item = head; item; item = item->next)
+ /*
+ * We need the proposed new value of custom_variable_classes to check
+ * custom variables with. ParseConfigFile ensured that if it's in
+ * the file, it's first in the list. But first check to see if we
+ * have an active value from the command line, which should override
+ * the file in any case. (Since there's no relevant env var, the
+ * only possible nondefault sources are the file and ARGV.)
+ */
+ cvc_struct = (struct config_string *)
+ find_option("custom_variable_classes", false, elevel);
+ if (cvc_struct && cvc_struct->gen.reset_source > PGC_S_FILE)
{
- char *sep = strchr(item->name, GUC_QUALIFIER_SEPARATOR);
- if (sep && !is_custom_class(item->name, sep - item->name))
+ cvc = guc_strdup(elevel, cvc_struct->reset_val);
+ if (cvc == NULL)
+ goto cleanup_list;
+ }
+ else if (head != NULL &&
+ guc_name_compare(head->name, "custom_variable_classes") == 0)
+ {
+ /*
+ * Need to canonicalize the value via the assign hook. Casting away
+ * const is a bit ugly, but we know the result is malloc'd.
+ */
+ cvc = (char *) assign_custom_variable_classes(head->value,
+ false, PGC_S_FILE);
+ if (cvc == NULL)
{
ereport(elevel,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("unrecognized configuration parameter \"%s\"",
- item->name)));
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("invalid value for parameter \"%s\": \"%s\"",
+ head->name, head->value)));
goto cleanup_list;
}
-
- if (!set_config_option(item->name, item->value, context,
- PGC_S_FILE, false, false))
- goto cleanup_list;
}
-
/*
- * Mark all variables as not showing up in the config file. The
- * allocation has to take place after ParseConfigFile() since this
- * function can change num_guc_variables due to custom variables.
- * It would be easier to add a new field or status bit to struct
- * conf_generic, but that way we would expose internal information
- * that is just needed here in the following few lines. The price
- * to pay for this separation are a few more loops over the set of
- * configuration options, but those are expected to be rather few
- * and we only have to pay the cost at SIGHUP. We initialize
- * in_conffile only here because set_config_option() makes
- * guc_variables grow with custom variables.
+ * Mark all extant GUC variables as not present in the config file.
+ * We need this so that we can tell below which ones have been removed
+ * from the file since we last processed it.
*/
- in_conffile = guc_malloc(elevel, num_guc_variables * sizeof(bool));
- if (!in_conffile)
- goto cleanup_list;
for (i = 0; i < num_guc_variables; i++)
- in_conffile[i] = false;
+ {
+ struct config_generic *gconf = guc_variables[i];
+
+ gconf->status &= ~GUC_IS_IN_FILE;
+ }
+ /*
+ * Check if all options are valid. As a side-effect, the GUC_IS_IN_FILE
+ * flag is set on each GUC variable mentioned in the list.
+ */
for (item = head; item; item = item->next)
{
- /*
- * After set_config_option() the variable name item->name is
- * known to exist.
- */
- Assert(guc_get_index(item->name) >= 0);
- in_conffile[guc_get_index(item->name)] = true;
+ char *sep = strchr(item->name, GUC_QUALIFIER_SEPARATOR);
+
+ if (sep)
+ {
+ /*
+ * We have to consider three cases for custom variables:
+ *
+ * 1. The class name is not valid according to the (new) setting
+ * of custom_variable_classes. If so, reject. We don't care
+ * which side is at fault.
+ */
+ if (!is_custom_class(item->name, sep - item->name, cvc))
+ {
+ ereport(elevel,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("unrecognized configuration parameter \"%s\"",
+ item->name)));
+ goto cleanup_list;
+ }
+ /*
+ * 2. There is no GUC entry. If we called set_config_option then
+ * it would make a placeholder, which we don't want to do yet,
+ * since we could still fail further down the list. Do nothing
+ * (assuming that making the placeholder will succeed later).
+ */
+ if (find_option(item->name, false, elevel) == NULL)
+ continue;
+ /*
+ * 3. There is already a GUC entry (either real or placeholder) for
+ * the variable. In this case we should let set_config_option
+ * check it, since the assignment could well fail if it's a real
+ * entry.
+ */
+ }
+
+ if (!set_config_option(item->name, item->value, context,
+ PGC_S_FILE, false, false))
+ goto cleanup_list;
}
+ /*
+ * Check for variables having been removed from the config file, and
+ * revert their reset values (and perhaps also effective values) to the
+ * boot-time defaults. If such a variable can't be changed after startup,
+ * just throw a warning and continue. (This is analogous to the fact that
+ * set_config_option only throws a warning for a new but different value.
+ * If we wanted to make it a hard error, we'd need an extra pass over the
+ * list so that we could throw the error before starting to apply
+ * changes.)
+ */
for (i = 0; i < num_guc_variables; i++)
{
struct config_generic *gconf = guc_variables[i];
- if (!in_conffile[i] && gconf->source == PGC_S_FILE)
+ GucStack *stack;
+
+ if (gconf->reset_source != PGC_S_FILE ||
+ (gconf->status & GUC_IS_IN_FILE))
+ continue;
+ if (gconf->context < PGC_SIGHUP)
{
- if (gconf->context < PGC_SIGHUP)
- ereport(elevel,
+ ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
- errmsg("parameter \"%s\" cannot be changed after server start; configuration file change ignored",
- gconf->name)));
- else
- {
- /* prepare */
- GucStack *stack;
- if (gconf->reset_source == PGC_S_FILE)
- gconf->reset_source = PGC_S_DEFAULT;
- for (stack = gconf->stack; stack; stack = stack->prev)
- if (stack->source == PGC_S_FILE)
- stack->source = PGC_S_DEFAULT;
- /* apply the default */
- set_config_option(gconf->name, NULL, context,
- PGC_S_DEFAULT, false, true);
- }
+ errmsg("parameter \"%s\" cannot be changed after server start; configuration file change ignored",
+ gconf->name)));
+ continue;
}
- else if (!in_conffile[i] && gconf->reset_source == PGC_S_FILE)
- {
- /*------
- * Change the reset_val to default_val. Here's an
- * example: In the configuration file we have
- *
- * seq_page_cost = 3.00
- *
- * Now we execute in a session
- *
- * SET seq_page_cost TO 4.00;
- *
- * Then we remove this option from the configuration file
- * and send SIGHUP. Now when you execute
- *
- * RESET seq_page_cost;
- *
- * it should fall back to 1.00 (the default value for
- * seq_page_cost) and not to 3.00 (which is the current
- * reset_val).
- */
- switch (gconf->vartype)
- {
- case PGC_BOOL:
- {
- struct config_bool *conf;
- conf = (struct config_bool *) gconf;
- conf->reset_val = conf->boot_val;
- break;
- }
- case PGC_INT:
- {
- struct config_int *conf;
- conf = (struct config_int *) gconf;
- conf->reset_val = conf->boot_val;
- break;
- }
- case PGC_REAL:
- {
- struct config_real *conf;
- conf = (struct config_real *) gconf;
- conf->reset_val = conf->boot_val;
- break;
- }
- case PGC_STRING:
- {
- struct config_string *conf;
- conf = (struct config_string *) gconf;
- /*
- * We can cast away the const here because we
- * won't free the address. It is protected by
- * set_string_field() and string_field_used().
- */
- conf->reset_val = (char *) conf->boot_val;
- break;
- }
- }
+ /*
+ * Reset any "file" sources to "default", else set_config_option
+ * will not override those settings. tentative_source should
+ * never be "file".
+ */
+ if (gconf->reset_source == PGC_S_FILE)
+ gconf->reset_source = PGC_S_DEFAULT;
+ Assert(gconf->tentative_source != PGC_S_FILE);
+ if (gconf->source == PGC_S_FILE)
+ gconf->source = PGC_S_DEFAULT;
+ for (stack = gconf->stack; stack; stack = stack->prev)
+ {
+ Assert(stack->tentative_source != PGC_S_FILE);
+ if (stack->source == PGC_S_FILE)
+ stack->source = PGC_S_DEFAULT;
}
- }
- /* If we got here all the options checked out okay, so apply them. */
- for (item = head; item; item = item->next)
- set_config_option(item->name, item->value, context,
- PGC_S_FILE, false, true);
+ /* Now we can re-apply the wired-in default */
+ set_config_option(gconf->name, NULL, context, PGC_S_DEFAULT,
+ false, true);
+ }
/*
- * Reset variables to the value of environment variables
- * (PGC_S_ENV_VAR overrules PGC_S_FILE). PGPORT is ignored,
- * because it cannot be changed without restart.
+ * Restore any variables determined by environment variables. This
+ * is a no-op except in the case where one of these had been in the
+ * config file and is now removed. PGC_S_ENV_VAR will override the
+ * wired-in default we just applied, but cannot override any other source.
+ * PGPORT can be ignored, because it cannot be changed without restart.
+ * Keep this list in sync with InitializeGUCOptions()!
*/
- var = getenv("PGDATESTYLE");
- if (var != NULL)
- set_config_option("datestyle", var, context,
+ envvar = getenv("PGDATESTYLE");
+ if (envvar != NULL)
+ set_config_option("datestyle", envvar, PGC_POSTMASTER,
PGC_S_ENV_VAR, false, true);
- var = getenv("PGCLIENTENCODING");
- if (var != NULL)
- set_config_option("client_encoding", var, context,
+ envvar = getenv("PGCLIENTENCODING");
+ if (envvar != NULL)
+ set_config_option("client_encoding", envvar, PGC_POSTMASTER,
PGC_S_ENV_VAR, false, true);
+
+ /* If we got here all the options checked out okay, so apply them. */
+ for (item = head; item; item = item->next)
+ {
+ set_config_option(item->name, item->value, context,
+ PGC_S_FILE, false, true);
+ }
+
cleanup_list:
- free(in_conffile);
free_name_value_list(head);
+ if (cvc)
+ free(cvc);
}
while ((token = yylex()))
{
char *opt_name, *opt_value;
+ struct name_value_pair *item;
if (token == GUC_EOL) /* empty or comment line */
continue;
goto parse_error;
/* OK, process the option name and value */
- if (pg_strcasecmp(opt_name, "include") == 0)
+ if (guc_name_compare(opt_name, "include") == 0)
{
/*
* An include directive isn't a variable and should be processed
pfree(opt_name);
pfree(opt_value);
}
- else if (pg_strcasecmp(opt_name, "custom_variable_classes") == 0)
+ else if (guc_name_compare(opt_name, "custom_variable_classes") == 0)
{
/*
* This variable must be processed first as it controls
- * the validity of other variables; so apply immediately.
+ * the validity of other variables; so it goes at the head
+ * of the result list. If we already found a value for it,
+ * replace with this one.
*/
- if (!set_config_option(opt_name, opt_value, context,
- PGC_S_FILE, false, true))
+ item = *head_p;
+ if (item != NULL &&
+ guc_name_compare(item->name, "custom_variable_classes") == 0)
{
- pfree(opt_name);
- pfree(opt_value);
-
- /* We assume the error message was logged already. */
- OK = false;
- goto cleanup_exit;
+ /* replace existing head item */
+ pfree(item->name);
+ pfree(item->value);
+ item->name = opt_name;
+ item->value = opt_value;
+ }
+ else
+ {
+ /* prepend to list */
+ item = palloc(sizeof *item);
+ item->name = opt_name;
+ item->value = opt_value;
+ item->next = *head_p;
+ *head_p = item;
+ if (*tail_p == NULL)
+ *tail_p = item;
}
}
-
- if (pg_strcasecmp(opt_name, "include") != 0)
+ else
{
- /* append to list */
- struct name_value_pair *item;
-
+ /* ordinary variable, append to list */
item = palloc(sizeof *item);
item->name = opt_name;
item->value = opt_value;
* Written by Peter Eisentraut <peter_e@gmx.net>.
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.416 2007/09/03 18:46:30 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.417 2007/09/10 00:57:21 tgl Exp $
*
*--------------------------------------------------------------------
*/
static void ShowGUCConfigOption(const char *name, DestReceiver *dest);
static void ShowAllGUCConfig(DestReceiver *dest);
static char *_ShowOption(struct config_generic * record, bool use_units);
-static bool is_newvalue_equal(struct config_generic * record, const char *newvalue);
+static bool is_newvalue_equal(struct config_generic *record, const char *newvalue);
/*
sizeof(struct config_generic *), guc_var_compare);
}
-static bool
-is_custom_class(const char *name, int dotPos)
-{
- /*
- * assign_custom_variable_classes() has made sure no empty identifiers or
- * whitespace exists in the variable
- */
- bool result = false;
- const char *ccs = GetConfigOption("custom_variable_classes");
-
- if (ccs != NULL)
- {
- const char *start = ccs;
-
- for (;; ++ccs)
- {
- int c = *ccs;
-
- if (c == 0 || c == ',')
- {
- if (dotPos == ccs - start && strncmp(start, name, dotPos) == 0)
- {
- result = true;
- break;
- }
- if (c == 0)
- break;
- start = ccs + 1;
- }
- }
- }
- return result;
-}
-
/*
* Add a new GUC variable to the list of known variables. The
* list is expanded if needed.
* Create and add a placeholder variable. It's presumed to belong
* to a valid custom variable class at this point.
*/
-static struct config_string *
+static struct config_generic *
add_placeholder_variable(const char *name, int elevel)
{
size_t sz = sizeof(struct config_string) + sizeof(char *);
var = (struct config_string *) guc_malloc(elevel, sz);
if (var == NULL)
return NULL;
-
- gen = &var->gen;
memset(var, 0, sz);
+ gen = &var->gen;
gen->name = guc_strdup(elevel, name);
if (gen->name == NULL)
/*
* The char* is allocated at the end of the struct since we have no
- * 'static' place to point to.
+ * 'static' place to point to. Note that the current value, as well
+ * as the boot and reset values, start out NULL.
*/
var->variable = (char **) (var + 1);
return NULL;
}
- return var;
+ return gen;
+}
+
+/*
+ * Detect whether the portion of "name" before dotPos matches any custom
+ * variable class name listed in custom_var_classes. The latter must be
+ * formatted the way that assign_custom_variable_classes does it, ie,
+ * no whitespace. NULL is valid for custom_var_classes.
+ */
+static bool
+is_custom_class(const char *name, int dotPos, const char *custom_var_classes)
+{
+ bool result = false;
+ const char *ccs = custom_var_classes;
+
+ if (ccs != NULL)
+ {
+ const char *start = ccs;
+
+ for (;; ++ccs)
+ {
+ char c = *ccs;
+
+ if (c == '\0' || c == ',')
+ {
+ if (dotPos == ccs - start && strncmp(start, name, dotPos) == 0)
+ {
+ result = true;
+ break;
+ }
+ if (c == '\0')
+ break;
+ start = ccs + 1;
+ }
+ }
+ }
+ return result;
}
/*
- * Look up option NAME. If it exists, return a pointer to its record,
- * else return NULL.
+ * Look up option NAME. If it exists, return a pointer to its record,
+ * else return NULL. If create_placeholders is TRUE, we'll create a
+ * placeholder record for a valid-looking custom variable name.
*/
static struct config_generic *
-find_option(const char *name, int elevel)
+find_option(const char *name, bool create_placeholders, int elevel)
{
- const char *dot;
const char **key = &name;
struct config_generic **res;
int i;
for (i = 0; map_old_guc_names[i] != NULL; i += 2)
{
if (guc_name_compare(name, map_old_guc_names[i]) == 0)
- return find_option(map_old_guc_names[i + 1], elevel);
+ return find_option(map_old_guc_names[i + 1], false, elevel);
}
- /*
- * Check if the name is qualified, and if so, check if the qualifier maps
- * to a custom variable class.
- */
- dot = strchr(name, GUC_QUALIFIER_SEPARATOR);
- if (dot != NULL && is_custom_class(name, dot - name))
- /* Add a placeholder variable for this name */
- return (struct config_generic *) add_placeholder_variable(name, elevel);
+ if (create_placeholders)
+ {
+ /*
+ * Check if the name is qualified, and if so, check if the qualifier
+ * matches any custom variable class. If so, add a placeholder.
+ */
+ const char *dot = strchr(name, GUC_QUALIFIER_SEPARATOR);
+
+ if (dot != NULL &&
+ is_custom_class(name, dot - name, custom_variable_classes))
+ return add_placeholder_variable(name, elevel);
+ }
/* Unknown name */
return NULL;
}
-static int
-guc_get_index(const char *name)
-{
- const char **key = &name;
- struct config_generic **res;
-
- 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 -1;
-
- return res - guc_variables;
-}
-
-
/*
* Initialize GUC options during program startup.
*
if (conf->boot_val == NULL)
{
- /* Cannot set value yet */
+ /* leave the value NULL, do not call assign hook */
break;
}
/*
* For historical reasons, some GUC parameters can receive defaults from
- * environment variables. Process those settings.
+ * environment variables. Process those settings. NB: if you add or
+ * remove anything here, see also ProcessConfigFile().
*/
env = getenv("PGPORT");
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;
- }
-
/* We need not strdup here */
str = conf->reset_val;
- if (conf->assign_hook)
+ if (conf->assign_hook && str)
{
const char *newstr;
/*
* Skip if nothing's happened to this var in this transaction
*/
- if (my_status == 0)
+ if ((my_status & (GUC_HAVE_TENTATIVE |
+ GUC_HAVE_LOCAL |
+ GUC_HAVE_STACK)) == 0)
{
Assert(stack == NULL);
continue;
if (*conf->variable != newval)
{
- if (conf->assign_hook)
+ if (conf->assign_hook && newval)
{
const char *newstr;
else
elevel = ERROR;
- record = find_option(name, elevel);
+ record = find_option(name, true, elevel);
if (record == NULL)
{
ereport(elevel,
}
/*
- * Do not replace a value that has been set on the command line by a SIGHUP
- * reload
+ * If source is postgresql.conf, mark the found record with GUC_IS_IN_FILE.
+ * This is for the convenience of ProcessConfigFile. Note that we do it
+ * even if changeVal is false, since ProcessConfigFile wants the marking
+ * to occur during its testing pass.
*/
- if (context == PGC_SIGHUP && record->source == PGC_S_ARGV)
- return true;
+ if (source == PGC_S_FILE)
+ record->status |= GUC_IS_IN_FILE;
/*
* Check if the option can be set at this time. See guc.h for the precise
case PGC_POSTMASTER:
if (context == PGC_SIGHUP)
{
+ /*
+ * We are reading a PGC_POSTMASTER var from postgresql.conf.
+ * We can't change the setting, so give a warning if the DBA
+ * tries to change it. (Throwing an error would be more
+ * consistent, but seems overly rigid.)
+ */
if (changeVal && !is_newvalue_equal(record, value))
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
errmsg("parameter \"%s\" cannot be changed after server start; configuration file change ignored",
name)));
-
return true;
}
if (context != PGC_POSTMASTER)
* value from the database's/user's/client's default settings or
* when we reset a value to its default.
*/
- makeDefault = changeVal && (source <= PGC_S_OVERRIDE)
- && ((value != NULL) || source == PGC_S_DEFAULT);
+ makeDefault = changeVal && (source <= PGC_S_OVERRIDE) &&
+ ((value != NULL) || source == PGC_S_DEFAULT);
/*
- * Ignore attempted set if overridden by previously processed
- * setting. However, if changeVal 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/stacked values even if
- * we can't set the variable itself. There's one exception to
- * this rule: if we want to apply the default value to variables
- * that were removed from the configuration file. This is
- * indicated by source == PGC_S_DEFAULT and context == PGC_SIGHUP.
+ * Ignore attempted set if overridden by previously processed setting.
+ * However, if changeVal 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/stacked values even if we can't set the variable itself.
*/
- if (record->source > source
- && !(source == PGC_S_DEFAULT && context == PGC_SIGHUP))
+ if (record->source > source)
{
if (changeVal && !makeDefault)
{
/*
* Evaluate value and set variable.
+ *
+ * Note: if value == NULL then we are supposed to set to the reset_val,
+ * except when source == PGC_S_DEFAULT; then we set to the boot_val.
*/
switch (record->vartype)
{
return false;
}
}
- /*
- * If value == NULL and source == PGC_S_DEFAULT then
- * we reset some value to its default (removed from
- * configuration file).
- */
else if (source == PGC_S_DEFAULT)
newval = conf->boot_val;
- /* else we handle a "RESET varname" command */
else
{
newval = conf->reset_val;
return false;
}
}
- /*
- * If value == NULL and source == PGC_S_DEFAULT then
- * we reset some value to its default (removed from
- * configuration file).
- */
else if (source == PGC_S_DEFAULT)
newval = conf->boot_val;
- /* else we handle a "RESET varname" command */
else
{
newval = conf->reset_val;
return false;
}
}
- /*
- * If value == NULL and source == PGC_S_DEFAULT then
- * we reset some value to its default (removed from
- * configuration file).
- */
else if (source == PGC_S_DEFAULT)
newval = conf->boot_val;
- /* else we handle a "RESET varname" command */
else
{
newval = conf->reset_val;
if (conf->gen.flags & GUC_IS_NAME)
truncate_identifier(newval, strlen(newval), true);
}
- /*
- * If value == NULL and source == PGC_S_DEFAULT then
- * we reset some value to its default (removed from
- * configuration file).
- */
else if (source == PGC_S_DEFAULT)
{
if (conf->boot_val == NULL)
return false;
}
}
- /* else we handle a "RESET varname" command */
- else if (conf->reset_val)
+ else
{
/*
* We could possibly avoid strdup here, but easier to make
- * this case work the same as the normal assignment case.
+ * this case work the same as the normal assignment case;
+ * note the possible free of newval below.
*/
- newval = guc_strdup(elevel, conf->reset_val);
- if (newval == NULL)
- return false;
+ if (conf->reset_val == NULL)
+ newval = NULL;
+ else
+ {
+ newval = guc_strdup(elevel, conf->reset_val);
+ if (newval == NULL)
+ return false;
+ }
source = conf->gen.reset_source;
}
- else
- {
- /* Nothing to reset to, as yet; so do nothing */
- break;
- }
- if (conf->assign_hook)
+ if (conf->assign_hook && newval)
{
const char *hookresult;
}
}
/* Perhaps we didn't install newval anywhere */
- if (!string_field_used(conf, newval))
+ if (newval && !string_field_used(conf, newval))
free(newval);
}
else if (isLocal)
guc_dirty = true;
}
}
- else
+ else if (newval)
free(newval);
break;
}
struct config_generic *record;
static char buffer[256];
- record = find_option(name, ERROR);
+ record = find_option(name, false, ERROR);
if (record == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
/*
* Get the RESET value associated with the given option.
+ *
+ * Note: this is not re-entrant, due to use of static result buffer;
+ * not to mention that a string variable could have its reset_val changed.
+ * Beware of assuming the result value is good for very long.
*/
const char *
GetConfigOptionResetString(const char *name)
struct config_generic *record;
static char buffer[256];
- record = find_option(name, ERROR);
+ record = find_option(name, false, ERROR);
if (record == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
{
struct config_generic *record;
- record = find_option(name, ERROR);
+ record = find_option(name, false, ERROR);
/* On an unrecognized name, don't error, just return false. */
if (record == NULL)
return false;
return NULL;
/* Else get flags for the variable */
- record = find_option(name, ERROR);
+ record = find_option(name, true, ERROR);
if (record == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
}
+/*
+ * Common code for DefineCustomXXXVariable subroutines: allocate the
+ * new variable's config struct and fill in generic fields.
+ */
+static struct config_generic *
+init_custom_variable(const char *name,
+ const char *short_desc,
+ const char *long_desc,
+ GucContext context,
+ enum config_type type,
+ size_t sz)
+{
+ struct config_generic *gen;
+
+ gen = (struct config_generic *) guc_malloc(ERROR, sz);
+ memset(gen, 0, sz);
+
+ gen->name = guc_strdup(ERROR, name);
+ gen->context = context;
+ gen->group = CUSTOM_OPTIONS;
+ gen->short_desc = short_desc;
+ gen->long_desc = long_desc;
+ gen->vartype = type;
+
+ return gen;
+}
+
+/*
+ * Common code for DefineCustomXXXVariable subroutines: insert the new
+ * variable into the GUC variable array, replacing any placeholder.
+ */
static void
-define_custom_variable(struct config_generic * variable)
+define_custom_variable(struct config_generic *variable)
{
const char *name = variable->name;
const char **nameAddr = &name;
const char *value;
struct config_string *pHolder;
- struct config_generic **res = (struct config_generic **) bsearch(
- (void *) &nameAddr,
- (void *) guc_variables,
- num_guc_variables,
- sizeof(struct config_generic *),
- guc_var_compare);
+ struct config_generic **res;
+ res = (struct config_generic **) bsearch((void *) &nameAddr,
+ (void *) guc_variables,
+ num_guc_variables,
+ sizeof(struct config_generic *),
+ guc_var_compare);
if (res == NULL)
{
+ /* No placeholder to replace, so just add it */
add_guc_variable(variable, ERROR);
return;
}
errmsg("attempt to redefine parameter \"%s\"", name)));
Assert((*res)->vartype == PGC_STRING);
- pHolder = (struct config_string *) * res;
+ pHolder = (struct config_string *) (*res);
- /* We have the same name, no sorting is necessary */
+ /*
+ * Replace the placeholder.
+ * We aren't changing the name, so no re-sorting is necessary
+ */
*res = variable;
- value = *pHolder->variable;
-
/*
* Assign the string value stored in the placeholder to the real variable.
*
* assignment, since we don't want it to roll back if the current xact
* fails later.
*/
- set_config_option(name, value,
- pHolder->gen.context, pHolder->gen.source,
- false, true);
+ value = *pHolder->variable;
+
+ if (value)
+ set_config_option(name, value,
+ pHolder->gen.context, pHolder->gen.source,
+ false, true);
/*
* Free up as much as we conveniently can of the placeholder structure
free(pHolder);
}
-static void
-init_custom_variable(struct config_generic * gen,
- const char *name,
- const char *short_desc,
- const char *long_desc,
- GucContext context,
- enum config_type type)
-{
- gen->name = guc_strdup(ERROR, name);
- gen->context = context;
- gen->group = CUSTOM_OPTIONS;
- gen->short_desc = short_desc;
- gen->long_desc = long_desc;
- gen->vartype = type;
-}
-
void
DefineCustomBoolVariable(const char *name,
const char *short_desc,
GucBoolAssignHook assign_hook,
GucShowHook show_hook)
{
- size_t sz = sizeof(struct config_bool);
- struct config_bool *var = (struct config_bool *) guc_malloc(ERROR, sz);
-
- memset(var, 0, sz);
- init_custom_variable(&var->gen, name, short_desc, long_desc, context, PGC_BOOL);
+ struct config_bool *var;
+ var = (struct config_bool *)
+ init_custom_variable(name, short_desc, long_desc, context,
+ PGC_BOOL, sizeof(struct config_bool));
var->variable = valueAddr;
+ var->boot_val = *valueAddr;
var->reset_val = *valueAddr;
var->assign_hook = assign_hook;
var->show_hook = show_hook;
GucIntAssignHook assign_hook,
GucShowHook show_hook)
{
- size_t sz = sizeof(struct config_int);
- struct config_int *var = (struct config_int *) guc_malloc(ERROR, sz);
-
- memset(var, 0, sz);
- init_custom_variable(&var->gen, name, short_desc, long_desc, context, PGC_INT);
+ struct config_int *var;
+ var = (struct config_int *)
+ init_custom_variable(name, short_desc, long_desc, context,
+ PGC_INT, sizeof(struct config_int));
var->variable = valueAddr;
+ var->boot_val = *valueAddr;
var->reset_val = *valueAddr;
var->min = minValue;
var->max = maxValue;
GucRealAssignHook assign_hook,
GucShowHook show_hook)
{
- size_t sz = sizeof(struct config_real);
- struct config_real *var = (struct config_real *) guc_malloc(ERROR, sz);
-
- memset(var, 0, sz);
- init_custom_variable(&var->gen, name, short_desc, long_desc, context, PGC_REAL);
+ struct config_real *var;
+ var = (struct config_real *)
+ init_custom_variable(name, short_desc, long_desc, context,
+ PGC_REAL, sizeof(struct config_real));
var->variable = valueAddr;
+ var->boot_val = *valueAddr;
var->reset_val = *valueAddr;
var->min = minValue;
var->max = maxValue;
GucStringAssignHook assign_hook,
GucShowHook show_hook)
{
- size_t sz = sizeof(struct config_string);
- struct config_string *var = (struct config_string *) guc_malloc(ERROR, sz);
-
- memset(var, 0, sz);
- init_custom_variable(&var->gen, name, short_desc, long_desc, context, PGC_STRING);
+ struct config_string *var;
+ var = (struct config_string *)
+ init_custom_variable(name, short_desc, long_desc, context,
+ PGC_STRING, sizeof(struct config_string));
var->variable = valueAddr;
- var->reset_val = *valueAddr;
+ var->boot_val = *valueAddr;
+ /* we could probably do without strdup, but keep it like normal case */
+ if (var->boot_val)
+ var->reset_val = guc_strdup(ERROR, var->boot_val);
var->assign_hook = assign_hook;
var->show_hook = show_hook;
define_custom_variable(&var->gen);
void
GetPGVariable(const char *name, DestReceiver *dest)
{
- if (pg_strcasecmp(name, "all") == 0)
+ if (guc_name_compare(name, "all") == 0)
ShowAllGUCConfig(dest);
else
ShowGUCConfigOption(name, dest);
{
TupleDesc tupdesc;
- if (pg_strcasecmp(name, "all") == 0)
+ if (guc_name_compare(name, "all") == 0)
{
/* need a tuple descriptor representing three TEXT columns */
tupdesc = CreateTemplateTupleDesc(3, false);
{
struct config_generic *record;
- record = find_option(name, ERROR);
+ record = find_option(name, false, ERROR);
if (record == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
}
+/*
+ * Attempt (badly) to detect if a proposed new GUC setting is the same
+ * as the current value.
+ *
+ * XXX this does not really work because it doesn't account for the
+ * effects of canonicalization of string values by assign_hooks.
+ */
static bool
-is_newvalue_equal(struct config_generic * record, const char *newvalue)
+is_newvalue_equal(struct config_generic *record, const char *newvalue)
{
+ /* newvalue == NULL isn't supported */
+ Assert(newvalue != NULL);
+
switch (record->vartype)
{
case PGC_BOOL:
{
struct config_string *conf = (struct config_string *) record;
- return strcmp(*conf->variable, newvalue) == 0;
+ return *conf->variable != NULL &&
+ strcmp(*conf->variable, newvalue) == 0;
}
}
if ((varname = read_string_with_null(fp)) == NULL)
break;
- if ((record = find_option(varname, FATAL)) == NULL)
+ if ((record = find_option(varname, true, FATAL)) == NULL)
elog(FATAL, "failed to locate variable %s in exec config params file", varname);
if ((varvalue = read_string_with_null(fp)) == NULL)
elog(FATAL, "invalid format of exec config params file");
}
static const char *
-assign_log_min_messages(const char *newval,
- bool doit, GucSource source)
+assign_log_min_messages(const char *newval, bool doit, GucSource source)
{
return (assign_msglvl(&log_min_messages, newval, doit, source));
}
{
/*
* Check syntax. newval must be a comma separated list of identifiers.
- * Whitespace is allowed but skipped.
+ * Whitespace is allowed but removed from the result.
*/
bool hasSpaceAfterToken = false;
const char *cp = newval;
int symLen = 0;
- int c;
+ char c;
StringInfoData buf;
- /*
- * Resetting custom_variable_classes by removing it from the
- * configuration file will lead to newval = NULL
- */
- if (newval == NULL)
- return guc_strdup(ERROR, "");
-
initStringInfo(&buf);
- while ((c = *cp++) != 0)
+ while ((c = *cp++) != '\0')
{
if (isspace((unsigned char) c))
{
if (c == ',')
{
- hasSpaceAfterToken = false;
- if (symLen > 0)
+ if (symLen > 0) /* terminate identifier */
{
- symLen = 0;
appendStringInfoChar(&buf, ',');
+ symLen = 0;
}
+ hasSpaceAfterToken = false;
continue;
}
* Syntax error due to token following space after token or non
* alpha numeric character
*/
- ereport(LOG,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("invalid syntax for \"custom_variable_classes\": \"%s\"", newval)));
pfree(buf.data);
return NULL;
}
+ appendStringInfoChar(&buf, c);
symLen++;
- appendStringInfoChar(&buf, (char) c);
}
/* Remove stray ',' at end */
if (symLen == 0 && buf.len > 0)
buf.data[--buf.len] = '\0';
- if (buf.len == 0)
- newval = NULL;
- else if (doit)
- newval = guc_strdup(ERROR, buf.data);
+ /* GUC wants the result malloc'd */
+ newval = guc_strdup(LOG, buf.data);
pfree(buf.data);
return newval;
projects / thirdparty / postgresql.git / commitdiff
