rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Replace the sorted array of GUC variables with a hash table. 

This gets rid of bsearch() in favor of hashed lookup.  The main
advantage is that it becomes far cheaper to add new GUCs, since
we needn't re-sort the pointer array.  Adding N new GUCs had
been O(N^2 log N), but now it's closer to O(N).  We need to
sort only in SHOW ALL and equivalent functions, which are
hopefully not performance-critical to anybody.

Also, merge GetNumConfigOptions() into get_guc_variables(),
because in a world where the set of GUCs isn't fairly static
you really want to consider those two results as tied together
not independent.

Discussion: https://postgr.es/m/2982579.1662416866@sss.pgh.pa.us
This commit is contained in:
Tom Lane 2022-10-14 12:26:39 -04:00
parent 407b50f2d4
commit 3057465acf
5 changed files with 272 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

385
src/backend/utils/misc/guc.c
View File

@ -36,6 +36,7 @@
#include "guc_internal.h"
#include "libpq/pqformat.h"
#include "parser/scansup.h"
#include "port/pg_bitutils.h"
#include "storage/fd.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
@ -192,16 +193,17 @@ static const char *const map_old_guc_names[] = {
static MemoryContext GUCMemoryContext;
/*
* Actual lookup of variables is done through this single, sorted array.
* We use a dynahash table to look up GUCs by name, or to iterate through
* all the GUCs. The gucname field is redundant with gucvar->name, but
* dynahash makes it too painful to not store the hash key separately.
*/
static struct config_generic **guc_variables;
/* Current number of variables contained in the vector */
static int num_guc_variables;
/* Vector capacity */
static int size_guc_variables;
typedef struct
{
const char *gucname; /* hash key */
struct config_generic *gucvar; /* -> GUC's defining structure */
} GUCHashEntry;
static HTAB *guc_hashtab; /* entries are GUCHashEntrys */
static bool guc_dirty; /* true if need to do commit/abort work */
@ -213,6 +215,8 @@ static int GUCNestLevel = 0; /* 1 when in main transaction */
static int guc_var_compare(const void *a, const void *b);
static uint32 guc_name_hash(const void *key, Size keysize);
static int guc_name_match(const void *key1, const void *key2, Size keysize);
static void InitializeGUCOptionsFromEnvironment(void);
static void InitializeOneGUCOption(struct config_generic *gconf);
static void pg_timezone_abbrev_initialize(void);
@ -262,7 +266,8 @@ ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
ConfigVariable *item,
*head,
*tail;
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
/* Parse the main config file into a list of option names and values */
ConfFileWithError = ConfigFileName;
@ -337,9 +342,10 @@ ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
* need this so that we can tell below which ones have been removed from
* the file since we last processed it.
*/
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *gconf = guc_variables[i];
struct config_generic *gconf = hentry->gucvar;
gconf->status &= ~GUC_IS_IN_FILE;
}
@ -423,9 +429,10 @@ ProcessConfigFileInternal(GucContext context, bool applySettings, int elevel)
* boot-time defaults. If such a variable can't be changed after startup,
* report that and continue.
*/
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *gconf = guc_variables[i];
struct config_generic *gconf = hentry->gucvar;
GucStack *stack;
if (gconf->reset_source != PGC_S_FILE ||
@ -836,17 +843,38 @@ discard_stack_value(struct config_generic *gconf, config_var_value *val)
/*
* Fetch the sorted array pointer (exported for help_config.c's use ONLY)
* Fetch a palloc'd, sorted array of GUC struct pointers
*
* The array length is returned into *num_vars.
*/
struct config_generic **
get_guc_variables(void)
get_guc_variables(int *num_vars)
{
return guc_variables;
struct config_generic **result;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
int i;
*num_vars = hash_get_num_entries(guc_hashtab);
result = palloc(sizeof(struct config_generic *) * *num_vars);
/* Extract pointers from the hash table */
i = 0;
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
result[i++] = hentry->gucvar;
Assert(i == *num_vars);
/* Sort by name */
qsort(result, *num_vars,
sizeof(struct config_generic *), guc_var_compare);
return result;
}
/*
* Build the sorted array. This is split out so that help_config.c can
* Build the GUC hash table. This is split out so that help_config.c can
* extract all the variables without running all of InitializeGUCOptions.
* It's not meant for use anyplace else.
*/
@ -855,7 +883,9 @@ build_guc_variables(void)
{
int size_vars;
int num_vars = 0;
struct config_generic **guc_vars;
HASHCTL hash_ctl;
GUCHashEntry *hentry;
bool found;
int i;
/*
@ -911,74 +941,106 @@ build_guc_variables(void)
}
/*
* Create table with 20% slack
* Create hash table with 20% slack
*/
size_vars = num_vars + num_vars / 4;
guc_vars = (struct config_generic **)
guc_malloc(FATAL, size_vars * sizeof(struct config_generic *));
num_vars = 0;
hash_ctl.keysize = sizeof(char *);
hash_ctl.entrysize = sizeof(GUCHashEntry);
hash_ctl.hash = guc_name_hash;
hash_ctl.match = guc_name_match;
hash_ctl.hcxt = GUCMemoryContext;
guc_hashtab = hash_create("GUC hash table",
size_vars,
&hash_ctl,
HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT);
for (i = 0; ConfigureNamesBool[i].gen.name; i++)
guc_vars[num_vars++] = &ConfigureNamesBool[i].gen;
{
struct config_generic *gucvar = &ConfigureNamesBool[i].gen;
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&gucvar->name,
HASH_ENTER,
&found);
Assert(!found);
hentry->gucvar = gucvar;
}
for (i = 0; ConfigureNamesInt[i].gen.name; i++)
guc_vars[num_vars++] = &ConfigureNamesInt[i].gen;
{
struct config_generic *gucvar = &ConfigureNamesInt[i].gen;
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&gucvar->name,
HASH_ENTER,
&found);
Assert(!found);
hentry->gucvar = gucvar;
}
for (i = 0; ConfigureNamesReal[i].gen.name; i++)
guc_vars[num_vars++] = &ConfigureNamesReal[i].gen;
{
struct config_generic *gucvar = &ConfigureNamesReal[i].gen;
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&gucvar->name,
HASH_ENTER,
&found);
Assert(!found);
hentry->gucvar = gucvar;
}
for (i = 0; ConfigureNamesString[i].gen.name; i++)
guc_vars[num_vars++] = &ConfigureNamesString[i].gen;
{
struct config_generic *gucvar = &ConfigureNamesString[i].gen;
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&gucvar->name,
HASH_ENTER,
&found);
Assert(!found);
hentry->gucvar = gucvar;
}
for (i = 0; ConfigureNamesEnum[i].gen.name; i++)
guc_vars[num_vars++] = &ConfigureNamesEnum[i].gen;
{
struct config_generic *gucvar = &ConfigureNamesEnum[i].gen;
guc_free(guc_variables);
guc_variables = guc_vars;
num_guc_variables = num_vars;
size_guc_variables = size_vars;
qsort((void *) guc_variables, num_guc_variables,
sizeof(struct config_generic *), guc_var_compare);
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&gucvar->name,
HASH_ENTER,
&found);
Assert(!found);
hentry->gucvar = gucvar;
}
Assert(num_vars == hash_get_num_entries(guc_hashtab));
}
/*
* Add a new GUC variable to the list of known variables. The
* list is expanded if needed.
* Add a new GUC variable to the hash of known variables. The
* hash is expanded if needed.
*/
static bool
add_guc_variable(struct config_generic *var, int elevel)
{
if (num_guc_variables + 1 >= size_guc_variables)
GUCHashEntry *hentry;
bool found;
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&var->name,
HASH_ENTER_NULL,
&found);
if (unlikely(hentry == NULL))
{
/*
* Increase the vector by 25%
*/
int size_vars = size_guc_variables + size_guc_variables / 4;
struct config_generic **guc_vars;
if (size_vars == 0)
{
size_vars = 100;
guc_vars = (struct config_generic **)
guc_malloc(elevel, size_vars * sizeof(struct config_generic *));
}
else
{
guc_vars = (struct config_generic **)
guc_realloc(elevel, guc_variables, size_vars * sizeof(struct config_generic *));
}
if (guc_vars == NULL)
return false; /* out of memory */
guc_variables = guc_vars;
size_guc_variables = size_vars;
ereport(elevel,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory")));
return false; /* out of memory */
}
guc_variables[num_guc_variables++] = var;
qsort((void *) guc_variables, num_guc_variables,
sizeof(struct config_generic *), guc_var_compare);
Assert(!found);
hentry->gucvar = var;
return true;
}
@ -1087,23 +1149,18 @@ struct config_generic *
find_option(const char *name, bool create_placeholders, bool skip_errors,
int elevel)
{
const char **key = &name;
struct config_generic **res;
GUCHashEntry *hentry;
int i;
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;
/* Look it up using the hash table. */
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&name,
HASH_FIND,
NULL);
if (hentry)
return hentry->gucvar;
/*
* See if the name is an obsolete name for a variable. We assume that the
@ -1176,7 +1233,7 @@ find_option(const char *name, bool create_placeholders, bool skip_errors,
/*
* comparator for qsorting and bsearching guc_variables array
* comparator for qsorting an array of GUC pointers
*/
static int
guc_var_compare(const void *a, const void *b)
@ -1195,7 +1252,7 @@ guc_name_compare(const char *namea, const char *nameb)
{
/*
* The temptation to use strcasecmp() here must be resisted, because the
* array ordering has to remain stable across setlocale() calls. So, build
* hash mapping has to remain stable across setlocale() calls. So, build
* our own with a simple ASCII-only downcasing.
*/
while (*namea && *nameb)
@ -1217,6 +1274,42 @@ guc_name_compare(const char *namea, const char *nameb)
return 0;
}
/*
* Hash function that's compatible with guc_name_compare
*/
static uint32
guc_name_hash(const void *key, Size keysize)
{
uint32 result = 0;
const char *name = *(const char *const *) key;
while (*name)
{
char ch = *name++;
/* Case-fold in the same way as guc_name_compare */
if (ch >= 'A' && ch <= 'Z')
ch += 'a' - 'A';
/* Merge into hash ... not very bright, but it needn't be */
result = pg_rotate_left32(result, 5);
result ^= (uint32) ch;
}
return result;
}
/*
* Dynahash match function to use in guc_hashtab
*/
static int
guc_name_match(const void *key1, const void *key2, Size keysize)
{
const char *name1 = *(const char *const *) key1;
const char *name2 = *(const char *const *) key2;
return guc_name_compare(name1, name2);
}
/*
* Convert a GUC name to the form that should be used in pg_parameter_acl.
@ -1286,7 +1379,8 @@ check_GUC_name_for_parameter_acl(const char *name)
void
InitializeGUCOptions(void)
{
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
/*
* Before log_line_prefix could possibly receive a nonempty setting, make
@ -1295,7 +1389,7 @@ InitializeGUCOptions(void)
pg_timezone_initialize();
/*
* Create GUCMemoryContext and build sorted array of all GUC variables.
* Create GUCMemoryContext and build hash table of all GUC variables.
*/
build_guc_variables();
@ -1303,9 +1397,10 @@ InitializeGUCOptions(void)
* Load all variables with their compiled-in defaults, and initialize
* status fields as needed.
*/
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
InitializeOneGUCOption(guc_variables[i]);
InitializeOneGUCOption(hentry->gucvar);
}
guc_dirty = false;
@ -1740,11 +1835,13 @@ pg_timezone_abbrev_initialize(void)
void
ResetAllOptions(void)
{
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *gconf = guc_variables[i];
struct config_generic *gconf = hentry->gucvar;
/* Don't reset non-SET-able values */
if (gconf->context != PGC_SUSET &&
@ -1962,7 +2059,8 @@ void
AtEOXact_GUC(bool isCommit, int nestLevel)
{
bool still_dirty;
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
/*
* Note: it's possible to get here with GUCNestLevel == nestLevel-1 during
@ -1981,9 +2079,10 @@ AtEOXact_GUC(bool isCommit, int nestLevel)
}
still_dirty = false;
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *gconf = guc_variables[i];
struct config_generic *gconf = hentry->gucvar;
GucStack *stack;
/*
@ -2252,7 +2351,8 @@ AtEOXact_GUC(bool isCommit, int nestLevel)
void
BeginReportingGUCOptions(void)
{
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
/*
* Don't do anything unless talking to an interactive frontend.
@ -2275,9 +2375,10 @@ BeginReportingGUCOptions(void)
PGC_INTERNAL, PGC_S_OVERRIDE);
/* Transmit initial values of interesting variables */
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *conf = guc_variables[i];
struct config_generic *conf = hentry->gucvar;
if (conf->flags & GUC_REPORT)
ReportGUCOption(conf);
@ -2302,6 +2403,9 @@ BeginReportingGUCOptions(void)
void
ReportChangedGUCOptions(void)
{
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
/* Quick exit if not (yet) enabled */
if (!reporting_enabled)
return;
@ -2321,9 +2425,10 @@ ReportChangedGUCOptions(void)
return;
/* Transmit new values of interesting variables */
for (int i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *conf = guc_variables[i];
struct config_generic *conf = hentry->gucvar;
if ((conf->flags & GUC_REPORT) && (conf->status & GUC_NEEDS_REPORT))
ReportGUCOption(conf);
@ -4506,25 +4611,23 @@ init_custom_variable(const char *name,
/*
* Common code for DefineCustomXXXVariable subroutines: insert the new
* variable into the GUC variable array, replacing any placeholder.
* variable into the GUC variable hash, replacing any placeholder.
*/
static void
define_custom_variable(struct config_generic *variable)
{
const char *name = variable->name;
const char **nameAddr = &name;
GUCHashEntry *hentry;
struct config_string *pHolder;
struct config_generic **res;
/*
* See if there's a placeholder by the same name.
*/
res = (struct config_generic **) bsearch((void *) &nameAddr,
(void *) guc_variables,
num_guc_variables,
sizeof(struct config_generic *),
guc_var_compare);
if (res == NULL)
hentry = (GUCHashEntry *) hash_search(guc_hashtab,
&name,
HASH_FIND,
NULL);
if (hentry == NULL)
{
/*
* No placeholder to replace, so we can just add it ... but first,
@ -4538,13 +4641,13 @@ define_custom_variable(struct config_generic *variable)
/*
* This better be a placeholder
*/
if (((*res)->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
if ((hentry->gucvar->flags & GUC_CUSTOM_PLACEHOLDER) == 0)
ereport(ERROR,
(errcode(ERRCODE_INTERNAL_ERROR),
errmsg("attempt to redefine parameter \"%s\"", name)));
Assert((*res)->vartype == PGC_STRING);
pHolder = (struct config_string *) (*res);
Assert(hentry->gucvar->vartype == PGC_STRING);
pHolder = (struct config_string *) hentry->gucvar;
/*
* First, set the variable to its default value. We must do this even
@ -4554,10 +4657,11 @@ define_custom_variable(struct config_generic *variable)
InitializeOneGUCOption(variable);
/*
* Replace the placeholder. We aren't changing the name, so no re-sorting
* is necessary
* Replace the placeholder in the hash table. We aren't changing the name
* (at least up to case-folding), so the hash value is unchanged.
*/
*res = variable;
hentry->gucname = name;
hentry->gucvar = variable;
/*
* Assign the string value(s) stored in the placeholder to the real
@ -4849,7 +4953,8 @@ void
MarkGUCPrefixReserved(const char *className)
{
int classLen = strlen(className);
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
MemoryContext oldcontext;
/*
@ -4858,9 +4963,10 @@ MarkGUCPrefixReserved(const char *className)
* don't bother trying to free associated memory, since this shouldn't
* happen often.)
*/
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *var = guc_variables[i];
struct config_generic *var = hentry->gucvar;
if ((var->flags & GUC_CUSTOM_PLACEHOLDER) != 0 &&
strncmp(className, var->name, classLen) == 0 &&
@ -4872,9 +4978,10 @@ MarkGUCPrefixReserved(const char *className)
var->name),
errdetail("\"%s\" is now a reserved prefix.",
className)));
num_guc_variables--;
memmove(&guc_variables[i], &guc_variables[i + 1],
(num_guc_variables - i) * sizeof(struct config_generic *));
hash_search(guc_hashtab,
&var->name,
HASH_REMOVE,
NULL);
}
}
@ -4895,6 +5002,8 @@ struct config_generic **
get_explain_guc_options(int *num)
{
struct config_generic **result;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
*num = 0;
@ -4902,12 +5011,13 @@ get_explain_guc_options(int *num)
* While only a fraction of all the GUC variables are marked GUC_EXPLAIN,
* it doesn't seem worth dynamically resizing this array.
*/
result = palloc(sizeof(struct config_generic *) * num_guc_variables);
result = palloc(sizeof(struct config_generic *) * hash_get_num_entries(guc_hashtab));
for (int i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *conf = hentry->gucvar;
bool modified;
struct config_generic *conf = guc_variables[i];
/* return only parameters marked for inclusion in explain */
if (!(conf->flags & GUC_EXPLAIN))
@ -5010,15 +5120,6 @@ GetConfigOptionByName(const char *name, const char **varname, bool missing_ok)
return ShowGUCOption(record, true);
}
/*
* Return the total number of GUC variables
*/
int
GetNumConfigOptions(void)
{
return num_guc_variables;
}
/*
* ShowGUCOption: get string value of variable
*
@ -5220,7 +5321,8 @@ write_nondefault_variables(GucContext context)
{
int elevel;
FILE *fp;
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
Assert(context == PGC_POSTMASTER || context == PGC_SIGHUP);
@ -5239,9 +5341,10 @@ write_nondefault_variables(GucContext context)
return;
}
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
write_one_nondefault_variable(fp, guc_variables[i]);
write_one_nondefault_variable(fp, hentry->gucvar);
}
if (FreeFile(fp))
@ -5515,15 +5618,17 @@ Size
EstimateGUCStateSpace(void)
{
Size size;
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
/* Add space reqd for saving the data size of the guc state */
size = sizeof(Size);
/* Add up the space needed for each GUC variable */
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
size = add_size(size,
estimate_variable_size(guc_variables[i]));
estimate_variable_size(hentry->gucvar));
return size;
}
@ -5662,15 +5767,17 @@ SerializeGUCState(Size maxsize, char *start_address)
char *curptr;
Size actual_size;
Size bytes_left;
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
/* Reserve space for saving the actual size of the guc state */
Assert(maxsize > sizeof(actual_size));
curptr = start_address + sizeof(actual_size);
bytes_left = maxsize - sizeof(actual_size);
for (i = 0; i < num_guc_variables; i++)
serialize_variable(&curptr, &bytes_left, guc_variables[i]);
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
serialize_variable(&curptr, &bytes_left, hentry->gucvar);
/* Store actual size without assuming alignment of start_address. */
actual_size = maxsize - bytes_left - sizeof(actual_size);
@ -5755,7 +5862,8 @@ RestoreGUCState(void *gucstate)
char *srcptr = (char *) gucstate;
char *srcend;
Size len;
int i;
HASH_SEQ_STATUS status;
GUCHashEntry *hentry;
ErrorContextCallback error_context_callback;
/*
@ -5780,9 +5888,10 @@ RestoreGUCState(void *gucstate)
* also ensures that set_config_option won't refuse to set them because of
* source-priority comparisons.
*/
for (i = 0; i < num_guc_variables; i++)
hash_seq_init(&status, guc_hashtab);
while ((hentry = (GUCHashEntry *) hash_seq_search(&status)) != NULL)
{
struct config_generic *gconf = guc_variables[i];
struct config_generic *gconf = hentry->gucvar;
/* Do nothing if non-shippable or if already at PGC_S_DEFAULT. */
if (can_skip_gucvar(gconf))

39
src/backend/utils/misc/guc_funcs.c
View File

@ -455,13 +455,15 @@ ShowGUCConfigOption(const char *name, DestReceiver *dest)
static void
ShowAllGUCConfig(DestReceiver *dest)
{
int i;
struct config_generic **guc_vars;
int num_vars;
TupOutputState *tstate;
TupleDesc tupdesc;
Datum values[3];
bool isnull[3] = {false, false, false};
struct config_generic **guc_variables = get_guc_variables();
int num_guc_variables = GetNumConfigOptions();
/* collect the variables, in sorted order */
guc_vars = get_guc_variables(&num_vars);
/* need a tuple descriptor representing three TEXT columns */
tupdesc = CreateTemplateTupleDesc(3);
@ -475,9 +477,9 @@ ShowAllGUCConfig(DestReceiver *dest)
/* prepare for projection of tuples */
tstate = begin_tup_output_tupdesc(dest, tupdesc, &TTSOpsVirtual);
for (i = 0; i < num_guc_variables; i++)
for (int i = 0; i < num_vars; i++)
{
struct config_generic *conf = guc_variables[i];
struct config_generic *conf = guc_vars[i];
char *setting;
if ((conf->flags & GUC_NO_SHOW_ALL) ||
@ -570,20 +572,13 @@ pg_settings_get_flags(PG_FUNCTION_ARGS)
}
/*
* Return GUC variable value by variable number; optionally return canonical
* form of name. Return value is palloc'd.
* Extract fields to show in pg_settings for given variable.
*/
static void
GetConfigOptionByNum(int varnum, const char **values, bool *noshow)
GetConfigOptionValues(struct config_generic *conf, const char **values,
bool *noshow)
{
char buffer[256];
struct config_generic *conf;
struct config_generic **guc_variables = get_guc_variables();
/* check requested variable number valid */
Assert((varnum >= 0) && (varnum < GetNumConfigOptions()));
conf = guc_variables[varnum];
if (noshow)
{
@ -849,6 +844,8 @@ Datum
show_all_settings(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
struct config_generic **guc_vars;
int num_vars;
TupleDesc tupdesc;
int call_cntr;
int max_calls;
@ -913,8 +910,14 @@ show_all_settings(PG_FUNCTION_ARGS)
attinmeta = TupleDescGetAttInMetadata(tupdesc);
funcctx->attinmeta = attinmeta;
/* collect the variables, in sorted order */
guc_vars = get_guc_variables(&num_vars);
/* use user_fctx to remember the array location */
funcctx->user_fctx = guc_vars;
/* total number of tuples to be returned */
funcctx->max_calls = GetNumConfigOptions();
funcctx->max_calls = num_vars;
MemoryContextSwitchTo(oldcontext);
}
@ -922,6 +925,7 @@ show_all_settings(PG_FUNCTION_ARGS)
/* stuff done on every call of the function */
funcctx = SRF_PERCALL_SETUP();
guc_vars = (struct config_generic **) funcctx->user_fctx;
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
attinmeta = funcctx->attinmeta;
@ -938,7 +942,8 @@ show_all_settings(PG_FUNCTION_ARGS)
*/
do
{
GetConfigOptionByNum(call_cntr, (const char **) values, &noshow);
GetConfigOptionValues(guc_vars[call_cntr], (const char **) values,
&noshow);
if (noshow)
{
/* bump the counter and get the next config setting */

5
src/backend/utils/misc/help_config.c
View File

@ -49,11 +49,10 @@ GucInfoMain(void)
int numOpts,
i;
/* Initialize the guc_variables[] array */
/* Initialize the GUC hash table */
build_guc_variables();
guc_vars = get_guc_variables();
numOpts = GetNumConfigOptions();
guc_vars = get_guc_variables(&numOpts);
for (i = 0; i < numOpts; i++)
{

1
src/include/utils/guc.h
View File

@ -390,7 +390,6 @@ extern int set_config_option_ext(const char *name, const char *value,
extern void AlterSystemSetConfigFile(AlterSystemStmt *altersysstmt);
extern char *GetConfigOptionByName(const char *name, const char **varname,
bool missing_ok);
extern int GetNumConfigOptions(void);
extern void ProcessGUCArray(ArrayType *array,
GucContext context, GucSource source, GucAction action);

2
src/include/utils/guc_tables.h
View File

@ -281,7 +281,7 @@ extern struct config_generic **get_explain_guc_options(int *num);
extern char *ShowGUCOption(struct config_generic *record, bool use_units);
/* get the current set of variables */
extern struct config_generic **get_guc_variables(void);
extern struct config_generic **get_guc_variables(int *num_vars);
extern void build_guc_variables(void);