2003-04-25 21:45:10 +02:00
|
|
|
/*--------------------------------------------------------------------
|
2000-05-31 02:28:42 +02:00
|
|
|
* guc.h
|
|
|
|
|
*
|
|
|
|
|
* External declarations pertaining to backend/utils/misc/guc.c and
|
|
|
|
|
* backend/utils/misc/guc-file.l
|
|
|
|
|
*
|
2009-01-01 18:24:05 +01:00
|
|
|
* Copyright (c) 2000-2009, PostgreSQL Global Development Group
|
2003-04-25 21:45:10 +02:00
|
|
|
* Written by Peter Eisentraut <peter_e@gmx.net>.
|
|
|
|
|
*
|
2009-08-29 21:26:52 +02:00
|
|
|
* $PostgreSQL: pgsql/src/include/utils/guc.h,v 1.103 2009/08/29 19:26:52 tgl Exp $
|
2003-04-25 21:45:10 +02:00
|
|
|
*--------------------------------------------------------------------
|
2000-05-31 02:28:42 +02:00
|
|
|
*/
|
|
|
|
|
#ifndef GUC_H
|
|
|
|
|
#define GUC_H
|
|
|
|
|
|
2007-09-03 20:46:30 +02:00
|
|
|
#include "nodes/parsenodes.h"
|
2003-05-06 22:26:28 +02:00
|
|
|
#include "tcop/dest.h"
|
2002-03-01 23:45:19 +01:00
|
|
|
#include "utils/array.h"
|
|
|
|
|
|
2002-05-17 03:19:19 +02:00
|
|
|
|
2000-05-31 02:28:42 +02:00
|
|
|
/*
|
2000-06-23 00:31:24 +02:00
|
|
|
* Certain options can only be set at certain times. The rules are
|
|
|
|
|
* like this:
|
|
|
|
|
*
|
2003-04-25 21:45:10 +02:00
|
|
|
* INTERNAL options cannot be set by the user at all, but only through
|
|
|
|
|
* internal processes ("server_version" is an example). These are GUC
|
|
|
|
|
* variables only so they can be shown by SHOW, etc.
|
|
|
|
|
*
|
2000-06-23 00:31:24 +02:00
|
|
|
* POSTMASTER options can only be set when the postmaster starts,
|
|
|
|
|
* either from the configuration file or the command line.
|
|
|
|
|
*
|
|
|
|
|
* SIGHUP options can only be set at postmaster startup or by changing
|
|
|
|
|
* the configuration file and sending the HUP signal to the postmaster
|
2006-03-07 04:01:22 +01:00
|
|
|
* or a backend process. (Notice that the signal receipt will not be
|
|
|
|
|
* evaluated immediately. The postmaster and the backend check it at a
|
|
|
|
|
* certain point in their main loop. It's safer to wait than to read a
|
|
|
|
|
* file asynchronously.)
|
2000-06-23 00:31:24 +02:00
|
|
|
*
|
2001-09-30 22:16:21 +02:00
|
|
|
* BACKEND options can only be set at postmaster startup, from the
|
2003-04-25 21:45:10 +02:00
|
|
|
* configuration file, or by client request in the connection startup
|
|
|
|
|
* packet (e.g., from libpq's PGOPTIONS variable). Furthermore, an
|
|
|
|
|
* already-started backend will ignore changes to such an option in the
|
2003-08-04 02:43:34 +02:00
|
|
|
* configuration file. The idea is that these options are fixed for a
|
2003-04-25 21:45:10 +02:00
|
|
|
* given backend once it's started, but they can vary across backends.
|
2000-06-23 00:31:24 +02:00
|
|
|
*
|
|
|
|
|
* SUSET options can be set at postmaster startup, with the SIGHUP
|
2004-11-24 20:51:05 +01:00
|
|
|
* mechanism, or from SQL if you're a superuser.
|
2000-06-23 00:31:24 +02:00
|
|
|
*
|
|
|
|
|
* USERSET options can be set by anyone any time.
|
2000-05-31 02:28:42 +02:00
|
|
|
*/
|
2001-03-22 05:01:46 +01:00
|
|
|
typedef enum
|
|
|
|
|
{
|
2003-07-28 21:31:32 +02:00
|
|
|
PGC_INTERNAL,
|
|
|
|
|
PGC_POSTMASTER,
|
|
|
|
|
PGC_SIGHUP,
|
|
|
|
|
PGC_BACKEND,
|
|
|
|
|
PGC_SUSET,
|
|
|
|
|
PGC_USERSET
|
2000-05-31 02:28:42 +02:00
|
|
|
} GucContext;
|
|
|
|
|
|
2002-02-23 02:31:37 +01:00
|
|
|
/*
|
|
|
|
|
* The following type records the source of the current setting. A
|
|
|
|
|
* new setting can only take effect if the previous setting had the
|
|
|
|
|
* same or lower level. (E.g, changing the config file doesn't
|
2002-05-17 03:19:19 +02:00
|
|
|
* override the postmaster command line.) Tracking the source allows us
|
|
|
|
|
* to process sources in any convenient order without affecting results.
|
|
|
|
|
* Sources <= PGC_S_OVERRIDE will set the default used by RESET, as well
|
2003-04-25 21:45:10 +02:00
|
|
|
* as the current value. Note that source == PGC_S_OVERRIDE should be
|
|
|
|
|
* used when setting a PGC_INTERNAL option.
|
2003-07-27 06:35:54 +02:00
|
|
|
*
|
2004-11-14 20:35:35 +01:00
|
|
|
* PGC_S_INTERACTIVE isn't actually a source value, but is the
|
2004-01-19 20:04:40 +01:00
|
|
|
* dividing line between "interactive" and "non-interactive" sources for
|
|
|
|
|
* error reporting purposes.
|
|
|
|
|
*
|
|
|
|
|
* PGC_S_TEST is used when testing values to be stored as per-database or
|
|
|
|
|
* per-user defaults ("doit" will always be false, so this never gets stored
|
2004-08-29 07:07:03 +02:00
|
|
|
* as the actual source of any value). This is an interactive case, but
|
2004-01-19 20:04:40 +01:00
|
|
|
* it needs its own source value because some assign hooks need to make
|
|
|
|
|
* different validity checks in this case.
|
2002-02-23 02:31:37 +01:00
|
|
|
*/
|
|
|
|
|
typedef enum
|
|
|
|
|
{
|
2003-07-28 21:31:32 +02:00
|
|
|
PGC_S_DEFAULT, /* wired-in default */
|
|
|
|
|
PGC_S_ENV_VAR, /* postmaster environment variable */
|
|
|
|
|
PGC_S_FILE, /* postgresql.conf */
|
|
|
|
|
PGC_S_ARGV, /* postmaster command line */
|
|
|
|
|
PGC_S_DATABASE, /* per-database setting */
|
|
|
|
|
PGC_S_USER, /* per-user setting */
|
|
|
|
|
PGC_S_CLIENT, /* from client connection request */
|
|
|
|
|
PGC_S_OVERRIDE, /* special case to forcibly set default */
|
2004-01-19 20:04:40 +01:00
|
|
|
PGC_S_INTERACTIVE, /* dividing line for error reporting */
|
|
|
|
|
PGC_S_TEST, /* test per-database or per-user setting */
|
2003-07-28 21:31:32 +02:00
|
|
|
PGC_S_SESSION /* SET command */
|
2002-02-23 02:31:37 +01:00
|
|
|
} GucSource;
|
2000-05-31 02:28:42 +02:00
|
|
|
|
2008-03-16 17:42:44 +01:00
|
|
|
/*
|
|
|
|
|
* Enum values are made up of an array of name-value pairs
|
|
|
|
|
*/
|
|
|
|
|
struct config_enum_entry
|
|
|
|
|
{
|
|
|
|
|
const char *name;
|
2009-06-11 16:49:15 +02:00
|
|
|
int val;
|
2008-05-28 11:04:06 +02:00
|
|
|
bool hidden;
|
2008-03-16 17:42:44 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
typedef const char *(*GucStringAssignHook) (const char *newval, bool doit, GucSource source);
|
|
|
|
|
typedef bool (*GucBoolAssignHook) (bool newval, bool doit, GucSource source);
|
|
|
|
|
typedef bool (*GucIntAssignHook) (int newval, bool doit, GucSource source);
|
|
|
|
|
typedef bool (*GucRealAssignHook) (double newval, bool doit, GucSource source);
|
2008-03-10 13:55:13 +01:00
|
|
|
typedef bool (*GucEnumAssignHook) (int newval, bool doit, GucSource source);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
typedef const char *(*GucShowHook) (void);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
2007-09-11 02:06:42 +02:00
|
|
|
typedef enum
|
|
|
|
|
{
|
|
|
|
|
/* Types of set_config_option actions */
|
|
|
|
|
GUC_ACTION_SET, /* regular SET command */
|
|
|
|
|
GUC_ACTION_LOCAL, /* SET LOCAL command */
|
|
|
|
|
GUC_ACTION_SAVE /* function SET option */
|
2007-11-15 23:25:18 +01:00
|
|
|
} GucAction;
|
2007-09-11 02:06:42 +02:00
|
|
|
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
#define GUC_QUALIFIER_SEPARATOR '.'
|
|
|
|
|
|
2008-11-19 02:10:24 +01:00
|
|
|
/*
|
|
|
|
|
* bit values in "flags" of a GUC variable
|
|
|
|
|
*/
|
|
|
|
|
#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 */
|
|
|
|
|
#define GUC_REPORT 0x0010 /* auto-report changes to client */
|
|
|
|
|
#define GUC_NOT_IN_SAMPLE 0x0020 /* not in postgresql.conf.sample */
|
|
|
|
|
#define GUC_DISALLOW_IN_FILE 0x0040 /* can't set in postgresql.conf */
|
|
|
|
|
#define GUC_CUSTOM_PLACEHOLDER 0x0080 /* placeholder for custom variable */
|
|
|
|
|
#define GUC_SUPERUSER_ONLY 0x0100 /* show only to superusers */
|
|
|
|
|
#define GUC_IS_NAME 0x0200 /* limit string to NAMEDATALEN-1 */
|
|
|
|
|
|
|
|
|
|
#define GUC_UNIT_KB 0x0400 /* value is in kilobytes */
|
|
|
|
|
#define GUC_UNIT_BLOCKS 0x0800 /* value is in blocks */
|
|
|
|
|
#define GUC_UNIT_XBLOCKS 0x0C00 /* value is in xlog blocks */
|
|
|
|
|
#define GUC_UNIT_MEMORY 0x0C00 /* mask for KB, BLOCKS, XBLOCKS */
|
|
|
|
|
|
|
|
|
|
#define GUC_UNIT_MS 0x1000 /* value is in milliseconds */
|
|
|
|
|
#define GUC_UNIT_S 0x2000 /* value is in seconds */
|
|
|
|
|
#define GUC_UNIT_MIN 0x4000 /* value is in minutes */
|
|
|
|
|
#define GUC_UNIT_TIME 0x7000 /* mask for MS, S, MIN */
|
|
|
|
|
|
2003-04-25 21:45:10 +02:00
|
|
|
/* GUC vars that are actually declared in guc.c, rather than elsewhere */
|
|
|
|
|
extern bool log_duration;
|
|
|
|
|
extern bool Debug_print_plan;
|
|
|
|
|
extern bool Debug_print_parse;
|
|
|
|
|
extern bool Debug_print_rewritten;
|
|
|
|
|
extern bool Debug_pretty_print;
|
|
|
|
|
|
|
|
|
|
extern bool log_parser_stats;
|
|
|
|
|
extern bool log_planner_stats;
|
|
|
|
|
extern bool log_executor_stats;
|
|
|
|
|
extern bool log_statement_stats;
|
|
|
|
|
extern bool log_btree_build_stats;
|
|
|
|
|
|
2007-07-25 14:22:54 +02:00
|
|
|
extern PGDLLIMPORT bool check_function_bodies;
|
2003-12-01 23:08:02 +01:00
|
|
|
extern bool default_with_oids;
|
2006-10-19 20:32:48 +02:00
|
|
|
extern bool SQL_inheritance;
|
2003-12-01 23:08:02 +01:00
|
|
|
|
2003-04-25 21:45:10 +02:00
|
|
|
extern int log_min_error_statement;
|
|
|
|
|
extern int log_min_messages;
|
|
|
|
|
extern int client_min_messages;
|
2003-07-28 21:31:32 +02:00
|
|
|
extern int log_min_duration_statement;
|
2007-01-09 22:31:17 +01:00
|
|
|
extern int log_temp_files;
|
2003-04-25 21:45:10 +02:00
|
|
|
|
2005-03-20 00:27:11 +01:00
|
|
|
extern int num_temp_buffers;
|
|
|
|
|
|
2004-10-08 03:36:36 +02:00
|
|
|
extern char *ConfigFileName;
|
2004-10-10 01:13:22 +02:00
|
|
|
extern char *HbaFileName;
|
|
|
|
|
extern char *IdentFileName;
|
|
|
|
|
extern char *external_pid_file;
|
2004-07-11 02:18:45 +02:00
|
|
|
|
2005-10-15 04:49:52 +02:00
|
|
|
extern int tcp_keepalives_idle;
|
|
|
|
|
extern int tcp_keepalives_interval;
|
|
|
|
|
extern int tcp_keepalives_count;
|
2003-04-25 21:45:10 +02:00
|
|
|
|
2001-06-13 00:54:06 +02:00
|
|
|
extern void SetConfigOption(const char *name, const char *value,
|
2002-02-23 02:31:37 +01:00
|
|
|
GucContext context, GucSource source);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
|
|
|
|
extern void DefineCustomBoolVariable(
|
2004-08-29 07:07:03 +02:00
|
|
|
const char *name,
|
|
|
|
|
const char *short_desc,
|
|
|
|
|
const char *long_desc,
|
|
|
|
|
bool *valueAddr,
|
2008-11-19 02:10:24 +01:00
|
|
|
bool bootValue,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucContext context,
|
2008-11-19 02:10:24 +01:00
|
|
|
int flags,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucBoolAssignHook assign_hook,
|
|
|
|
|
GucShowHook show_hook);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
|
|
|
|
extern void DefineCustomIntVariable(
|
2004-08-29 07:07:03 +02:00
|
|
|
const char *name,
|
|
|
|
|
const char *short_desc,
|
|
|
|
|
const char *long_desc,
|
|
|
|
|
int *valueAddr,
|
2008-11-19 02:10:24 +01:00
|
|
|
int bootValue,
|
2005-03-25 17:17:28 +01:00
|
|
|
int minValue,
|
|
|
|
|
int maxValue,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucContext context,
|
2008-11-19 02:10:24 +01:00
|
|
|
int flags,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucIntAssignHook assign_hook,
|
|
|
|
|
GucShowHook show_hook);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
|
|
|
|
extern void DefineCustomRealVariable(
|
2004-08-29 07:07:03 +02:00
|
|
|
const char *name,
|
|
|
|
|
const char *short_desc,
|
|
|
|
|
const char *long_desc,
|
|
|
|
|
double *valueAddr,
|
2008-11-19 02:10:24 +01:00
|
|
|
double bootValue,
|
2005-03-25 17:17:28 +01:00
|
|
|
double minValue,
|
|
|
|
|
double maxValue,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucContext context,
|
2008-11-19 02:10:24 +01:00
|
|
|
int flags,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucRealAssignHook assign_hook,
|
|
|
|
|
GucShowHook show_hook);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
|
|
|
|
extern void DefineCustomStringVariable(
|
2004-08-29 07:07:03 +02:00
|
|
|
const char *name,
|
|
|
|
|
const char *short_desc,
|
|
|
|
|
const char *long_desc,
|
|
|
|
|
char **valueAddr,
|
2008-11-19 02:10:24 +01:00
|
|
|
const char *bootValue,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucContext context,
|
2008-11-19 02:10:24 +01:00
|
|
|
int flags,
|
2004-08-29 07:07:03 +02:00
|
|
|
GucStringAssignHook assign_hook,
|
|
|
|
|
GucShowHook show_hook);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
2008-03-16 17:42:44 +01:00
|
|
|
extern void DefineCustomEnumVariable(
|
2009-06-11 16:49:15 +02:00
|
|
|
const char *name,
|
|
|
|
|
const char *short_desc,
|
|
|
|
|
const char *long_desc,
|
|
|
|
|
int *valueAddr,
|
|
|
|
|
int bootValue,
|
|
|
|
|
const struct config_enum_entry * options,
|
|
|
|
|
GucContext context,
|
|
|
|
|
int flags,
|
|
|
|
|
GucEnumAssignHook assign_hook,
|
|
|
|
|
GucShowHook show_hook);
|
2008-03-16 17:42:44 +01:00
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
extern void EmitWarningsOnPlaceholders(const char *className);
|
The patch adresses the TODO list item "Allow external interfaces to
extend the GUC variable set".
Plugin modules like the pl<lang> modules needs a way to declare
configuration parameters. The postmaster has no knowledge of such
modules when it reads the postgresql.conf file. Rather than allowing
totally unknown configuration parameters, the concept of a variable
"class" is introduced. Variables that belongs to a declared classes will
create a placeholder value of string type and will not generate an
error. When a module is loaded, it will declare variables for such a
class and make those variables "consume" any placeholders that has been
defined. Finally, the module will generate warnings for unrecognized
placeholders defined for its class.
More detail:
The design is outlined after the suggestions made by Tom Lane and Joe
Conway in this thread:
http://archives.postgresql.org/pgsql-hackers/2004-02/msg00229.php
A new string variable 'custom_variable_classes' is introduced. This
variable is a comma separated string of identifiers. Each identifier
denots a 'class' that will allow its members to be added without error.
This variable must be defined in postmaster.conf.
The lexer (guc_file.l) is changed so that it can accept a qualified name
in the form <ID>.<ID> as the name of a variable. I also changed so that
the 'custom_variable_classes', if found, is added first of all variables
in order to remove the order of declaration issue.
The guc_variables table is made more dynamic. It is originally created
with 20% slack and can grow dynamically. A capacity is introduced to
avoid resizing every time a new variable is added. guc_variables and
num_guc_variables becomes static (hidden).
The GucInfoMain now uses the new function get_guc_variables() and
GetNumConfigOptions instead or using the guc_variables directly.
The find_option() function, when passed a missing name, will check if
the name is qualified. If the name is qualified and if the qualifier
denotes a class included in the 'custom_variable_classes', a placeholder
variable will be created. Such a placeholder will not participate in a
list operation but will otherwise function as a normal string variable.
Define<type>GucVariable() functions will be added, one for each variable
type. They are inteded to be used by add-on modules like the pl<lang>
mappings. Example:
extern void DefineCustomBoolVariable(
const char* name,
const char* short_desc,
const char* long_desc,
bool* valueAddr,
GucContext context,
GucBoolAssignHook assign_hook,
GucShowHook show_hook);
(I created typedefs for the assign-hook and show-hook functions). A call
to these functions will define a new GUC-variable. If a placeholder
exists it will be replaced but it's value will be used in place of the
default value. The valueAddr is assumed ot point at a default value when
the define function is called. The only constraint that is imposed on a
Custom variable is that its name is qualified.
Finally, a function:
void EmittWarningsOnPlacholders(const char* className)
was added. This function should be called when a module has completed
its variable definitions. At that time, no placeholders should remain
for the class that the module uses. If they do, elog(INFO, ...) messages
will be issued to inform the user that unrecognized variables are
present.
Thomas Hallgren
2004-05-26 17:07:41 +02:00
|
|
|
|
2001-06-13 00:54:06 +02:00
|
|
|
extern const char *GetConfigOption(const char *name);
|
2002-05-17 03:19:19 +02:00
|
|
|
extern const char *GetConfigOptionResetString(const char *name);
|
2001-06-13 00:54:06 +02:00
|
|
|
extern void ProcessConfigFile(GucContext context);
|
2002-05-17 03:19:19 +02:00
|
|
|
extern void InitializeGUCOptions(void);
|
2004-10-08 03:36:36 +02:00
|
|
|
extern bool SelectConfigFiles(const char *userDoption, const char *progname);
|
2002-05-17 03:19:19 +02:00
|
|
|
extern void ResetAllOptions(void);
|
2007-09-03 02:39:26 +02:00
|
|
|
extern void AtStart_GUC(void);
|
|
|
|
|
extern int NewGUCNestLevel(void);
|
|
|
|
|
extern void AtEOXact_GUC(bool isCommit, int nestLevel);
|
2003-04-25 21:45:10 +02:00
|
|
|
extern void BeginReportingGUCOptions(void);
|
2001-06-13 00:54:06 +02:00
|
|
|
extern void ParseLongOption(const char *string, char **name, char **value);
|
2008-07-23 19:29:53 +02:00
|
|
|
extern bool parse_int(const char *value, int *result, int flags,
|
2009-06-11 16:49:15 +02:00
|
|
|
const char **hintmsg);
|
2008-07-23 19:29:53 +02:00
|
|
|
extern bool parse_real(const char *value, double *result);
|
2001-06-13 00:54:06 +02:00
|
|
|
extern bool set_config_option(const char *name, const char *value,
|
2002-09-04 22:31:48 +02:00
|
|
|
GucContext context, GucSource source,
|
2007-09-11 02:06:42 +02:00
|
|
|
GucAction action, bool changeVal);
|
2002-07-20 17:12:56 +02:00
|
|
|
extern char *GetConfigOptionByName(const char *name, const char **varname);
|
2003-07-27 06:35:54 +02:00
|
|
|
extern void GetConfigOptionByNum(int varnum, const char **values, bool *noshow);
|
2002-09-04 22:31:48 +02:00
|
|
|
extern int GetNumConfigOptions(void);
|
2000-05-31 02:28:42 +02:00
|
|
|
|
2002-05-17 03:19:19 +02:00
|
|
|
extern void SetPGVariable(const char *name, List *args, bool is_local);
|
2003-05-06 22:26:28 +02:00
|
|
|
extern void GetPGVariable(const char *name, DestReceiver *dest);
|
|
|
|
|
extern TupleDesc GetPGVariableResultDesc(const char *name);
|
2002-05-17 03:19:19 +02:00
|
|
|
|
2007-09-03 20:46:30 +02:00
|
|
|
extern void ExecSetVariableStmt(VariableSetStmt *stmt);
|
|
|
|
|
extern char *ExtractSetVariableArgs(VariableSetStmt *stmt);
|
2002-05-17 03:19:19 +02:00
|
|
|
|
2007-09-03 02:39:26 +02:00
|
|
|
extern void ProcessGUCArray(ArrayType *array,
|
2007-09-11 02:06:42 +02:00
|
|
|
GucContext context, GucSource source, GucAction action);
|
2002-03-01 23:45:19 +01:00
|
|
|
extern ArrayType *GUCArrayAdd(ArrayType *array, const char *name, const char *value);
|
|
|
|
|
extern ArrayType *GUCArrayDelete(ArrayType *array, const char *name);
|
2000-05-31 02:28:42 +02:00
|
|
|
|
2007-12-28 01:23:23 +01:00
|
|
|
extern int GUC_complaint_elevel(GucSource source);
|
|
|
|
|
|
2006-07-29 05:02:56 +02:00
|
|
|
extern void pg_timezone_abbrev_initialize(void);
|
|
|
|
|
|
2003-05-03 00:02:47 +02:00
|
|
|
#ifdef EXEC_BACKEND
|
2004-05-28 07:13:32 +02:00
|
|
|
extern void write_nondefault_variables(GucContext context);
|
|
|
|
|
extern void read_nondefault_variables(void);
|
2003-05-03 00:02:47 +02:00
|
|
|
#endif
|
|
|
|
|
|
2004-01-19 20:04:40 +01:00
|
|
|
/*
|
|
|
|
|
* The following functions are not in guc.c, but are declared here to avoid
|
|
|
|
|
* having to include guc.h in some widely used headers that it really doesn't
|
|
|
|
|
* belong in.
|
|
|
|
|
*/
|
|
|
|
|
|
2004-11-05 20:17:13 +01:00
|
|
|
/* in commands/tablespace.c */
|
|
|
|
|
extern const char *assign_default_tablespace(const char *newval,
|
2005-10-15 04:49:52 +02:00
|
|
|
bool doit, GucSource source);
|
2007-06-03 19:08:34 +02:00
|
|
|
extern const char *assign_temp_tablespaces(const char *newval,
|
2007-11-15 22:14:46 +01:00
|
|
|
bool doit, GucSource source);
|
2004-11-05 20:17:13 +01:00
|
|
|
|
2004-01-19 20:04:40 +01:00
|
|
|
/* in catalog/namespace.c */
|
|
|
|
|
extern const char *assign_search_path(const char *newval,
|
|
|
|
|
bool doit, GucSource source);
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-01-19 20:04:40 +01:00
|
|
|
/* in access/transam/xlog.c */
|
2008-05-12 10:35:05 +02:00
|
|
|
extern bool assign_xlog_sync_method(int newval,
|
2009-06-11 16:49:15 +02:00
|
|
|
bool doit, GucSource source);
|
2004-01-19 20:04:40 +01:00
|
|
|
|
2001-11-05 18:46:40 +01:00
|
|
|
#endif /* GUC_H */
|
