PostgreSQL Source Code  git master
guc_tables.c
Go to the documentation of this file.
1 /*--------------------------------------------------------------------
2  *
3  * guc_tables.c
4  *
5  * Static tables for the Grand Unified Configuration scheme.
6  *
7  * Many of these tables are const. However, ConfigureNamesBool[]
8  * and so on are not, because the structs in those arrays are actually
9  * the live per-variable state data that guc.c manipulates. While many of
10  * their fields are intended to be constant, some fields change at runtime.
11  *
12  *
13  * Copyright (c) 2000-2024, PostgreSQL Global Development Group
14  * Written by Peter Eisentraut <peter_e@gmx.net>.
15  *
16  * IDENTIFICATION
17  * src/backend/utils/misc/guc_tables.c
18  *
19  *--------------------------------------------------------------------
20  */
21 #include "postgres.h"
22 
23 #include <float.h>
24 #include <limits.h>
25 #ifdef HAVE_SYSLOG
26 #include <syslog.h>
27 #endif
28 
29 #include "access/commit_ts.h"
30 #include "access/gin.h"
31 #include "access/slru.h"
32 #include "access/toast_compression.h"
33 #include "access/twophase.h"
34 #include "access/xlog_internal.h"
35 #include "access/xlogprefetcher.h"
36 #include "access/xlogrecovery.h"
37 #include "archive/archive_module.h"
38 #include "catalog/namespace.h"
39 #include "catalog/storage.h"
40 #include "commands/async.h"
41 #include "commands/event_trigger.h"
42 #include "commands/tablespace.h"
43 #include "commands/trigger.h"
44 #include "commands/user.h"
45 #include "commands/vacuum.h"
46 #include "common/file_utils.h"
47 #include "common/scram-common.h"
48 #include "jit/jit.h"
49 #include "libpq/auth.h"
50 #include "libpq/libpq.h"
51 #include "libpq/scram.h"
52 #include "nodes/queryjumble.h"
53 #include "optimizer/cost.h"
54 #include "optimizer/geqo.h"
55 #include "optimizer/optimizer.h"
56 #include "optimizer/paths.h"
57 #include "optimizer/planmain.h"
58 #include "parser/parse_expr.h"
59 #include "parser/parser.h"
60 #include "pgstat.h"
61 #include "postmaster/autovacuum.h"
62 #include "postmaster/bgworker_internals.h"
63 #include "postmaster/bgwriter.h"
64 #include "postmaster/postmaster.h"
65 #include "postmaster/startup.h"
66 #include "postmaster/syslogger.h"
67 #include "postmaster/walsummarizer.h"
68 #include "postmaster/walwriter.h"
69 #include "replication/logicallauncher.h"
70 #include "replication/slot.h"
71 #include "replication/slotsync.h"
72 #include "replication/syncrep.h"
73 #include "storage/bufmgr.h"
74 #include "storage/large_object.h"
75 #include "storage/pg_shmem.h"
76 #include "storage/predicate.h"
77 #include "storage/standby.h"
78 #include "tcop/tcopprot.h"
79 #include "tsearch/ts_cache.h"
80 #include "utils/builtins.h"
81 #include "utils/bytea.h"
82 #include "utils/float.h"
83 #include "utils/guc_hooks.h"
84 #include "utils/guc_tables.h"
85 #include "utils/inval.h"
86 #include "utils/memutils.h"
87 #include "utils/pg_locale.h"
88 #include "utils/plancache.h"
89 #include "utils/ps_status.h"
90 #include "utils/xml.h"
91 
92 /* This value is normally passed in from the Makefile */
93 #ifndef PG_KRB_SRVTAB
94 #define PG_KRB_SRVTAB ""
95 #endif
96 
97 /* XXX these should appear in other modules' header files */
98 extern bool Log_disconnections;
99 extern bool Trace_connection_negotiation;
100 extern int CommitDelay;
101 extern int CommitSiblings;
102 extern char *default_tablespace;
103 extern char *temp_tablespaces;
104 extern bool ignore_checksum_failure;
105 extern bool ignore_invalid_pages;
106 
107 #ifdef TRACE_SYNCSCAN
108 extern bool trace_syncscan;
109 #endif
110 #ifdef DEBUG_BOUNDED_SORT
111 extern bool optimize_bounded_sort;
112 #endif
113 
114 /*
115  * Options for enum values defined in this module.
116  *
117  * NOTE! Option values may not contain double quotes!
118  */
119 
120 static const struct config_enum_entry bytea_output_options[] = {
121  {"escape", BYTEA_OUTPUT_ESCAPE, false},
122  {"hex", BYTEA_OUTPUT_HEX, false},
123  {NULL, 0, false}
124 };
125 
126 StaticAssertDecl(lengthof(bytea_output_options) == (BYTEA_OUTPUT_HEX + 2),
127  "array length mismatch");
128 
129 /*
130  * We have different sets for client and server message level options because
131  * they sort slightly different (see "log" level), and because "fatal"/"panic"
132  * aren't sensible for client_min_messages.
133  */
134 static const struct config_enum_entry client_message_level_options[] = {
135  {"debug5", DEBUG5, false},
136  {"debug4", DEBUG4, false},
137  {"debug3", DEBUG3, false},
138  {"debug2", DEBUG2, false},
139  {"debug1", DEBUG1, false},
140  {"debug", DEBUG2, true},
141  {"log", LOG, false},
142  {"info", INFO, true},
143  {"notice", NOTICE, false},
144  {"warning", WARNING, false},
145  {"error", ERROR, false},
146  {NULL, 0, false}
147 };
148 
149 static const struct config_enum_entry server_message_level_options[] = {
150  {"debug5", DEBUG5, false},
151  {"debug4", DEBUG4, false},
152  {"debug3", DEBUG3, false},
153  {"debug2", DEBUG2, false},
154  {"debug1", DEBUG1, false},
155  {"debug", DEBUG2, true},
156  {"info", INFO, false},
157  {"notice", NOTICE, false},
158  {"warning", WARNING, false},
159  {"error", ERROR, false},
160  {"log", LOG, false},
161  {"fatal", FATAL, false},
162  {"panic", PANIC, false},
163  {NULL, 0, false}
164 };
165 
166 static const struct config_enum_entry intervalstyle_options[] = {
167  {"postgres", INTSTYLE_POSTGRES, false},
168  {"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
169  {"sql_standard", INTSTYLE_SQL_STANDARD, false},
170  {"iso_8601", INTSTYLE_ISO_8601, false},
171  {NULL, 0, false}
172 };
173 
174 static const struct config_enum_entry icu_validation_level_options[] = {
175  {"disabled", -1, false},
176  {"debug5", DEBUG5, false},
177  {"debug4", DEBUG4, false},
178  {"debug3", DEBUG3, false},
179  {"debug2", DEBUG2, false},
180  {"debug1", DEBUG1, false},
181  {"debug", DEBUG2, true},
182  {"log", LOG, false},
183  {"info", INFO, true},
184  {"notice", NOTICE, false},
185  {"warning", WARNING, false},
186  {"error", ERROR, false},
187  {NULL, 0, false}
188 };
189 
190 StaticAssertDecl(lengthof(intervalstyle_options) == (INTSTYLE_ISO_8601 + 2),
191  "array length mismatch");
192 
193 static const struct config_enum_entry log_error_verbosity_options[] = {
194  {"terse", PGERROR_TERSE, false},
195  {"default", PGERROR_DEFAULT, false},
196  {"verbose", PGERROR_VERBOSE, false},
197  {NULL, 0, false}
198 };
199 
200 StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
201  "array length mismatch");
202 
203 static const struct config_enum_entry log_statement_options[] = {
204  {"none", LOGSTMT_NONE, false},
205  {"ddl", LOGSTMT_DDL, false},
206  {"mod", LOGSTMT_MOD, false},
207  {"all", LOGSTMT_ALL, false},
208  {NULL, 0, false}
209 };
210 
211 StaticAssertDecl(lengthof(log_statement_options) == (LOGSTMT_ALL + 2),
212  "array length mismatch");
213 
214 static const struct config_enum_entry isolation_level_options[] = {
215  {"serializable", XACT_SERIALIZABLE, false},
216  {"repeatable read", XACT_REPEATABLE_READ, false},
217  {"read committed", XACT_READ_COMMITTED, false},
218  {"read uncommitted", XACT_READ_UNCOMMITTED, false},
219  {NULL, 0}
220 };
221 
222 static const struct config_enum_entry session_replication_role_options[] = {
223  {"origin", SESSION_REPLICATION_ROLE_ORIGIN, false},
224  {"replica", SESSION_REPLICATION_ROLE_REPLICA, false},
225  {"local", SESSION_REPLICATION_ROLE_LOCAL, false},
226  {NULL, 0, false}
227 };
228 
229 StaticAssertDecl(lengthof(session_replication_role_options) == (SESSION_REPLICATION_ROLE_LOCAL + 2),
230  "array length mismatch");
231 
232 static const struct config_enum_entry syslog_facility_options[] = {
233 #ifdef HAVE_SYSLOG
234  {"local0", LOG_LOCAL0, false},
235  {"local1", LOG_LOCAL1, false},
236  {"local2", LOG_LOCAL2, false},
237  {"local3", LOG_LOCAL3, false},
238  {"local4", LOG_LOCAL4, false},
239  {"local5", LOG_LOCAL5, false},
240  {"local6", LOG_LOCAL6, false},
241  {"local7", LOG_LOCAL7, false},
242 #else
243  {"none", 0, false},
244 #endif
245  {NULL, 0}
246 };
247 
248 static const struct config_enum_entry track_function_options[] = {
249  {"none", TRACK_FUNC_OFF, false},
250  {"pl", TRACK_FUNC_PL, false},
251  {"all", TRACK_FUNC_ALL, false},
252  {NULL, 0, false}
253 };
254 
255 StaticAssertDecl(lengthof(track_function_options) == (TRACK_FUNC_ALL + 2),
256  "array length mismatch");
257 
258 static const struct config_enum_entry stats_fetch_consistency[] = {
259  {"none", PGSTAT_FETCH_CONSISTENCY_NONE, false},
260  {"cache", PGSTAT_FETCH_CONSISTENCY_CACHE, false},
261  {"snapshot", PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, false},
262  {NULL, 0, false}
263 };
264 
265 StaticAssertDecl(lengthof(stats_fetch_consistency) == (PGSTAT_FETCH_CONSISTENCY_SNAPSHOT + 2),
266  "array length mismatch");
267 
268 static const struct config_enum_entry xmlbinary_options[] = {
269  {"base64", XMLBINARY_BASE64, false},
270  {"hex", XMLBINARY_HEX, false},
271  {NULL, 0, false}
272 };
273 
274 StaticAssertDecl(lengthof(xmlbinary_options) == (XMLBINARY_HEX + 2),
275  "array length mismatch");
276 
277 static const struct config_enum_entry xmloption_options[] = {
278  {"content", XMLOPTION_CONTENT, false},
279  {"document", XMLOPTION_DOCUMENT, false},
280  {NULL, 0, false}
281 };
282 
283 StaticAssertDecl(lengthof(xmloption_options) == (XMLOPTION_CONTENT + 2),
284  "array length mismatch");
285 
286 /*
287  * Although only "on", "off", and "safe_encoding" are documented, we
288  * accept all the likely variants of "on" and "off".
289  */
290 static const struct config_enum_entry backslash_quote_options[] = {
291  {"safe_encoding", BACKSLASH_QUOTE_SAFE_ENCODING, false},
292  {"on", BACKSLASH_QUOTE_ON, false},
293  {"off", BACKSLASH_QUOTE_OFF, false},
294  {"true", BACKSLASH_QUOTE_ON, true},
295  {"false", BACKSLASH_QUOTE_OFF, true},
296  {"yes", BACKSLASH_QUOTE_ON, true},
297  {"no", BACKSLASH_QUOTE_OFF, true},
298  {"1", BACKSLASH_QUOTE_ON, true},
299  {"0", BACKSLASH_QUOTE_OFF, true},
300  {NULL, 0, false}
301 };
302 
303 /*
304  * Although only "on", "off", and "auto" are documented, we accept
305  * all the likely variants of "on" and "off".
306  */
307 static const struct config_enum_entry compute_query_id_options[] = {
308  {"auto", COMPUTE_QUERY_ID_AUTO, false},
309  {"regress", COMPUTE_QUERY_ID_REGRESS, false},
310  {"on", COMPUTE_QUERY_ID_ON, false},
311  {"off", COMPUTE_QUERY_ID_OFF, false},
312  {"true", COMPUTE_QUERY_ID_ON, true},
313  {"false", COMPUTE_QUERY_ID_OFF, true},
314  {"yes", COMPUTE_QUERY_ID_ON, true},
315  {"no", COMPUTE_QUERY_ID_OFF, true},
316  {"1", COMPUTE_QUERY_ID_ON, true},
317  {"0", COMPUTE_QUERY_ID_OFF, true},
318  {NULL, 0, false}
319 };
320 
321 /*
322  * Although only "on", "off", and "partition" are documented, we
323  * accept all the likely variants of "on" and "off".
324  */
325 static const struct config_enum_entry constraint_exclusion_options[] = {
326  {"partition", CONSTRAINT_EXCLUSION_PARTITION, false},
327  {"on", CONSTRAINT_EXCLUSION_ON, false},
328  {"off", CONSTRAINT_EXCLUSION_OFF, false},
329  {"true", CONSTRAINT_EXCLUSION_ON, true},
330  {"false", CONSTRAINT_EXCLUSION_OFF, true},
331  {"yes", CONSTRAINT_EXCLUSION_ON, true},
332  {"no", CONSTRAINT_EXCLUSION_OFF, true},
333  {"1", CONSTRAINT_EXCLUSION_ON, true},
334  {"0", CONSTRAINT_EXCLUSION_OFF, true},
335  {NULL, 0, false}
336 };
337 
338 /*
339  * Although only "on", "off", "remote_apply", "remote_write", and "local" are
340  * documented, we accept all the likely variants of "on" and "off".
341  */
342 static const struct config_enum_entry synchronous_commit_options[] = {
343  {"local", SYNCHRONOUS_COMMIT_LOCAL_FLUSH, false},
344  {"remote_write", SYNCHRONOUS_COMMIT_REMOTE_WRITE, false},
345  {"remote_apply", SYNCHRONOUS_COMMIT_REMOTE_APPLY, false},
346  {"on", SYNCHRONOUS_COMMIT_ON, false},
347  {"off", SYNCHRONOUS_COMMIT_OFF, false},
348  {"true", SYNCHRONOUS_COMMIT_ON, true},
349  {"false", SYNCHRONOUS_COMMIT_OFF, true},
350  {"yes", SYNCHRONOUS_COMMIT_ON, true},
351  {"no", SYNCHRONOUS_COMMIT_OFF, true},
352  {"1", SYNCHRONOUS_COMMIT_ON, true},
353  {"0", SYNCHRONOUS_COMMIT_OFF, true},
354  {NULL, 0, false}
355 };
356 
357 /*
358  * Although only "on", "off", "try" are documented, we accept all the likely
359  * variants of "on" and "off".
360  */
361 static const struct config_enum_entry huge_pages_options[] = {
362  {"off", HUGE_PAGES_OFF, false},
363  {"on", HUGE_PAGES_ON, false},
364  {"try", HUGE_PAGES_TRY, false},
365  {"true", HUGE_PAGES_ON, true},
366  {"false", HUGE_PAGES_OFF, true},
367  {"yes", HUGE_PAGES_ON, true},
368  {"no", HUGE_PAGES_OFF, true},
369  {"1", HUGE_PAGES_ON, true},
370  {"0", HUGE_PAGES_OFF, true},
371  {NULL, 0, false}
372 };
373 
374 static const struct config_enum_entry huge_pages_status_options[] = {
375  {"off", HUGE_PAGES_OFF, false},
376  {"on", HUGE_PAGES_ON, false},
377  {"unknown", HUGE_PAGES_UNKNOWN, false},
378  {NULL, 0, false}
379 };
380 
381 static const struct config_enum_entry recovery_prefetch_options[] = {
382  {"off", RECOVERY_PREFETCH_OFF, false},
383  {"on", RECOVERY_PREFETCH_ON, false},
384  {"try", RECOVERY_PREFETCH_TRY, false},
385  {"true", RECOVERY_PREFETCH_ON, true},
386  {"false", RECOVERY_PREFETCH_OFF, true},
387  {"yes", RECOVERY_PREFETCH_ON, true},
388  {"no", RECOVERY_PREFETCH_OFF, true},
389  {"1", RECOVERY_PREFETCH_ON, true},
390  {"0", RECOVERY_PREFETCH_OFF, true},
391  {NULL, 0, false}
392 };
393 
394 static const struct config_enum_entry debug_parallel_query_options[] = {
395  {"off", DEBUG_PARALLEL_OFF, false},
396  {"on", DEBUG_PARALLEL_ON, false},
397  {"regress", DEBUG_PARALLEL_REGRESS, false},
398  {"true", DEBUG_PARALLEL_ON, true},
399  {"false", DEBUG_PARALLEL_OFF, true},
400  {"yes", DEBUG_PARALLEL_ON, true},
401  {"no", DEBUG_PARALLEL_OFF, true},
402  {"1", DEBUG_PARALLEL_ON, true},
403  {"0", DEBUG_PARALLEL_OFF, true},
404  {NULL, 0, false}
405 };
406 
407 static const struct config_enum_entry plan_cache_mode_options[] = {
408  {"auto", PLAN_CACHE_MODE_AUTO, false},
409  {"force_generic_plan", PLAN_CACHE_MODE_FORCE_GENERIC_PLAN, false},
410  {"force_custom_plan", PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN, false},
411  {NULL, 0, false}
412 };
413 
414 static const struct config_enum_entry password_encryption_options[] = {
415  {"md5", PASSWORD_TYPE_MD5, false},
416  {"scram-sha-256", PASSWORD_TYPE_SCRAM_SHA_256, false},
417  {NULL, 0, false}
418 };
419 
420 static const struct config_enum_entry ssl_protocol_versions_info[] = {
421  {"", PG_TLS_ANY, false},
422  {"TLSv1", PG_TLS1_VERSION, false},
423  {"TLSv1.1", PG_TLS1_1_VERSION, false},
424  {"TLSv1.2", PG_TLS1_2_VERSION, false},
425  {"TLSv1.3", PG_TLS1_3_VERSION, false},
426  {NULL, 0, false}
427 };
428 
429 static const struct config_enum_entry debug_logical_replication_streaming_options[] = {
430  {"buffered", DEBUG_LOGICAL_REP_STREAMING_BUFFERED, false},
431  {"immediate", DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE, false},
432  {NULL, 0, false}
433 };
434 
435 StaticAssertDecl(lengthof(ssl_protocol_versions_info) == (PG_TLS1_3_VERSION + 2),
436  "array length mismatch");
437 
438 static const struct config_enum_entry recovery_init_sync_method_options[] = {
439  {"fsync", DATA_DIR_SYNC_METHOD_FSYNC, false},
440 #ifdef HAVE_SYNCFS
441  {"syncfs", DATA_DIR_SYNC_METHOD_SYNCFS, false},
442 #endif
443  {NULL, 0, false}
444 };
445 
446 static const struct config_enum_entry shared_memory_options[] = {
447 #ifndef WIN32
448  {"sysv", SHMEM_TYPE_SYSV, false},
449 #endif
450 #ifndef EXEC_BACKEND
451  {"mmap", SHMEM_TYPE_MMAP, false},
452 #endif
453 #ifdef WIN32
454  {"windows", SHMEM_TYPE_WINDOWS, false},
455 #endif
456  {NULL, 0, false}
457 };
458 
459 static const struct config_enum_entry default_toast_compression_options[] = {
460  {"pglz", TOAST_PGLZ_COMPRESSION, false},
461 #ifdef USE_LZ4
462  {"lz4", TOAST_LZ4_COMPRESSION, false},
463 #endif
464  {NULL, 0, false}
465 };
466 
467 static const struct config_enum_entry wal_compression_options[] = {
468  {"pglz", WAL_COMPRESSION_PGLZ, false},
469 #ifdef USE_LZ4
470  {"lz4", WAL_COMPRESSION_LZ4, false},
471 #endif
472 #ifdef USE_ZSTD
473  {"zstd", WAL_COMPRESSION_ZSTD, false},
474 #endif
475  {"on", WAL_COMPRESSION_PGLZ, false},
476  {"off", WAL_COMPRESSION_NONE, false},
477  {"true", WAL_COMPRESSION_PGLZ, true},
478  {"false", WAL_COMPRESSION_NONE, true},
479  {"yes", WAL_COMPRESSION_PGLZ, true},
480  {"no", WAL_COMPRESSION_NONE, true},
481  {"1", WAL_COMPRESSION_PGLZ, true},
482  {"0", WAL_COMPRESSION_NONE, true},
483  {NULL, 0, false}
484 };
485 
486 /*
487  * Options for enum values stored in other modules
488  */
489 extern const struct config_enum_entry wal_level_options[];
490 extern const struct config_enum_entry archive_mode_options[];
491 extern const struct config_enum_entry recovery_target_action_options[];
492 extern const struct config_enum_entry wal_sync_method_options[];
493 extern const struct config_enum_entry dynamic_shared_memory_options[];
494 
495 /*
496  * GUC option variables that are exported from this module
497  */
498 bool AllowAlterSystem = true;
499 bool log_duration = false;
500 bool Debug_print_plan = false;
501 bool Debug_print_parse = false;
502 bool Debug_print_rewritten = false;
503 bool Debug_pretty_print = true;
504 
505 bool log_parser_stats = false;
506 bool log_planner_stats = false;
507 bool log_executor_stats = false;
508 bool log_statement_stats = false; /* this is sort of all three above
509  * together */
510 bool log_btree_build_stats = false;
511 char *event_source;
512 
513 bool row_security;
514 bool check_function_bodies = true;
515 
516 /*
517  * This GUC exists solely for backward compatibility, check its definition for
518  * details.
519  */
520 bool default_with_oids = false;
521 bool current_role_is_superuser;
522 
523 int log_min_error_statement = ERROR;
524 int log_min_messages = WARNING;
525 int client_min_messages = NOTICE;
526 int log_min_duration_sample = -1;
527 int log_min_duration_statement = -1;
528 int log_parameter_max_length = -1;
529 int log_parameter_max_length_on_error = 0;
530 int log_temp_files = -1;
531 double log_statement_sample_rate = 1.0;
532 double log_xact_sample_rate = 0;
533 char *backtrace_functions;
534 bool backtrace_on_internal_error = false;
535 
536 int temp_file_limit = -1;
537 
538 int num_temp_buffers = 1024;
539 
540 char *cluster_name = "";
541 char *ConfigFileName;
542 char *HbaFileName;
543 char *IdentFileName;
544 char *external_pid_file;
545 
546 char *application_name;
547 
548 int tcp_keepalives_idle;
549 int tcp_keepalives_interval;
550 int tcp_keepalives_count;
551 int tcp_user_timeout;
552 
553 /*
554  * SSL renegotiation was been removed in PostgreSQL 9.5, but we tolerate it
555  * being set to zero (meaning never renegotiate) for backward compatibility.
556  * This avoids breaking compatibility with clients that have never supported
557  * renegotiation and therefore always try to zero it.
558  */
559 int ssl_renegotiation_limit;
560 
561 /*
562  * This really belongs in pg_shmem.c, but is defined here so that it doesn't
563  * need to be duplicated in all the different implementations of pg_shmem.c.
564  */
565 int huge_pages = HUGE_PAGES_TRY;
566 int huge_page_size;
567 int huge_pages_status = HUGE_PAGES_UNKNOWN;
568 
569 /*
570  * These variables are all dummies that don't do anything, except in some
571  * cases provide the value for SHOW to display. The real state is elsewhere
572  * and is kept in sync by assign_hooks.
573  */
574 static char *syslog_ident_str;
575 static double phony_random_seed;
576 static char *client_encoding_string;
577 static char *datestyle_string;
578 static char *server_encoding_string;
579 static char *server_version_string;
580 static int server_version_num;
581 static char *debug_io_direct_string;
582 
583 #ifdef HAVE_SYSLOG
584 #define DEFAULT_SYSLOG_FACILITY LOG_LOCAL0
585 #else
586 #define DEFAULT_SYSLOG_FACILITY 0
587 #endif
588 static int syslog_facility = DEFAULT_SYSLOG_FACILITY;
589 
590 static char *timezone_string;
591 static char *log_timezone_string;
592 static char *timezone_abbreviations_string;
593 static char *data_directory;
594 static char *session_authorization_string;
595 static int max_function_args;
596 static int max_index_keys;
597 static int max_identifier_length;
598 static int block_size;
599 static int segment_size;
600 static int shared_memory_size_mb;
601 static int shared_memory_size_in_huge_pages;
602 static int wal_block_size;
603 static bool data_checksums;
604 static bool integer_datetimes;
605 
606 #ifdef USE_ASSERT_CHECKING
607 #define DEFAULT_ASSERT_ENABLED true
608 #else
609 #define DEFAULT_ASSERT_ENABLED false
610 #endif
611 static bool assert_enabled = DEFAULT_ASSERT_ENABLED;
612 
613 static char *recovery_target_timeline_string;
614 static char *recovery_target_string;
615 static char *recovery_target_xid_string;
616 static char *recovery_target_name_string;
617 static char *recovery_target_lsn_string;
618 
619 /* should be static, but commands/variable.c needs to get at this */
620 char *role_string;
621 
622 /* should be static, but guc.c needs to get at this */
623 bool in_hot_standby_guc;
624 
625 
626 /*
627  * Displayable names for context types (enum GucContext)
628  *
629  * Note: these strings are deliberately not localized.
630  */
631 const char *const GucContext_Names[] =
632 {
633  [PGC_INTERNAL] = "internal",
634  [PGC_POSTMASTER] = "postmaster",
635  [PGC_SIGHUP] = "sighup",
636  [PGC_SU_BACKEND] = "superuser-backend",
637  [PGC_BACKEND] = "backend",
638  [PGC_SUSET] = "superuser",
639  [PGC_USERSET] = "user",
640 };
641 
642 StaticAssertDecl(lengthof(GucContext_Names) == (PGC_USERSET + 1),
643  "array length mismatch");
644 
645 /*
646  * Displayable names for source types (enum GucSource)
647  *
648  * Note: these strings are deliberately not localized.
649  */
650 const char *const GucSource_Names[] =
651 {
652  [PGC_S_DEFAULT] = "default",
653  [PGC_S_DYNAMIC_DEFAULT] = "default",
654  [PGC_S_ENV_VAR] = "environment variable",
655  [PGC_S_FILE] = "configuration file",
656  [PGC_S_ARGV] = "command line",
657  [PGC_S_GLOBAL] = "global",
658  [PGC_S_DATABASE] = "database",
659  [PGC_S_USER] = "user",
660  [PGC_S_DATABASE_USER] = "database user",
661  [PGC_S_CLIENT] = "client",
662  [PGC_S_OVERRIDE] = "override",
663  [PGC_S_INTERACTIVE] = "interactive",
664  [PGC_S_TEST] = "test",
665  [PGC_S_SESSION] = "session",
666 };
667 
668 StaticAssertDecl(lengthof(GucSource_Names) == (PGC_S_SESSION + 1),
669  "array length mismatch");
670 
671 /*
672  * Displayable names for the groupings defined in enum config_group
673  */
674 const char *const config_group_names[] =
675 {
676  [UNGROUPED] = gettext_noop("Ungrouped"),
677  [FILE_LOCATIONS] = gettext_noop("File Locations"),
678  [CONN_AUTH_SETTINGS] = gettext_noop("Connections and Authentication / Connection Settings"),
679  [CONN_AUTH_TCP] = gettext_noop("Connections and Authentication / TCP Settings"),
680  [CONN_AUTH_AUTH] = gettext_noop("Connections and Authentication / Authentication"),
681  [CONN_AUTH_SSL] = gettext_noop("Connections and Authentication / SSL"),
682  [RESOURCES_MEM] = gettext_noop("Resource Usage / Memory"),
683  [RESOURCES_DISK] = gettext_noop("Resource Usage / Disk"),
684  [RESOURCES_KERNEL] = gettext_noop("Resource Usage / Kernel Resources"),
685  [RESOURCES_VACUUM_DELAY] = gettext_noop("Resource Usage / Cost-Based Vacuum Delay"),
686  [RESOURCES_BGWRITER] = gettext_noop("Resource Usage / Background Writer"),
687  [RESOURCES_ASYNCHRONOUS] = gettext_noop("Resource Usage / Asynchronous Behavior"),
688  [WAL_SETTINGS] = gettext_noop("Write-Ahead Log / Settings"),
689  [WAL_CHECKPOINTS] = gettext_noop("Write-Ahead Log / Checkpoints"),
690  [WAL_ARCHIVING] = gettext_noop("Write-Ahead Log / Archiving"),
691  [WAL_RECOVERY] = gettext_noop("Write-Ahead Log / Recovery"),
692  [WAL_ARCHIVE_RECOVERY] = gettext_noop("Write-Ahead Log / Archive Recovery"),
693  [WAL_RECOVERY_TARGET] = gettext_noop("Write-Ahead Log / Recovery Target"),
694  [WAL_SUMMARIZATION] = gettext_noop("Write-Ahead Log / Summarization"),
695  [REPLICATION_SENDING] = gettext_noop("Replication / Sending Servers"),
696  [REPLICATION_PRIMARY] = gettext_noop("Replication / Primary Server"),
697  [REPLICATION_STANDBY] = gettext_noop("Replication / Standby Servers"),
698  [REPLICATION_SUBSCRIBERS] = gettext_noop("Replication / Subscribers"),
699  [QUERY_TUNING_METHOD] = gettext_noop("Query Tuning / Planner Method Configuration"),
700  [QUERY_TUNING_COST] = gettext_noop("Query Tuning / Planner Cost Constants"),
701  [QUERY_TUNING_GEQO] = gettext_noop("Query Tuning / Genetic Query Optimizer"),
702  [QUERY_TUNING_OTHER] = gettext_noop("Query Tuning / Other Planner Options"),
703  [LOGGING_WHERE] = gettext_noop("Reporting and Logging / Where to Log"),
704  [LOGGING_WHEN] = gettext_noop("Reporting and Logging / When to Log"),
705  [LOGGING_WHAT] = gettext_noop("Reporting and Logging / What to Log"),
706  [PROCESS_TITLE] = gettext_noop("Reporting and Logging / Process Title"),
707  [STATS_MONITORING] = gettext_noop("Statistics / Monitoring"),
708  [STATS_CUMULATIVE] = gettext_noop("Statistics / Cumulative Query and Index Statistics"),
709  [AUTOVACUUM] = gettext_noop("Autovacuum"),
710  [CLIENT_CONN_STATEMENT] = gettext_noop("Client Connection Defaults / Statement Behavior"),
711  [CLIENT_CONN_LOCALE] = gettext_noop("Client Connection Defaults / Locale and Formatting"),
712  [CLIENT_CONN_PRELOAD] = gettext_noop("Client Connection Defaults / Shared Library Preloading"),
713  [CLIENT_CONN_OTHER] = gettext_noop("Client Connection Defaults / Other Defaults"),
714  [LOCK_MANAGEMENT] = gettext_noop("Lock Management"),
715  [COMPAT_OPTIONS_PREVIOUS] = gettext_noop("Version and Platform Compatibility / Previous PostgreSQL Versions"),
716  [COMPAT_OPTIONS_OTHER] = gettext_noop("Version and Platform Compatibility / Other Platforms and Clients"),
717  [ERROR_HANDLING_OPTIONS] = gettext_noop("Error Handling"),
718  [PRESET_OPTIONS] = gettext_noop("Preset Options"),
719  [CUSTOM_OPTIONS] = gettext_noop("Customized Options"),
720  [DEVELOPER_OPTIONS] = gettext_noop("Developer Options"),
721 };
722 
723 StaticAssertDecl(lengthof(config_group_names) == (DEVELOPER_OPTIONS + 1),
724  "array length mismatch");
725 
726 /*
727  * Displayable names for GUC variable types (enum config_type)
728  *
729  * Note: these strings are deliberately not localized.
730  */
731 const char *const config_type_names[] =
732 {
733  [PGC_BOOL] = "bool",
734  [PGC_INT] = "integer",
735  [PGC_REAL] = "real",
736  [PGC_STRING] = "string",
737  [PGC_ENUM] = "enum",
738 };
739 
740 StaticAssertDecl(lengthof(config_type_names) == (PGC_ENUM + 1),
741  "array length mismatch");
742 
743 
744 /*
745  * Contents of GUC tables
746  *
747  * See src/backend/utils/misc/README for design notes.
748  *
749  * TO ADD AN OPTION:
750  *
751  * 1. Declare a global variable of type bool, int, double, or char*
752  * and make use of it.
753  *
754  * 2. Decide at what times it's safe to set the option. See guc.h for
755  * details.
756  *
757  * 3. Decide on a name, a default value, upper and lower bounds (if
758  * applicable), etc.
759  *
760  * 4. Add a record below.
761  *
762  * 5. Add it to src/backend/utils/misc/postgresql.conf.sample, if
763  * appropriate.
764  *
765  * 6. Don't forget to document the option (at least in config.sgml).
766  *
767  * 7. If it's a new GUC_LIST_QUOTE option, you must add it to
768  * variable_is_guc_list_quote() in src/bin/pg_dump/dumputils.c.
769  */
770 
771 struct config_bool ConfigureNamesBool[] =
772 {
773  {
774  {"backtrace_on_internal_error", PGC_SUSET, DEVELOPER_OPTIONS,
775  gettext_noop("Log backtrace for any error with error code XX000 (internal error)."),
776  NULL,
777  GUC_NOT_IN_SAMPLE
778  },
779  &backtrace_on_internal_error,
780  false,
781  NULL, NULL, NULL
782  },
783  {
784  {"enable_seqscan", PGC_USERSET, QUERY_TUNING_METHOD,
785  gettext_noop("Enables the planner's use of sequential-scan plans."),
786  NULL,
787  GUC_EXPLAIN
788  },
789  &enable_seqscan,
790  true,
791  NULL, NULL, NULL
792  },
793  {
794  {"enable_indexscan", PGC_USERSET, QUERY_TUNING_METHOD,
795  gettext_noop("Enables the planner's use of index-scan plans."),
796  NULL,
797  GUC_EXPLAIN
798  },
799  &enable_indexscan,
800  true,
801  NULL, NULL, NULL
802  },
803  {
804  {"enable_indexonlyscan", PGC_USERSET, QUERY_TUNING_METHOD,
805  gettext_noop("Enables the planner's use of index-only-scan plans."),
806  NULL,
807  GUC_EXPLAIN
808  },
809  &enable_indexonlyscan,
810  true,
811  NULL, NULL, NULL
812  },
813  {
814  {"enable_bitmapscan", PGC_USERSET, QUERY_TUNING_METHOD,
815  gettext_noop("Enables the planner's use of bitmap-scan plans."),
816  NULL,
817  GUC_EXPLAIN
818  },
819  &enable_bitmapscan,
820  true,
821  NULL, NULL, NULL
822  },
823  {
824  {"enable_tidscan", PGC_USERSET, QUERY_TUNING_METHOD,
825  gettext_noop("Enables the planner's use of TID scan plans."),
826  NULL,
827  GUC_EXPLAIN
828  },
829  &enable_tidscan,
830  true,
831  NULL, NULL, NULL
832  },
833  {
834  {"enable_sort", PGC_USERSET, QUERY_TUNING_METHOD,
835  gettext_noop("Enables the planner's use of explicit sort steps."),
836  NULL,
837  GUC_EXPLAIN
838  },
839  &enable_sort,
840  true,
841  NULL, NULL, NULL
842  },
843  {
844  {"enable_incremental_sort", PGC_USERSET, QUERY_TUNING_METHOD,
845  gettext_noop("Enables the planner's use of incremental sort steps."),
846  NULL,
847  GUC_EXPLAIN
848  },
849  &enable_incremental_sort,
850  true,
851  NULL, NULL, NULL
852  },
853  {
854  {"enable_hashagg", PGC_USERSET, QUERY_TUNING_METHOD,
855  gettext_noop("Enables the planner's use of hashed aggregation plans."),
856  NULL,
857  GUC_EXPLAIN
858  },
859  &enable_hashagg,
860  true,
861  NULL, NULL, NULL
862  },
863  {
864  {"enable_material", PGC_USERSET, QUERY_TUNING_METHOD,
865  gettext_noop("Enables the planner's use of materialization."),
866  NULL,
867  GUC_EXPLAIN
868  },
869  &enable_material,
870  true,
871  NULL, NULL, NULL
872  },
873  {
874  {"enable_memoize", PGC_USERSET, QUERY_TUNING_METHOD,
875  gettext_noop("Enables the planner's use of memoization."),
876  NULL,
877  GUC_EXPLAIN
878  },
879  &enable_memoize,
880  true,
881  NULL, NULL, NULL
882  },
883  {
884  {"enable_nestloop", PGC_USERSET, QUERY_TUNING_METHOD,
885  gettext_noop("Enables the planner's use of nested-loop join plans."),
886  NULL,
887  GUC_EXPLAIN
888  },
889  &enable_nestloop,
890  true,
891  NULL, NULL, NULL
892  },
893  {
894  {"enable_mergejoin", PGC_USERSET, QUERY_TUNING_METHOD,
895  gettext_noop("Enables the planner's use of merge join plans."),
896  NULL,
897  GUC_EXPLAIN
898  },
899  &enable_mergejoin,
900  true,
901  NULL, NULL, NULL
902  },
903  {
904  {"enable_hashjoin", PGC_USERSET, QUERY_TUNING_METHOD,
905  gettext_noop("Enables the planner's use of hash join plans."),
906  NULL,
907  GUC_EXPLAIN
908  },
909  &enable_hashjoin,
910  true,
911  NULL, NULL, NULL
912  },
913  {
914  {"enable_gathermerge", PGC_USERSET, QUERY_TUNING_METHOD,
915  gettext_noop("Enables the planner's use of gather merge plans."),
916  NULL,
917  GUC_EXPLAIN
918  },
919  &enable_gathermerge,
920  true,
921  NULL, NULL, NULL
922  },
923  {
924  {"enable_partitionwise_join", PGC_USERSET, QUERY_TUNING_METHOD,
925  gettext_noop("Enables partitionwise join."),
926  NULL,
927  GUC_EXPLAIN
928  },
929  &enable_partitionwise_join,
930  false,
931  NULL, NULL, NULL
932  },
933  {
934  {"enable_partitionwise_aggregate", PGC_USERSET, QUERY_TUNING_METHOD,
935  gettext_noop("Enables partitionwise aggregation and grouping."),
936  NULL,
937  GUC_EXPLAIN
938  },
939  &enable_partitionwise_aggregate,
940  false,
941  NULL, NULL, NULL
942  },
943  {
944  {"enable_parallel_append", PGC_USERSET, QUERY_TUNING_METHOD,
945  gettext_noop("Enables the planner's use of parallel append plans."),
946  NULL,
947  GUC_EXPLAIN
948  },
949  &enable_parallel_append,
950  true,
951  NULL, NULL, NULL
952  },
953  {
954  {"enable_parallel_hash", PGC_USERSET, QUERY_TUNING_METHOD,
955  gettext_noop("Enables the planner's use of parallel hash plans."),
956  NULL,
957  GUC_EXPLAIN
958  },
959  &enable_parallel_hash,
960  true,
961  NULL, NULL, NULL
962  },
963  {
964  {"enable_partition_pruning", PGC_USERSET, QUERY_TUNING_METHOD,
965  gettext_noop("Enables plan-time and execution-time partition pruning."),
966  gettext_noop("Allows the query planner and executor to compare partition "
967  "bounds to conditions in the query to determine which "
968  "partitions must be scanned."),
969  GUC_EXPLAIN
970  },
971  &enable_partition_pruning,
972  true,
973  NULL, NULL, NULL
974  },
975  {
976  {"enable_presorted_aggregate", PGC_USERSET, QUERY_TUNING_METHOD,
977  gettext_noop("Enables the planner's ability to produce plans that "
978  "provide presorted input for ORDER BY / DISTINCT aggregate "
979  "functions."),
980  gettext_noop("Allows the query planner to build plans that provide "
981  "presorted input for aggregate functions with an ORDER BY / "
982  "DISTINCT clause. When disabled, implicit sorts are always "
983  "performed during execution."),
984  GUC_EXPLAIN
985  },
986  &enable_presorted_aggregate,
987  true,
988  NULL, NULL, NULL
989  },
990  {
991  {"enable_async_append", PGC_USERSET, QUERY_TUNING_METHOD,
992  gettext_noop("Enables the planner's use of async append plans."),
993  NULL,
994  GUC_EXPLAIN
995  },
996  &enable_async_append,
997  true,
998  NULL, NULL, NULL
999  },
1000  {
1001  {"enable_self_join_removal", PGC_USERSET, QUERY_TUNING_METHOD,
1002  gettext_noop("Enable removal of unique self-joins."),
1003  NULL,
1004  GUC_EXPLAIN | GUC_NOT_IN_SAMPLE
1005  },
1006  &enable_self_join_removal,
1007  true,
1008  NULL, NULL, NULL
1009  },
1010  {
1011  {"enable_group_by_reordering", PGC_USERSET, QUERY_TUNING_METHOD,
1012  gettext_noop("Enables reordering of GROUP BY keys."),
1013  NULL,
1014  GUC_EXPLAIN
1015  },
1016  &enable_group_by_reordering,
1017  true,
1018  NULL, NULL, NULL
1019  },
1020  {
1021  {"geqo", PGC_USERSET, QUERY_TUNING_GEQO,
1022  gettext_noop("Enables genetic query optimization."),
1023  gettext_noop("This algorithm attempts to do planning without "
1024  "exhaustive searching."),
1025  GUC_EXPLAIN
1026  },
1027  &enable_geqo,
1028  true,
1029  NULL, NULL, NULL
1030  },
1031  {
1032  /*
1033  * Not for general use --- used by SET SESSION AUTHORIZATION and SET
1034  * ROLE
1035  */
1036  {"is_superuser", PGC_INTERNAL, UNGROUPED,
1037  gettext_noop("Shows whether the current user is a superuser."),
1038  NULL,
1039  GUC_REPORT | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1040  },
1041  &current_role_is_superuser,
1042  false,
1043  NULL, NULL, NULL
1044  },
1045  {
1046  /*
1047  * This setting itself cannot be set by ALTER SYSTEM to avoid an
1048  * operator turning this setting off by using ALTER SYSTEM, without a
1049  * way to turn it back on.
1050  */
1051  {"allow_alter_system", PGC_SIGHUP, COMPAT_OPTIONS_OTHER,
1052  gettext_noop("Allows running the ALTER SYSTEM command."),
1053  gettext_noop("Can be set to off for environments where global configuration "
1054  "changes should be made using a different method."),
1055  GUC_DISALLOW_IN_AUTO_FILE
1056  },
1057  &AllowAlterSystem,
1058  true,
1059  NULL, NULL, NULL
1060  },
1061  {
1062  {"bonjour", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
1063  gettext_noop("Enables advertising the server via Bonjour."),
1064  NULL
1065  },
1066  &enable_bonjour,
1067  false,
1068  check_bonjour, NULL, NULL
1069  },
1070  {
1071  {"track_commit_timestamp", PGC_POSTMASTER, REPLICATION_SENDING,
1072  gettext_noop("Collects transaction commit time."),
1073  NULL
1074  },
1075  &track_commit_timestamp,
1076  false,
1077  NULL, NULL, NULL
1078  },
1079  {
1080  {"ssl", PGC_SIGHUP, CONN_AUTH_SSL,
1081  gettext_noop("Enables SSL connections."),
1082  NULL
1083  },
1084  &EnableSSL,
1085  false,
1086  check_ssl, NULL, NULL
1087  },
1088  {
1089  {"ssl_passphrase_command_supports_reload", PGC_SIGHUP, CONN_AUTH_SSL,
1090  gettext_noop("Controls whether ssl_passphrase_command is called during server reload."),
1091  NULL
1092  },
1093  &ssl_passphrase_command_supports_reload,
1094  false,
1095  NULL, NULL, NULL
1096  },
1097  {
1098  {"ssl_prefer_server_ciphers", PGC_SIGHUP, CONN_AUTH_SSL,
1099  gettext_noop("Give priority to server ciphersuite order."),
1100  NULL
1101  },
1102  &SSLPreferServerCiphers,
1103  true,
1104  NULL, NULL, NULL
1105  },
1106  {
1107  {"fsync", PGC_SIGHUP, WAL_SETTINGS,
1108  gettext_noop("Forces synchronization of updates to disk."),
1109  gettext_noop("The server will use the fsync() system call in several places to make "
1110  "sure that updates are physically written to disk. This ensures "
1111  "that a database cluster will recover to a consistent state after "
1112  "an operating system or hardware crash.")
1113  },
1114  &enableFsync,
1115  true,
1116  NULL, NULL, NULL
1117  },
1118  {
1119  {"ignore_checksum_failure", PGC_SUSET, DEVELOPER_OPTIONS,
1120  gettext_noop("Continues processing after a checksum failure."),
1121  gettext_noop("Detection of a checksum failure normally causes PostgreSQL to "
1122  "report an error, aborting the current transaction. Setting "
1123  "ignore_checksum_failure to true causes the system to ignore the failure "
1124  "(but still report a warning), and continue processing. This "
1125  "behavior could cause crashes or other serious problems. Only "
1126  "has an effect if checksums are enabled."),
1127  GUC_NOT_IN_SAMPLE
1128  },
1129  &ignore_checksum_failure,
1130  false,
1131  NULL, NULL, NULL
1132  },
1133  {
1134  {"zero_damaged_pages", PGC_SUSET, DEVELOPER_OPTIONS,
1135  gettext_noop("Continues processing past damaged page headers."),
1136  gettext_noop("Detection of a damaged page header normally causes PostgreSQL to "
1137  "report an error, aborting the current transaction. Setting "
1138  "zero_damaged_pages to true causes the system to instead report a "
1139  "warning, zero out the damaged page, and continue processing. This "
1140  "behavior will destroy data, namely all the rows on the damaged page."),
1141  GUC_NOT_IN_SAMPLE
1142  },
1143  &zero_damaged_pages,
1144  false,
1145  NULL, NULL, NULL
1146  },
1147  {
1148  {"ignore_invalid_pages", PGC_POSTMASTER, DEVELOPER_OPTIONS,
1149  gettext_noop("Continues recovery after an invalid pages failure."),
1150  gettext_noop("Detection of WAL records having references to "
1151  "invalid pages during recovery causes PostgreSQL to "
1152  "raise a PANIC-level error, aborting the recovery. "
1153  "Setting ignore_invalid_pages to true causes "
1154  "the system to ignore invalid page references "
1155  "in WAL records (but still report a warning), "
1156  "and continue recovery. This behavior may cause "
1157  "crashes, data loss, propagate or hide corruption, "
1158  "or other serious problems. Only has an effect "
1159  "during recovery or in standby mode."),
1160  GUC_NOT_IN_SAMPLE
1161  },
1162  &ignore_invalid_pages,
1163  false,
1164  NULL, NULL, NULL
1165  },
1166  {
1167  {"full_page_writes", PGC_SIGHUP, WAL_SETTINGS,
1168  gettext_noop("Writes full pages to WAL when first modified after a checkpoint."),
1169  gettext_noop("A page write in process during an operating system crash might be "
1170  "only partially written to disk. During recovery, the row changes "
1171  "stored in WAL are not enough to recover. This option writes "
1172  "pages when first modified after a checkpoint to WAL so full recovery "
1173  "is possible.")
1174  },
1175  &fullPageWrites,
1176  true,
1177  NULL, NULL, NULL
1178  },
1179 
1180  {
1181  {"wal_log_hints", PGC_POSTMASTER, WAL_SETTINGS,
1182  gettext_noop("Writes full pages to WAL when first modified after a checkpoint, even for a non-critical modification."),
1183  NULL
1184  },
1185  &wal_log_hints,
1186  false,
1187  NULL, NULL, NULL
1188  },
1189 
1190  {
1191  {"wal_init_zero", PGC_SUSET, WAL_SETTINGS,
1192  gettext_noop("Writes zeroes to new WAL files before first use."),
1193  NULL
1194  },
1195  &wal_init_zero,
1196  true,
1197  NULL, NULL, NULL
1198  },
1199 
1200  {
1201  {"wal_recycle", PGC_SUSET, WAL_SETTINGS,
1202  gettext_noop("Recycles WAL files by renaming them."),
1203  NULL
1204  },
1205  &wal_recycle,
1206  true,
1207  NULL, NULL, NULL
1208  },
1209 
1210  {
1211  {"log_checkpoints", PGC_SIGHUP, LOGGING_WHAT,
1212  gettext_noop("Logs each checkpoint."),
1213  NULL
1214  },
1215  &log_checkpoints,
1216  true,
1217  NULL, NULL, NULL
1218  },
1219  {
1220  {"log_connections", PGC_SU_BACKEND, LOGGING_WHAT,
1221  gettext_noop("Logs each successful connection."),
1222  NULL
1223  },
1224  &Log_connections,
1225  false,
1226  NULL, NULL, NULL
1227  },
1228  {
1229  {"trace_connection_negotiation", PGC_POSTMASTER, DEVELOPER_OPTIONS,
1230  gettext_noop("Logs details of pre-authentication connection handshake."),
1231  NULL,
1232  GUC_NOT_IN_SAMPLE
1233  },
1234  &Trace_connection_negotiation,
1235  false,
1236  NULL, NULL, NULL
1237  },
1238  {
1239  {"log_disconnections", PGC_SU_BACKEND, LOGGING_WHAT,
1240  gettext_noop("Logs end of a session, including duration."),
1241  NULL
1242  },
1243  &Log_disconnections,
1244  false,
1245  NULL, NULL, NULL
1246  },
1247  {
1248  {"log_replication_commands", PGC_SUSET, LOGGING_WHAT,
1249  gettext_noop("Logs each replication command."),
1250  NULL
1251  },
1252  &log_replication_commands,
1253  false,
1254  NULL, NULL, NULL
1255  },
1256  {
1257  {"debug_assertions", PGC_INTERNAL, PRESET_OPTIONS,
1258  gettext_noop("Shows whether the running server has assertion checks enabled."),
1259  NULL,
1260  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1261  },
1262  &assert_enabled,
1263  DEFAULT_ASSERT_ENABLED,
1264  NULL, NULL, NULL
1265  },
1266 
1267  {
1268  {"exit_on_error", PGC_USERSET, ERROR_HANDLING_OPTIONS,
1269  gettext_noop("Terminate session on any error."),
1270  NULL
1271  },
1272  &ExitOnAnyError,
1273  false,
1274  NULL, NULL, NULL
1275  },
1276  {
1277  {"restart_after_crash", PGC_SIGHUP, ERROR_HANDLING_OPTIONS,
1278  gettext_noop("Reinitialize server after backend crash."),
1279  NULL
1280  },
1281  &restart_after_crash,
1282  true,
1283  NULL, NULL, NULL
1284  },
1285  {
1286  {"remove_temp_files_after_crash", PGC_SIGHUP, DEVELOPER_OPTIONS,
1287  gettext_noop("Remove temporary files after backend crash."),
1288  NULL,
1289  GUC_NOT_IN_SAMPLE
1290  },
1291  &remove_temp_files_after_crash,
1292  true,
1293  NULL, NULL, NULL
1294  },
1295  {
1296  {"send_abort_for_crash", PGC_SIGHUP, DEVELOPER_OPTIONS,
1297  gettext_noop("Send SIGABRT not SIGQUIT to child processes after backend crash."),
1298  NULL,
1299  GUC_NOT_IN_SAMPLE
1300  },
1301  &send_abort_for_crash,
1302  false,
1303  NULL, NULL, NULL
1304  },
1305  {
1306  {"send_abort_for_kill", PGC_SIGHUP, DEVELOPER_OPTIONS,
1307  gettext_noop("Send SIGABRT not SIGKILL to stuck child processes."),
1308  NULL,
1309  GUC_NOT_IN_SAMPLE
1310  },
1311  &send_abort_for_kill,
1312  false,
1313  NULL, NULL, NULL
1314  },
1315 
1316  {
1317  {"log_duration", PGC_SUSET, LOGGING_WHAT,
1318  gettext_noop("Logs the duration of each completed SQL statement."),
1319  NULL
1320  },
1321  &log_duration,
1322  false,
1323  NULL, NULL, NULL
1324  },
1325  {
1326  {"debug_print_parse", PGC_USERSET, LOGGING_WHAT,
1327  gettext_noop("Logs each query's parse tree."),
1328  NULL
1329  },
1330  &Debug_print_parse,
1331  false,
1332  NULL, NULL, NULL
1333  },
1334  {
1335  {"debug_print_rewritten", PGC_USERSET, LOGGING_WHAT,
1336  gettext_noop("Logs each query's rewritten parse tree."),
1337  NULL
1338  },
1339  &Debug_print_rewritten,
1340  false,
1341  NULL, NULL, NULL
1342  },
1343  {
1344  {"debug_print_plan", PGC_USERSET, LOGGING_WHAT,
1345  gettext_noop("Logs each query's execution plan."),
1346  NULL
1347  },
1348  &Debug_print_plan,
1349  false,
1350  NULL, NULL, NULL
1351  },
1352  {
1353  {"debug_pretty_print", PGC_USERSET, LOGGING_WHAT,
1354  gettext_noop("Indents parse and plan tree displays."),
1355  NULL
1356  },
1357  &Debug_pretty_print,
1358  true,
1359  NULL, NULL, NULL
1360  },
1361  {
1362  {"log_parser_stats", PGC_SUSET, STATS_MONITORING,
1363  gettext_noop("Writes parser performance statistics to the server log."),
1364  NULL
1365  },
1366  &log_parser_stats,
1367  false,
1368  check_stage_log_stats, NULL, NULL
1369  },
1370  {
1371  {"log_planner_stats", PGC_SUSET, STATS_MONITORING,
1372  gettext_noop("Writes planner performance statistics to the server log."),
1373  NULL
1374  },
1375  &log_planner_stats,
1376  false,
1377  check_stage_log_stats, NULL, NULL
1378  },
1379  {
1380  {"log_executor_stats", PGC_SUSET, STATS_MONITORING,
1381  gettext_noop("Writes executor performance statistics to the server log."),
1382  NULL
1383  },
1384  &log_executor_stats,
1385  false,
1386  check_stage_log_stats, NULL, NULL
1387  },
1388  {
1389  {"log_statement_stats", PGC_SUSET, STATS_MONITORING,
1390  gettext_noop("Writes cumulative performance statistics to the server log."),
1391  NULL
1392  },
1393  &log_statement_stats,
1394  false,
1395  check_log_stats, NULL, NULL
1396  },
1397 #ifdef BTREE_BUILD_STATS
1398  {
1399  {"log_btree_build_stats", PGC_SUSET, DEVELOPER_OPTIONS,
1400  gettext_noop("Logs system resource usage statistics (memory and CPU) on various B-tree operations."),
1401  NULL,
1402  GUC_NOT_IN_SAMPLE
1403  },
1404  &log_btree_build_stats,
1405  false,
1406  NULL, NULL, NULL
1407  },
1408 #endif
1409 
1410  {
1411  {"track_activities", PGC_SUSET, STATS_CUMULATIVE,
1412  gettext_noop("Collects information about executing commands."),
1413  gettext_noop("Enables the collection of information on the currently "
1414  "executing command of each session, along with "
1415  "the time at which that command began execution.")
1416  },
1417  &pgstat_track_activities,
1418  true,
1419  NULL, NULL, NULL
1420  },
1421  {
1422  {"track_counts", PGC_SUSET, STATS_CUMULATIVE,
1423  gettext_noop("Collects statistics on database activity."),
1424  NULL
1425  },
1426  &pgstat_track_counts,
1427  true,
1428  NULL, NULL, NULL
1429  },
1430  {
1431  {"track_io_timing", PGC_SUSET, STATS_CUMULATIVE,
1432  gettext_noop("Collects timing statistics for database I/O activity."),
1433  NULL
1434  },
1435  &track_io_timing,
1436  false,
1437  NULL, NULL, NULL
1438  },
1439  {
1440  {"track_wal_io_timing", PGC_SUSET, STATS_CUMULATIVE,
1441  gettext_noop("Collects timing statistics for WAL I/O activity."),
1442  NULL
1443  },
1444  &track_wal_io_timing,
1445  false,
1446  NULL, NULL, NULL
1447  },
1448 
1449  {
1450  {"update_process_title", PGC_SUSET, PROCESS_TITLE,
1451  gettext_noop("Updates the process title to show the active SQL command."),
1452  gettext_noop("Enables updating of the process title every time a new SQL command is received by the server.")
1453  },
1454  &update_process_title,
1455  DEFAULT_UPDATE_PROCESS_TITLE,
1456  NULL, NULL, NULL
1457  },
1458 
1459  {
1460  {"autovacuum", PGC_SIGHUP, AUTOVACUUM,
1461  gettext_noop("Starts the autovacuum subprocess."),
1462  NULL
1463  },
1464  &autovacuum_start_daemon,
1465  true,
1466  NULL, NULL, NULL
1467  },
1468 
1469  {
1470  {"trace_notify", PGC_USERSET, DEVELOPER_OPTIONS,
1471  gettext_noop("Generates debugging output for LISTEN and NOTIFY."),
1472  NULL,
1473  GUC_NOT_IN_SAMPLE
1474  },
1475  &Trace_notify,
1476  false,
1477  NULL, NULL, NULL
1478  },
1479 
1480 #ifdef LOCK_DEBUG
1481  {
1482  {"trace_locks", PGC_SUSET, DEVELOPER_OPTIONS,
1483  gettext_noop("Emits information about lock usage."),
1484  NULL,
1485  GUC_NOT_IN_SAMPLE
1486  },
1487  &Trace_locks,
1488  false,
1489  NULL, NULL, NULL
1490  },
1491  {
1492  {"trace_userlocks", PGC_SUSET, DEVELOPER_OPTIONS,
1493  gettext_noop("Emits information about user lock usage."),
1494  NULL,
1495  GUC_NOT_IN_SAMPLE
1496  },
1497  &Trace_userlocks,
1498  false,
1499  NULL, NULL, NULL
1500  },
1501  {
1502  {"trace_lwlocks", PGC_SUSET, DEVELOPER_OPTIONS,
1503  gettext_noop("Emits information about lightweight lock usage."),
1504  NULL,
1505  GUC_NOT_IN_SAMPLE
1506  },
1507  &Trace_lwlocks,
1508  false,
1509  NULL, NULL, NULL
1510  },
1511  {
1512  {"debug_deadlocks", PGC_SUSET, DEVELOPER_OPTIONS,
1513  gettext_noop("Dumps information about all current locks when a deadlock timeout occurs."),
1514  NULL,
1515  GUC_NOT_IN_SAMPLE
1516  },
1517  &Debug_deadlocks,
1518  false,
1519  NULL, NULL, NULL
1520  },
1521 #endif
1522 
1523  {
1524  {"log_lock_waits", PGC_SUSET, LOGGING_WHAT,
1525  gettext_noop("Logs long lock waits."),
1526  NULL
1527  },
1528  &log_lock_waits,
1529  false,
1530  NULL, NULL, NULL
1531  },
1532  {
1533  {"log_recovery_conflict_waits", PGC_SIGHUP, LOGGING_WHAT,
1534  gettext_noop("Logs standby recovery conflict waits."),
1535  NULL
1536  },
1537  &log_recovery_conflict_waits,
1538  false,
1539  NULL, NULL, NULL
1540  },
1541  {
1542  {"log_hostname", PGC_SIGHUP, LOGGING_WHAT,
1543  gettext_noop("Logs the host name in the connection logs."),
1544  gettext_noop("By default, connection logs only show the IP address "
1545  "of the connecting host. If you want them to show the host name you "
1546  "can turn this on, but depending on your host name resolution "
1547  "setup it might impose a non-negligible performance penalty.")
1548  },
1549  &log_hostname,
1550  false,
1551  NULL, NULL, NULL
1552  },
1553  {
1554  {"transform_null_equals", PGC_USERSET, COMPAT_OPTIONS_OTHER,
1555  gettext_noop("Treats \"expr=NULL\" as \"expr IS NULL\"."),
1556  gettext_noop("When turned on, expressions of the form expr = NULL "
1557  "(or NULL = expr) are treated as expr IS NULL, that is, they "
1558  "return true if expr evaluates to the null value, and false "
1559  "otherwise. The correct behavior of expr = NULL is to always "
1560  "return null (unknown).")
1561  },
1562  &Transform_null_equals,
1563  false,
1564  NULL, NULL, NULL
1565  },
1566  {
1567  {"default_transaction_read_only", PGC_USERSET, CLIENT_CONN_STATEMENT,
1568  gettext_noop("Sets the default read-only status of new transactions."),
1569  NULL,
1570  GUC_REPORT
1571  },
1572  &DefaultXactReadOnly,
1573  false,
1574  NULL, NULL, NULL
1575  },
1576  {
1577  {"transaction_read_only", PGC_USERSET, CLIENT_CONN_STATEMENT,
1578  gettext_noop("Sets the current transaction's read-only status."),
1579  NULL,
1580  GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1581  },
1582  &XactReadOnly,
1583  false,
1584  check_transaction_read_only, NULL, NULL
1585  },
1586  {
1587  {"default_transaction_deferrable", PGC_USERSET, CLIENT_CONN_STATEMENT,
1588  gettext_noop("Sets the default deferrable status of new transactions."),
1589  NULL
1590  },
1591  &DefaultXactDeferrable,
1592  false,
1593  NULL, NULL, NULL
1594  },
1595  {
1596  {"transaction_deferrable", PGC_USERSET, CLIENT_CONN_STATEMENT,
1597  gettext_noop("Whether to defer a read-only serializable transaction until it can be executed with no possible serialization failures."),
1598  NULL,
1599  GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1600  },
1601  &XactDeferrable,
1602  false,
1603  check_transaction_deferrable, NULL, NULL
1604  },
1605  {
1606  {"row_security", PGC_USERSET, CLIENT_CONN_STATEMENT,
1607  gettext_noop("Enable row security."),
1608  gettext_noop("When enabled, row security will be applied to all users.")
1609  },
1610  &row_security,
1611  true,
1612  NULL, NULL, NULL
1613  },
1614  {
1615  {"check_function_bodies", PGC_USERSET, CLIENT_CONN_STATEMENT,
1616  gettext_noop("Check routine bodies during CREATE FUNCTION and CREATE PROCEDURE."),
1617  NULL
1618  },
1619  &check_function_bodies,
1620  true,
1621  NULL, NULL, NULL
1622  },
1623  {
1624  {"array_nulls", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1625  gettext_noop("Enable input of NULL elements in arrays."),
1626  gettext_noop("When turned on, unquoted NULL in an array input "
1627  "value means a null value; "
1628  "otherwise it is taken literally.")
1629  },
1630  &Array_nulls,
1631  true,
1632  NULL, NULL, NULL
1633  },
1634 
1635  /*
1636  * WITH OIDS support, and consequently default_with_oids, was removed in
1637  * PostgreSQL 12, but we tolerate the parameter being set to false to
1638  * avoid unnecessarily breaking older dump files.
1639  */
1640  {
1641  {"default_with_oids", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1642  gettext_noop("WITH OIDS is no longer supported; this can only be false."),
1643  NULL,
1644  GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE
1645  },
1646  &default_with_oids,
1647  false,
1648  check_default_with_oids, NULL, NULL
1649  },
1650  {
1651  {"logging_collector", PGC_POSTMASTER, LOGGING_WHERE,
1652  gettext_noop("Start a subprocess to capture stderr output and/or csvlogs into log files."),
1653  NULL
1654  },
1655  &Logging_collector,
1656  false,
1657  NULL, NULL, NULL
1658  },
1659  {
1660  {"log_truncate_on_rotation", PGC_SIGHUP, LOGGING_WHERE,
1661  gettext_noop("Truncate existing log files of same name during log rotation."),
1662  NULL
1663  },
1664  &Log_truncate_on_rotation,
1665  false,
1666  NULL, NULL, NULL
1667  },
1668 
1669 #ifdef TRACE_SORT
1670  {
1671  {"trace_sort", PGC_USERSET, DEVELOPER_OPTIONS,
1672  gettext_noop("Emit information about resource usage in sorting."),
1673  NULL,
1674  GUC_NOT_IN_SAMPLE
1675  },
1676  &trace_sort,
1677  false,
1678  NULL, NULL, NULL
1679  },
1680 #endif
1681 
1682 #ifdef TRACE_SYNCSCAN
1683  /* this is undocumented because not exposed in a standard build */
1684  {
1685  {"trace_syncscan", PGC_USERSET, DEVELOPER_OPTIONS,
1686  gettext_noop("Generate debugging output for synchronized scanning."),
1687  NULL,
1688  GUC_NOT_IN_SAMPLE
1689  },
1690  &trace_syncscan,
1691  false,
1692  NULL, NULL, NULL
1693  },
1694 #endif
1695 
1696 #ifdef DEBUG_BOUNDED_SORT
1697  /* this is undocumented because not exposed in a standard build */
1698  {
1699  {
1700  "optimize_bounded_sort", PGC_USERSET, QUERY_TUNING_METHOD,
1701  gettext_noop("Enable bounded sorting using heap sort."),
1702  NULL,
1703  GUC_NOT_IN_SAMPLE | GUC_EXPLAIN
1704  },
1705  &optimize_bounded_sort,
1706  true,
1707  NULL, NULL, NULL
1708  },
1709 #endif
1710 
1711 #ifdef WAL_DEBUG
1712  {
1713  {"wal_debug", PGC_SUSET, DEVELOPER_OPTIONS,
1714  gettext_noop("Emit WAL-related debugging output."),
1715  NULL,
1716  GUC_NOT_IN_SAMPLE
1717  },
1718  &XLOG_DEBUG,
1719  false,
1720  NULL, NULL, NULL
1721  },
1722 #endif
1723 
1724  {
1725  {"integer_datetimes", PGC_INTERNAL, PRESET_OPTIONS,
1726  gettext_noop("Shows whether datetimes are integer based."),
1727  NULL,
1728  GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1729  },
1730  &integer_datetimes,
1731  true,
1732  NULL, NULL, NULL
1733  },
1734 
1735  {
1736  {"krb_caseins_users", PGC_SIGHUP, CONN_AUTH_AUTH,
1737  gettext_noop("Sets whether Kerberos and GSSAPI user names should be treated as case-insensitive."),
1738  NULL
1739  },
1740  &pg_krb_caseins_users,
1741  false,
1742  NULL, NULL, NULL
1743  },
1744 
1745  {
1746  {"gss_accept_delegation", PGC_SIGHUP, CONN_AUTH_AUTH,
1747  gettext_noop("Sets whether GSSAPI delegation should be accepted from the client."),
1748  NULL
1749  },
1750  &pg_gss_accept_delegation,
1751  false,
1752  NULL, NULL, NULL
1753  },
1754 
1755  {
1756  {"escape_string_warning", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1757  gettext_noop("Warn about backslash escapes in ordinary string literals."),
1758  NULL
1759  },
1760  &escape_string_warning,
1761  true,
1762  NULL, NULL, NULL
1763  },
1764 
1765  {
1766  {"standard_conforming_strings", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1767  gettext_noop("Causes '...' strings to treat backslashes literally."),
1768  NULL,
1769  GUC_REPORT
1770  },
1771  &standard_conforming_strings,
1772  true,
1773  NULL, NULL, NULL
1774  },
1775 
1776  {
1777  {"synchronize_seqscans", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1778  gettext_noop("Enable synchronized sequential scans."),
1779  NULL
1780  },
1781  &synchronize_seqscans,
1782  true,
1783  NULL, NULL, NULL
1784  },
1785 
1786  {
1787  {"recovery_target_inclusive", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
1788  gettext_noop("Sets whether to include or exclude transaction with recovery target."),
1789  NULL
1790  },
1791  &recoveryTargetInclusive,
1792  true,
1793  NULL, NULL, NULL
1794  },
1795 
1796  {
1797  {"summarize_wal", PGC_SIGHUP, WAL_SUMMARIZATION,
1798  gettext_noop("Starts the WAL summarizer process to enable incremental backup."),
1799  NULL
1800  },
1801  &summarize_wal,
1802  false,
1803  NULL, NULL, NULL
1804  },
1805 
1806  {
1807  {"hot_standby", PGC_POSTMASTER, REPLICATION_STANDBY,
1808  gettext_noop("Allows connections and queries during recovery."),
1809  NULL
1810  },
1811  &EnableHotStandby,
1812  true,
1813  NULL, NULL, NULL
1814  },
1815 
1816  {
1817  {"hot_standby_feedback", PGC_SIGHUP, REPLICATION_STANDBY,
1818  gettext_noop("Allows feedback from a hot standby to the primary that will avoid query conflicts."),
1819  NULL
1820  },
1821  &hot_standby_feedback,
1822  false,
1823  NULL, NULL, NULL
1824  },
1825 
1826  {
1827  {"in_hot_standby", PGC_INTERNAL, PRESET_OPTIONS,
1828  gettext_noop("Shows whether hot standby is currently active."),
1829  NULL,
1830  GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
1831  },
1832  &in_hot_standby_guc,
1833  false,
1834  NULL, NULL, show_in_hot_standby
1835  },
1836 
1837  {
1838  {"allow_system_table_mods", PGC_SUSET, DEVELOPER_OPTIONS,
1839  gettext_noop("Allows modifications of the structure of system tables."),
1840  NULL,
1841  GUC_NOT_IN_SAMPLE
1842  },
1843  &allowSystemTableMods,
1844  false,
1845  NULL, NULL, NULL
1846  },
1847 
1848  {
1849  {"ignore_system_indexes", PGC_BACKEND, DEVELOPER_OPTIONS,
1850  gettext_noop("Disables reading from system indexes."),
1851  gettext_noop("It does not prevent updating the indexes, so it is safe "
1852  "to use. The worst consequence is slowness."),
1853  GUC_NOT_IN_SAMPLE
1854  },
1855  &IgnoreSystemIndexes,
1856  false,
1857  NULL, NULL, NULL
1858  },
1859 
1860  {
1861  {"allow_in_place_tablespaces", PGC_SUSET, DEVELOPER_OPTIONS,
1862  gettext_noop("Allows tablespaces directly inside pg_tblspc, for testing."),
1863  NULL,
1864  GUC_NOT_IN_SAMPLE
1865  },
1866  &allow_in_place_tablespaces,
1867  false,
1868  NULL, NULL, NULL
1869  },
1870 
1871  {
1872  {"lo_compat_privileges", PGC_SUSET, COMPAT_OPTIONS_PREVIOUS,
1873  gettext_noop("Enables backward compatibility mode for privilege checks on large objects."),
1874  gettext_noop("Skips privilege checks when reading or modifying large objects, "
1875  "for compatibility with PostgreSQL releases prior to 9.0.")
1876  },
1877  &lo_compat_privileges,
1878  false,
1879  NULL, NULL, NULL
1880  },
1881 
1882  {
1883  {"quote_all_identifiers", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
1884  gettext_noop("When generating SQL fragments, quote all identifiers."),
1885  NULL,
1886  },
1887  &quote_all_identifiers,
1888  false,
1889  NULL, NULL, NULL
1890  },
1891 
1892  {
1893  {"data_checksums", PGC_INTERNAL, PRESET_OPTIONS,
1894  gettext_noop("Shows whether data checksums are turned on for this cluster."),
1895  NULL,
1896  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
1897  },
1898  &data_checksums,
1899  false,
1900  NULL, NULL, NULL
1901  },
1902 
1903  {
1904  {"syslog_sequence_numbers", PGC_SIGHUP, LOGGING_WHERE,
1905  gettext_noop("Add sequence number to syslog messages to avoid duplicate suppression."),
1906  NULL
1907  },
1908  &syslog_sequence_numbers,
1909  true,
1910  NULL, NULL, NULL
1911  },
1912 
1913  {
1914  {"syslog_split_messages", PGC_SIGHUP, LOGGING_WHERE,
1915  gettext_noop("Split messages sent to syslog by lines and to fit into 1024 bytes."),
1916  NULL
1917  },
1918  &syslog_split_messages,
1919  true,
1920  NULL, NULL, NULL
1921  },
1922 
1923  {
1924  {"parallel_leader_participation", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
1925  gettext_noop("Controls whether Gather and Gather Merge also run subplans."),
1926  gettext_noop("Should gather nodes also run subplans or just gather tuples?"),
1927  GUC_EXPLAIN
1928  },
1929  &parallel_leader_participation,
1930  true,
1931  NULL, NULL, NULL
1932  },
1933 
1934  {
1935  {"jit", PGC_USERSET, QUERY_TUNING_OTHER,
1936  gettext_noop("Allow JIT compilation."),
1937  NULL,
1938  GUC_EXPLAIN
1939  },
1940  &jit_enabled,
1941  true,
1942  NULL, NULL, NULL
1943  },
1944 
1945  {
1946  {"jit_debugging_support", PGC_SU_BACKEND, DEVELOPER_OPTIONS,
1947  gettext_noop("Register JIT-compiled functions with debugger."),
1948  NULL,
1949  GUC_NOT_IN_SAMPLE
1950  },
1951  &jit_debugging_support,
1952  false,
1953 
1954  /*
1955  * This is not guaranteed to be available, but given it's a developer
1956  * oriented option, it doesn't seem worth adding code checking
1957  * availability.
1958  */
1959  NULL, NULL, NULL
1960  },
1961 
1962  {
1963  {"jit_dump_bitcode", PGC_SUSET, DEVELOPER_OPTIONS,
1964  gettext_noop("Write out LLVM bitcode to facilitate JIT debugging."),
1965  NULL,
1966  GUC_NOT_IN_SAMPLE
1967  },
1968  &jit_dump_bitcode,
1969  false,
1970  NULL, NULL, NULL
1971  },
1972 
1973  {
1974  {"jit_expressions", PGC_USERSET, DEVELOPER_OPTIONS,
1975  gettext_noop("Allow JIT compilation of expressions."),
1976  NULL,
1977  GUC_NOT_IN_SAMPLE
1978  },
1979  &jit_expressions,
1980  true,
1981  NULL, NULL, NULL
1982  },
1983 
1984  {
1985  {"jit_profiling_support", PGC_SU_BACKEND, DEVELOPER_OPTIONS,
1986  gettext_noop("Register JIT-compiled functions with perf profiler."),
1987  NULL,
1988  GUC_NOT_IN_SAMPLE
1989  },
1990  &jit_profiling_support,
1991  false,
1992 
1993  /*
1994  * This is not guaranteed to be available, but given it's a developer
1995  * oriented option, it doesn't seem worth adding code checking
1996  * availability.
1997  */
1998  NULL, NULL, NULL
1999  },
2000 
2001  {
2002  {"jit_tuple_deforming", PGC_USERSET, DEVELOPER_OPTIONS,
2003  gettext_noop("Allow JIT compilation of tuple deforming."),
2004  NULL,
2005  GUC_NOT_IN_SAMPLE
2006  },
2007  &jit_tuple_deforming,
2008  true,
2009  NULL, NULL, NULL
2010  },
2011 
2012  {
2013  {"data_sync_retry", PGC_POSTMASTER, ERROR_HANDLING_OPTIONS,
2014  gettext_noop("Whether to continue running after a failure to sync data files."),
2015  },
2016  &data_sync_retry,
2017  false,
2018  NULL, NULL, NULL
2019  },
2020 
2021  {
2022  {"wal_receiver_create_temp_slot", PGC_SIGHUP, REPLICATION_STANDBY,
2023  gettext_noop("Sets whether a WAL receiver should create a temporary replication slot if no permanent slot is configured."),
2024  },
2025  &wal_receiver_create_temp_slot,
2026  false,
2027  NULL, NULL, NULL
2028  },
2029 
2030  {
2031  {"event_triggers", PGC_SUSET, CLIENT_CONN_STATEMENT,
2032  gettext_noop("Enables event triggers."),
2033  gettext_noop("When enabled, event triggers will fire for all applicable statements."),
2034  },
2035  &event_triggers,
2036  true,
2037  NULL, NULL, NULL
2038  },
2039 
2040  {
2041  {"sync_replication_slots", PGC_SIGHUP, REPLICATION_STANDBY,
2042  gettext_noop("Enables a physical standby to synchronize logical failover slots from the primary server."),
2043  },
2044  &sync_replication_slots,
2045  false,
2046  NULL, NULL, NULL
2047  },
2048 
2049  /* End-of-list marker */
2050  {
2051  {NULL, 0, 0, NULL, NULL}, NULL, false, NULL, NULL, NULL
2052  }
2053 };
2054 
2055 
2056 struct config_int ConfigureNamesInt[] =
2057 {
2058  {
2059  {"archive_timeout", PGC_SIGHUP, WAL_ARCHIVING,
2060  gettext_noop("Sets the amount of time to wait before forcing a "
2061  "switch to the next WAL file."),
2062  NULL,
2063  GUC_UNIT_S
2064  },
2065  &XLogArchiveTimeout,
2066  0, 0, INT_MAX / 2,
2067  NULL, NULL, NULL
2068  },
2069  {
2070  {"post_auth_delay", PGC_BACKEND, DEVELOPER_OPTIONS,
2071  gettext_noop("Sets the amount of time to wait after "
2072  "authentication on connection startup."),
2073  gettext_noop("This allows attaching a debugger to the process."),
2074  GUC_NOT_IN_SAMPLE | GUC_UNIT_S
2075  },
2076  &PostAuthDelay,
2077  0, 0, INT_MAX / 1000000,
2078  NULL, NULL, NULL
2079  },
2080  {
2081  {"default_statistics_target", PGC_USERSET, QUERY_TUNING_OTHER,
2082  gettext_noop("Sets the default statistics target."),
2083  gettext_noop("This applies to table columns that have not had a "
2084  "column-specific target set via ALTER TABLE SET STATISTICS.")
2085  },
2086  &default_statistics_target,
2087  100, 1, MAX_STATISTICS_TARGET,
2088  NULL, NULL, NULL
2089  },
2090  {
2091  {"from_collapse_limit", PGC_USERSET, QUERY_TUNING_OTHER,
2092  gettext_noop("Sets the FROM-list size beyond which subqueries "
2093  "are not collapsed."),
2094  gettext_noop("The planner will merge subqueries into upper "
2095  "queries if the resulting FROM list would have no more than "
2096  "this many items."),
2097  GUC_EXPLAIN
2098  },
2099  &from_collapse_limit,
2100  8, 1, INT_MAX,
2101  NULL, NULL, NULL
2102  },
2103  {
2104  {"join_collapse_limit", PGC_USERSET, QUERY_TUNING_OTHER,
2105  gettext_noop("Sets the FROM-list size beyond which JOIN "
2106  "constructs are not flattened."),
2107  gettext_noop("The planner will flatten explicit JOIN "
2108  "constructs into lists of FROM items whenever a "
2109  "list of no more than this many items would result."),
2110  GUC_EXPLAIN
2111  },
2112  &join_collapse_limit,
2113  8, 1, INT_MAX,
2114  NULL, NULL, NULL
2115  },
2116  {
2117  {"geqo_threshold", PGC_USERSET, QUERY_TUNING_GEQO,
2118  gettext_noop("Sets the threshold of FROM items beyond which GEQO is used."),
2119  NULL,
2120  GUC_EXPLAIN
2121  },
2122  &geqo_threshold,
2123  12, 2, INT_MAX,
2124  NULL, NULL, NULL
2125  },
2126  {
2127  {"geqo_effort", PGC_USERSET, QUERY_TUNING_GEQO,
2128  gettext_noop("GEQO: effort is used to set the default for other GEQO parameters."),
2129  NULL,
2130  GUC_EXPLAIN
2131  },
2132  &Geqo_effort,
2133  DEFAULT_GEQO_EFFORT, MIN_GEQO_EFFORT, MAX_GEQO_EFFORT,
2134  NULL, NULL, NULL
2135  },
2136  {
2137  {"geqo_pool_size", PGC_USERSET, QUERY_TUNING_GEQO,
2138  gettext_noop("GEQO: number of individuals in the population."),
2139  gettext_noop("Zero selects a suitable default value."),
2140  GUC_EXPLAIN
2141  },
2142  &Geqo_pool_size,
2143  0, 0, INT_MAX,
2144  NULL, NULL, NULL
2145  },
2146  {
2147  {"geqo_generations", PGC_USERSET, QUERY_TUNING_GEQO,
2148  gettext_noop("GEQO: number of iterations of the algorithm."),
2149  gettext_noop("Zero selects a suitable default value."),
2150  GUC_EXPLAIN
2151  },
2152  &Geqo_generations,
2153  0, 0, INT_MAX,
2154  NULL, NULL, NULL
2155  },
2156 
2157  {
2158  /* This is PGC_SUSET to prevent hiding from log_lock_waits. */
2159  {"deadlock_timeout", PGC_SUSET, LOCK_MANAGEMENT,
2160  gettext_noop("Sets the time to wait on a lock before checking for deadlock."),
2161  NULL,
2162  GUC_UNIT_MS
2163  },
2164  &DeadlockTimeout,
2165  1000, 1, INT_MAX,
2166  NULL, NULL, NULL
2167  },
2168 
2169  {
2170  {"max_standby_archive_delay", PGC_SIGHUP, REPLICATION_STANDBY,
2171  gettext_noop("Sets the maximum delay before canceling queries when a hot standby server is processing archived WAL data."),
2172  NULL,
2173  GUC_UNIT_MS
2174  },
2175  &max_standby_archive_delay,
2176  30 * 1000, -1, INT_MAX,
2177  NULL, NULL, NULL
2178  },
2179 
2180  {
2181  {"max_standby_streaming_delay", PGC_SIGHUP, REPLICATION_STANDBY,
2182  gettext_noop("Sets the maximum delay before canceling queries when a hot standby server is processing streamed WAL data."),
2183  NULL,
2184  GUC_UNIT_MS
2185  },
2186  &max_standby_streaming_delay,
2187  30 * 1000, -1, INT_MAX,
2188  NULL, NULL, NULL
2189  },
2190 
2191  {
2192  {"recovery_min_apply_delay", PGC_SIGHUP, REPLICATION_STANDBY,
2193  gettext_noop("Sets the minimum delay for applying changes during recovery."),
2194  NULL,
2195  GUC_UNIT_MS
2196  },
2197  &recovery_min_apply_delay,
2198  0, 0, INT_MAX,
2199  NULL, NULL, NULL
2200  },
2201 
2202  {
2203  {"wal_receiver_status_interval", PGC_SIGHUP, REPLICATION_STANDBY,
2204  gettext_noop("Sets the maximum interval between WAL receiver status reports to the sending server."),
2205  NULL,
2206  GUC_UNIT_S
2207  },
2208  &wal_receiver_status_interval,
2209  10, 0, INT_MAX / 1000,
2210  NULL, NULL, NULL
2211  },
2212 
2213  {
2214  {"wal_receiver_timeout", PGC_SIGHUP, REPLICATION_STANDBY,
2215  gettext_noop("Sets the maximum wait time to receive data from the sending server."),
2216  NULL,
2217  GUC_UNIT_MS
2218  },
2219  &wal_receiver_timeout,
2220  60 * 1000, 0, INT_MAX,
2221  NULL, NULL, NULL
2222  },
2223 
2224  {
2225  {"max_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2226  gettext_noop("Sets the maximum number of concurrent connections."),
2227  NULL
2228  },
2229  &MaxConnections,
2230  100, 1, MAX_BACKENDS,
2231  check_max_connections, NULL, NULL
2232  },
2233 
2234  {
2235  /* see max_connections */
2236  {"superuser_reserved_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2237  gettext_noop("Sets the number of connection slots reserved for superusers."),
2238  NULL
2239  },
2240  &SuperuserReservedConnections,
2241  3, 0, MAX_BACKENDS,
2242  NULL, NULL, NULL
2243  },
2244 
2245  {
2246  {"reserved_connections", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2247  gettext_noop("Sets the number of connection slots reserved for roles "
2248  "with privileges of pg_use_reserved_connections."),
2249  NULL
2250  },
2251  &ReservedConnections,
2252  0, 0, MAX_BACKENDS,
2253  NULL, NULL, NULL
2254  },
2255 
2256  {
2257  {"min_dynamic_shared_memory", PGC_POSTMASTER, RESOURCES_MEM,
2258  gettext_noop("Amount of dynamic shared memory reserved at startup."),
2259  NULL,
2260  GUC_UNIT_MB
2261  },
2262  &min_dynamic_shared_memory,
2263  0, 0, (int) Min((size_t) INT_MAX, SIZE_MAX / (1024 * 1024)),
2264  NULL, NULL, NULL
2265  },
2266 
2267  /*
2268  * We sometimes multiply the number of shared buffers by two without
2269  * checking for overflow, so we mustn't allow more than INT_MAX / 2.
2270  */
2271  {
2272  {"shared_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2273  gettext_noop("Sets the number of shared memory buffers used by the server."),
2274  NULL,
2275  GUC_UNIT_BLOCKS
2276  },
2277  &NBuffers,
2278  16384, 16, INT_MAX / 2,
2279  NULL, NULL, NULL
2280  },
2281 
2282  {
2283  {"vacuum_buffer_usage_limit", PGC_USERSET, RESOURCES_MEM,
2284  gettext_noop("Sets the buffer pool size for VACUUM, ANALYZE, and autovacuum."),
2285  NULL,
2286  GUC_UNIT_KB
2287  },
2288  &VacuumBufferUsageLimit,
2289  2048, 0, MAX_BAS_VAC_RING_SIZE_KB,
2290  check_vacuum_buffer_usage_limit, NULL, NULL
2291  },
2292 
2293  {
2294  {"shared_memory_size", PGC_INTERNAL, PRESET_OPTIONS,
2295  gettext_noop("Shows the size of the server's main shared memory area (rounded up to the nearest MB)."),
2296  NULL,
2297  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_UNIT_MB | GUC_RUNTIME_COMPUTED
2298  },
2299  &shared_memory_size_mb,
2300  0, 0, INT_MAX,
2301  NULL, NULL, NULL
2302  },
2303 
2304  {
2305  {"shared_memory_size_in_huge_pages", PGC_INTERNAL, PRESET_OPTIONS,
2306  gettext_noop("Shows the number of huge pages needed for the main shared memory area."),
2307  gettext_noop("-1 indicates that the value could not be determined."),
2308  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
2309  },
2310  &shared_memory_size_in_huge_pages,
2311  -1, -1, INT_MAX,
2312  NULL, NULL, NULL
2313  },
2314 
2315  {
2316  {"commit_timestamp_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2317  gettext_noop("Sets the size of the dedicated buffer pool used for the commit timestamp cache."),
2318  gettext_noop("Specify 0 to have this value determined as a fraction of shared_buffers."),
2319  GUC_UNIT_BLOCKS
2320  },
2321  &commit_timestamp_buffers,
2322  0, 0, SLRU_MAX_ALLOWED_BUFFERS,
2323  check_commit_ts_buffers, NULL, NULL
2324  },
2325 
2326  {
2327  {"multixact_member_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2328  gettext_noop("Sets the size of the dedicated buffer pool used for the MultiXact member cache."),
2329  NULL,
2330  GUC_UNIT_BLOCKS
2331  },
2332  &multixact_member_buffers,
2333  32, 16, SLRU_MAX_ALLOWED_BUFFERS,
2334  check_multixact_member_buffers, NULL, NULL
2335  },
2336 
2337  {
2338  {"multixact_offset_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2339  gettext_noop("Sets the size of the dedicated buffer pool used for the MultiXact offset cache."),
2340  NULL,
2341  GUC_UNIT_BLOCKS
2342  },
2343  &multixact_offset_buffers,
2344  16, 16, SLRU_MAX_ALLOWED_BUFFERS,
2345  check_multixact_offset_buffers, NULL, NULL
2346  },
2347 
2348  {
2349  {"notify_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2350  gettext_noop("Sets the size of the dedicated buffer pool used for the LISTEN/NOTIFY message cache."),
2351  NULL,
2352  GUC_UNIT_BLOCKS
2353  },
2354  &notify_buffers,
2355  16, 16, SLRU_MAX_ALLOWED_BUFFERS,
2356  check_notify_buffers, NULL, NULL
2357  },
2358 
2359  {
2360  {"serializable_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2361  gettext_noop("Sets the size of the dedicated buffer pool used for the serializable transaction cache."),
2362  NULL,
2363  GUC_UNIT_BLOCKS
2364  },
2365  &serializable_buffers,
2366  32, 16, SLRU_MAX_ALLOWED_BUFFERS,
2367  check_serial_buffers, NULL, NULL
2368  },
2369 
2370  {
2371  {"subtransaction_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2372  gettext_noop("Sets the size of the dedicated buffer pool used for the sub-transaction cache."),
2373  gettext_noop("Specify 0 to have this value determined as a fraction of shared_buffers."),
2374  GUC_UNIT_BLOCKS
2375  },
2376  &subtransaction_buffers,
2377  0, 0, SLRU_MAX_ALLOWED_BUFFERS,
2378  check_subtrans_buffers, NULL, NULL
2379  },
2380 
2381  {
2382  {"transaction_buffers", PGC_POSTMASTER, RESOURCES_MEM,
2383  gettext_noop("Sets the size of the dedicated buffer pool used for the transaction status cache."),
2384  gettext_noop("Specify 0 to have this value determined as a fraction of shared_buffers."),
2385  GUC_UNIT_BLOCKS
2386  },
2387  &transaction_buffers,
2388  0, 0, SLRU_MAX_ALLOWED_BUFFERS,
2389  check_transaction_buffers, NULL, NULL
2390  },
2391 
2392  {
2393  {"temp_buffers", PGC_USERSET, RESOURCES_MEM,
2394  gettext_noop("Sets the maximum number of temporary buffers used by each session."),
2395  NULL,
2396  GUC_UNIT_BLOCKS | GUC_EXPLAIN
2397  },
2398  &num_temp_buffers,
2399  1024, 100, INT_MAX / 2,
2400  check_temp_buffers, NULL, NULL
2401  },
2402 
2403  {
2404  {"port", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2405  gettext_noop("Sets the TCP port the server listens on."),
2406  NULL
2407  },
2408  &PostPortNumber,
2409  DEF_PGPORT, 1, 65535,
2410  NULL, NULL, NULL
2411  },
2412 
2413  {
2414  {"unix_socket_permissions", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
2415  gettext_noop("Sets the access permissions of the Unix-domain socket."),
2416  gettext_noop("Unix-domain sockets use the usual Unix file system "
2417  "permission set. The parameter value is expected "
2418  "to be a numeric mode specification in the form "
2419  "accepted by the chmod and umask system calls. "
2420  "(To use the customary octal format the number must "
2421  "start with a 0 (zero).)")
2422  },
2423  &Unix_socket_permissions,
2424  0777, 0000, 0777,
2425  NULL, NULL, show_unix_socket_permissions
2426  },
2427 
2428  {
2429  {"log_file_mode", PGC_SIGHUP, LOGGING_WHERE,
2430  gettext_noop("Sets the file permissions for log files."),
2431  gettext_noop("The parameter value is expected "
2432  "to be a numeric mode specification in the form "
2433  "accepted by the chmod and umask system calls. "
2434  "(To use the customary octal format the number must "
2435  "start with a 0 (zero).)")
2436  },
2437  &Log_file_mode,
2438  0600, 0000, 0777,
2439  NULL, NULL, show_log_file_mode
2440  },
2441 
2442 
2443  {
2444  {"data_directory_mode", PGC_INTERNAL, PRESET_OPTIONS,
2445  gettext_noop("Shows the mode of the data directory."),
2446  gettext_noop("The parameter value is a numeric mode specification "
2447  "in the form accepted by the chmod and umask system "
2448  "calls. (To use the customary octal format the number "
2449  "must start with a 0 (zero).)"),
2450  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
2451  },
2452  &data_directory_mode,
2453  0700, 0000, 0777,
2454  NULL, NULL, show_data_directory_mode
2455  },
2456 
2457  {
2458  {"work_mem", PGC_USERSET, RESOURCES_MEM,
2459  gettext_noop("Sets the maximum memory to be used for query workspaces."),
2460  gettext_noop("This much memory can be used by each internal "
2461  "sort operation and hash table before switching to "
2462  "temporary disk files."),
2463  GUC_UNIT_KB | GUC_EXPLAIN
2464  },
2465  &work_mem,
2466  4096, 64, MAX_KILOBYTES,
2467  NULL, NULL, NULL
2468  },
2469 
2470  {
2471  {"maintenance_work_mem", PGC_USERSET, RESOURCES_MEM,
2472  gettext_noop("Sets the maximum memory to be used for maintenance operations."),
2473  gettext_noop("This includes operations such as VACUUM and CREATE INDEX."),
2474  GUC_UNIT_KB
2475  },
2476  &maintenance_work_mem,
2477  65536, 1024, MAX_KILOBYTES,
2478  NULL, NULL, NULL
2479  },
2480 
2481  {
2482  {"logical_decoding_work_mem", PGC_USERSET, RESOURCES_MEM,
2483  gettext_noop("Sets the maximum memory to be used for logical decoding."),
2484  gettext_noop("This much memory can be used by each internal "
2485  "reorder buffer before spilling to disk."),
2486  GUC_UNIT_KB
2487  },
2488  &logical_decoding_work_mem,
2489  65536, 64, MAX_KILOBYTES,
2490  NULL, NULL, NULL
2491  },
2492 
2493  /*
2494  * We use the hopefully-safely-small value of 100kB as the compiled-in
2495  * default for max_stack_depth. InitializeGUCOptions will increase it if
2496  * possible, depending on the actual platform-specific stack limit.
2497  */
2498  {
2499  {"max_stack_depth", PGC_SUSET, RESOURCES_MEM,
2500  gettext_noop("Sets the maximum stack depth, in kilobytes."),
2501  NULL,
2502  GUC_UNIT_KB
2503  },
2504  &max_stack_depth,
2505  100, 100, MAX_KILOBYTES,
2506  check_max_stack_depth, assign_max_stack_depth, NULL
2507  },
2508 
2509  {
2510  {"temp_file_limit", PGC_SUSET, RESOURCES_DISK,
2511  gettext_noop("Limits the total size of all temporary files used by each process."),
2512  gettext_noop("-1 means no limit."),
2513  GUC_UNIT_KB
2514  },
2515  &temp_file_limit,
2516  -1, -1, INT_MAX,
2517  NULL, NULL, NULL
2518  },
2519 
2520  {
2521  {"vacuum_cost_page_hit", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2522  gettext_noop("Vacuum cost for a page found in the buffer cache."),
2523  NULL
2524  },
2525  &VacuumCostPageHit,
2526  1, 0, 10000,
2527  NULL, NULL, NULL
2528  },
2529 
2530  {
2531  {"vacuum_cost_page_miss", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2532  gettext_noop("Vacuum cost for a page not found in the buffer cache."),
2533  NULL
2534  },
2535  &VacuumCostPageMiss,
2536  2, 0, 10000,
2537  NULL, NULL, NULL
2538  },
2539 
2540  {
2541  {"vacuum_cost_page_dirty", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2542  gettext_noop("Vacuum cost for a page dirtied by vacuum."),
2543  NULL
2544  },
2545  &VacuumCostPageDirty,
2546  20, 0, 10000,
2547  NULL, NULL, NULL
2548  },
2549 
2550  {
2551  {"vacuum_cost_limit", PGC_USERSET, RESOURCES_VACUUM_DELAY,
2552  gettext_noop("Vacuum cost amount available before napping."),
2553  NULL
2554  },
2555  &VacuumCostLimit,
2556  200, 1, 10000,
2557  NULL, NULL, NULL
2558  },
2559 
2560  {
2561  {"autovacuum_vacuum_cost_limit", PGC_SIGHUP, AUTOVACUUM,
2562  gettext_noop("Vacuum cost amount available before napping, for autovacuum."),
2563  NULL
2564  },
2565  &autovacuum_vac_cost_limit,
2566  -1, -1, 10000,
2567  NULL, NULL, NULL
2568  },
2569 
2570  {
2571  {"max_files_per_process", PGC_POSTMASTER, RESOURCES_KERNEL,
2572  gettext_noop("Sets the maximum number of simultaneously open files for each server process."),
2573  NULL
2574  },
2575  &max_files_per_process,
2576  1000, 64, INT_MAX,
2577  NULL, NULL, NULL
2578  },
2579 
2580  /*
2581  * See also CheckRequiredParameterValues() if this parameter changes
2582  */
2583  {
2584  {"max_prepared_transactions", PGC_POSTMASTER, RESOURCES_MEM,
2585  gettext_noop("Sets the maximum number of simultaneously prepared transactions."),
2586  NULL
2587  },
2588  &max_prepared_xacts,
2589  0, 0, MAX_BACKENDS,
2590  NULL, NULL, NULL
2591  },
2592 
2593 #ifdef LOCK_DEBUG
2594  {
2595  {"trace_lock_oidmin", PGC_SUSET, DEVELOPER_OPTIONS,
2596  gettext_noop("Sets the minimum OID of tables for tracking locks."),
2597  gettext_noop("Is used to avoid output on system tables."),
2598  GUC_NOT_IN_SAMPLE
2599  },
2600  &Trace_lock_oidmin,
2601  FirstNormalObjectId, 0, INT_MAX,
2602  NULL, NULL, NULL
2603  },
2604  {
2605  {"trace_lock_table", PGC_SUSET, DEVELOPER_OPTIONS,
2606  gettext_noop("Sets the OID of the table with unconditionally lock tracing."),
2607  NULL,
2608  GUC_NOT_IN_SAMPLE
2609  },
2610  &Trace_lock_table,
2611  0, 0, INT_MAX,
2612  NULL, NULL, NULL
2613  },
2614 #endif
2615 
2616  {
2617  {"statement_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2618  gettext_noop("Sets the maximum allowed duration of any statement."),
2619  gettext_noop("A value of 0 turns off the timeout."),
2620  GUC_UNIT_MS
2621  },
2622  &StatementTimeout,
2623  0, 0, INT_MAX,
2624  NULL, NULL, NULL
2625  },
2626 
2627  {
2628  {"lock_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2629  gettext_noop("Sets the maximum allowed duration of any wait for a lock."),
2630  gettext_noop("A value of 0 turns off the timeout."),
2631  GUC_UNIT_MS
2632  },
2633  &LockTimeout,
2634  0, 0, INT_MAX,
2635  NULL, NULL, NULL
2636  },
2637 
2638  {
2639  {"idle_in_transaction_session_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2640  gettext_noop("Sets the maximum allowed idle time between queries, when in a transaction."),
2641  gettext_noop("A value of 0 turns off the timeout."),
2642  GUC_UNIT_MS
2643  },
2644  &IdleInTransactionSessionTimeout,
2645  0, 0, INT_MAX,
2646  NULL, NULL, NULL
2647  },
2648 
2649  {
2650  {"transaction_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2651  gettext_noop("Sets the maximum allowed duration of any transaction within a session (not a prepared transaction)."),
2652  gettext_noop("A value of 0 turns off the timeout."),
2653  GUC_UNIT_MS
2654  },
2655  &TransactionTimeout,
2656  0, 0, INT_MAX,
2657  NULL, assign_transaction_timeout, NULL
2658  },
2659 
2660  {
2661  {"idle_session_timeout", PGC_USERSET, CLIENT_CONN_STATEMENT,
2662  gettext_noop("Sets the maximum allowed idle time between queries, when not in a transaction."),
2663  gettext_noop("A value of 0 turns off the timeout."),
2664  GUC_UNIT_MS
2665  },
2666  &IdleSessionTimeout,
2667  0, 0, INT_MAX,
2668  NULL, NULL, NULL
2669  },
2670 
2671  {
2672  {"vacuum_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2673  gettext_noop("Minimum age at which VACUUM should freeze a table row."),
2674  NULL
2675  },
2676  &vacuum_freeze_min_age,
2677  50000000, 0, 1000000000,
2678  NULL, NULL, NULL
2679  },
2680 
2681  {
2682  {"vacuum_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2683  gettext_noop("Age at which VACUUM should scan whole table to freeze tuples."),
2684  NULL
2685  },
2686  &vacuum_freeze_table_age,
2687  150000000, 0, 2000000000,
2688  NULL, NULL, NULL
2689  },
2690 
2691  {
2692  {"vacuum_multixact_freeze_min_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2693  gettext_noop("Minimum age at which VACUUM should freeze a MultiXactId in a table row."),
2694  NULL
2695  },
2696  &vacuum_multixact_freeze_min_age,
2697  5000000, 0, 1000000000,
2698  NULL, NULL, NULL
2699  },
2700 
2701  {
2702  {"vacuum_multixact_freeze_table_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2703  gettext_noop("Multixact age at which VACUUM should scan whole table to freeze tuples."),
2704  NULL
2705  },
2706  &vacuum_multixact_freeze_table_age,
2707  150000000, 0, 2000000000,
2708  NULL, NULL, NULL
2709  },
2710 
2711  {
2712  {"vacuum_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2713  gettext_noop("Age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
2714  NULL
2715  },
2716  &vacuum_failsafe_age,
2717  1600000000, 0, 2100000000,
2718  NULL, NULL, NULL
2719  },
2720  {
2721  {"vacuum_multixact_failsafe_age", PGC_USERSET, CLIENT_CONN_STATEMENT,
2722  gettext_noop("Multixact age at which VACUUM should trigger failsafe to avoid a wraparound outage."),
2723  NULL
2724  },
2725  &vacuum_multixact_failsafe_age,
2726  1600000000, 0, 2100000000,
2727  NULL, NULL, NULL
2728  },
2729 
2730  /*
2731  * See also CheckRequiredParameterValues() if this parameter changes
2732  */
2733  {
2734  {"max_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT,
2735  gettext_noop("Sets the maximum number of locks per transaction."),
2736  gettext_noop("The shared lock table is sized on the assumption that at most "
2737  "max_locks_per_transaction objects per server process or prepared "
2738  "transaction will need to be locked at any one time.")
2739  },
2740  &max_locks_per_xact,
2741  64, 10, INT_MAX,
2742  NULL, NULL, NULL
2743  },
2744 
2745  {
2746  {"max_pred_locks_per_transaction", PGC_POSTMASTER, LOCK_MANAGEMENT,
2747  gettext_noop("Sets the maximum number of predicate locks per transaction."),
2748  gettext_noop("The shared predicate lock table is sized on the assumption that "
2749  "at most max_pred_locks_per_transaction objects per server process "
2750  "or prepared transaction will need to be locked at any one time.")
2751  },
2752  &max_predicate_locks_per_xact,
2753  64, 10, INT_MAX,
2754  NULL, NULL, NULL
2755  },
2756 
2757  {
2758  {"max_pred_locks_per_relation", PGC_SIGHUP, LOCK_MANAGEMENT,
2759  gettext_noop("Sets the maximum number of predicate-locked pages and tuples per relation."),
2760  gettext_noop("If more than this total of pages and tuples in the same relation are locked "
2761  "by a connection, those locks are replaced by a relation-level lock.")
2762  },
2763  &max_predicate_locks_per_relation,
2764  -2, INT_MIN, INT_MAX,
2765  NULL, NULL, NULL
2766  },
2767 
2768  {
2769  {"max_pred_locks_per_page", PGC_SIGHUP, LOCK_MANAGEMENT,
2770  gettext_noop("Sets the maximum number of predicate-locked tuples per page."),
2771  gettext_noop("If more than this number of tuples on the same page are locked "
2772  "by a connection, those locks are replaced by a page-level lock.")
2773  },
2774  &max_predicate_locks_per_page,
2775  2, 0, INT_MAX,
2776  NULL, NULL, NULL
2777  },
2778 
2779  {
2780  {"authentication_timeout", PGC_SIGHUP, CONN_AUTH_AUTH,
2781  gettext_noop("Sets the maximum allowed time to complete client authentication."),
2782  NULL,
2783  GUC_UNIT_S
2784  },
2785  &AuthenticationTimeout,
2786  60, 1, 600,
2787  NULL, NULL, NULL
2788  },
2789 
2790  {
2791  /* Not for general use */
2792  {"pre_auth_delay", PGC_SIGHUP, DEVELOPER_OPTIONS,
2793  gettext_noop("Sets the amount of time to wait before "
2794  "authentication on connection startup."),
2795  gettext_noop("This allows attaching a debugger to the process."),
2796  GUC_NOT_IN_SAMPLE | GUC_UNIT_S
2797  },
2798  &PreAuthDelay,
2799  0, 0, 60,
2800  NULL, NULL, NULL
2801  },
2802 
2803  {
2804  {"max_notify_queue_pages", PGC_POSTMASTER, RESOURCES_DISK,
2805  gettext_noop("Sets the maximum number of allocated pages for NOTIFY / LISTEN queue."),
2806  NULL,
2807  },
2808  &max_notify_queue_pages,
2809  1048576, 64, INT_MAX,
2810  NULL, NULL, NULL
2811  },
2812 
2813  {
2814  {"wal_decode_buffer_size", PGC_POSTMASTER, WAL_RECOVERY,
2815  gettext_noop("Buffer size for reading ahead in the WAL during recovery."),
2816  gettext_noop("Maximum distance to read ahead in the WAL to prefetch referenced data blocks."),
2817  GUC_UNIT_BYTE
2818  },
2819  &wal_decode_buffer_size,
2820  512 * 1024, 64 * 1024, MaxAllocSize,
2821  NULL, NULL, NULL
2822  },
2823 
2824  {
2825  {"wal_keep_size", PGC_SIGHUP, REPLICATION_SENDING,
2826  gettext_noop("Sets the size of WAL files held for standby servers."),
2827  NULL,
2828  GUC_UNIT_MB
2829  },
2830  &wal_keep_size_mb,
2831  0, 0, MAX_KILOBYTES,
2832  NULL, NULL, NULL
2833  },
2834 
2835  {
2836  {"min_wal_size", PGC_SIGHUP, WAL_CHECKPOINTS,
2837  gettext_noop("Sets the minimum size to shrink the WAL to."),
2838  NULL,
2839  GUC_UNIT_MB
2840  },
2841  &min_wal_size_mb,
2842  DEFAULT_MIN_WAL_SEGS * (DEFAULT_XLOG_SEG_SIZE / (1024 * 1024)),
2843  2, MAX_KILOBYTES,
2844  NULL, NULL, NULL
2845  },
2846 
2847  {
2848  {"max_wal_size", PGC_SIGHUP, WAL_CHECKPOINTS,
2849  gettext_noop("Sets the WAL size that triggers a checkpoint."),
2850  NULL,
2851  GUC_UNIT_MB
2852  },
2853  &max_wal_size_mb,
2854  DEFAULT_MAX_WAL_SEGS * (DEFAULT_XLOG_SEG_SIZE / (1024 * 1024)),
2855  2, MAX_KILOBYTES,
2856  NULL, assign_max_wal_size, NULL
2857  },
2858 
2859  {
2860  {"checkpoint_timeout", PGC_SIGHUP, WAL_CHECKPOINTS,
2861  gettext_noop("Sets the maximum time between automatic WAL checkpoints."),
2862  NULL,
2863  GUC_UNIT_S
2864  },
2865  &CheckPointTimeout,
2866  300, 30, 86400,
2867  NULL, NULL, NULL
2868  },
2869 
2870  {
2871  {"checkpoint_warning", PGC_SIGHUP, WAL_CHECKPOINTS,
2872  gettext_noop("Sets the maximum time before warning if checkpoints "
2873  "triggered by WAL volume happen too frequently."),
2874  gettext_noop("Write a message to the server log if checkpoints "
2875  "caused by the filling of WAL segment files happen more "
2876  "frequently than this amount of time. "
2877  "Zero turns off the warning."),
2878  GUC_UNIT_S
2879  },
2880  &CheckPointWarning,
2881  30, 0, INT_MAX,
2882  NULL, NULL, NULL
2883  },
2884 
2885  {
2886  {"checkpoint_flush_after", PGC_SIGHUP, WAL_CHECKPOINTS,
2887  gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
2888  NULL,
2889  GUC_UNIT_BLOCKS
2890  },
2891  &checkpoint_flush_after,
2892  DEFAULT_CHECKPOINT_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
2893  NULL, NULL, NULL
2894  },
2895 
2896  {
2897  {"wal_buffers", PGC_POSTMASTER, WAL_SETTINGS,
2898  gettext_noop("Sets the number of disk-page buffers in shared memory for WAL."),
2899  gettext_noop("Specify -1 to have this value determined as a fraction of shared_buffers."),
2900  GUC_UNIT_XBLOCKS
2901  },
2902  &XLOGbuffers,
2903  -1, -1, (INT_MAX / XLOG_BLCKSZ),
2904  check_wal_buffers, NULL, NULL
2905  },
2906 
2907  {
2908  {"wal_writer_delay", PGC_SIGHUP, WAL_SETTINGS,
2909  gettext_noop("Time between WAL flushes performed in the WAL writer."),
2910  NULL,
2911  GUC_UNIT_MS
2912  },
2913  &WalWriterDelay,
2914  200, 1, 10000,
2915  NULL, NULL, NULL
2916  },
2917 
2918  {
2919  {"wal_writer_flush_after", PGC_SIGHUP, WAL_SETTINGS,
2920  gettext_noop("Amount of WAL written out by WAL writer that triggers a flush."),
2921  NULL,
2922  GUC_UNIT_XBLOCKS
2923  },
2924  &WalWriterFlushAfter,
2925  DEFAULT_WAL_WRITER_FLUSH_AFTER, 0, INT_MAX,
2926  NULL, NULL, NULL
2927  },
2928 
2929  {
2930  {"wal_skip_threshold", PGC_USERSET, WAL_SETTINGS,
2931  gettext_noop("Minimum size of new file to fsync instead of writing WAL."),
2932  NULL,
2933  GUC_UNIT_KB
2934  },
2935  &wal_skip_threshold,
2936  2048, 0, MAX_KILOBYTES,
2937  NULL, NULL, NULL
2938  },
2939 
2940  {
2941  {"max_wal_senders", PGC_POSTMASTER, REPLICATION_SENDING,
2942  gettext_noop("Sets the maximum number of simultaneously running WAL sender processes."),
2943  NULL
2944  },
2945  &max_wal_senders,
2946  10, 0, MAX_BACKENDS,
2947  check_max_wal_senders, NULL, NULL
2948  },
2949 
2950  {
2951  /* see max_wal_senders */
2952  {"max_replication_slots", PGC_POSTMASTER, REPLICATION_SENDING,
2953  gettext_noop("Sets the maximum number of simultaneously defined replication slots."),
2954  NULL
2955  },
2956  &max_replication_slots,
2957  10, 0, MAX_BACKENDS /* XXX? */ ,
2958  NULL, NULL, NULL
2959  },
2960 
2961  {
2962  {"max_slot_wal_keep_size", PGC_SIGHUP, REPLICATION_SENDING,
2963  gettext_noop("Sets the maximum WAL size that can be reserved by replication slots."),
2964  gettext_noop("Replication slots will be marked as failed, and segments released "
2965  "for deletion or recycling, if this much space is occupied by WAL "
2966  "on disk."),
2967  GUC_UNIT_MB
2968  },
2969  &max_slot_wal_keep_size_mb,
2970  -1, -1, MAX_KILOBYTES,
2971  check_max_slot_wal_keep_size, NULL, NULL
2972  },
2973 
2974  {
2975  {"wal_sender_timeout", PGC_USERSET, REPLICATION_SENDING,
2976  gettext_noop("Sets the maximum time to wait for WAL replication."),
2977  NULL,
2978  GUC_UNIT_MS
2979  },
2980  &wal_sender_timeout,
2981  60 * 1000, 0, INT_MAX,
2982  NULL, NULL, NULL
2983  },
2984 
2985  {
2986  {"commit_delay", PGC_SUSET, WAL_SETTINGS,
2987  gettext_noop("Sets the delay in microseconds between transaction commit and "
2988  "flushing WAL to disk."),
2989  NULL
2990  /* we have no microseconds designation, so can't supply units here */
2991  },
2992  &CommitDelay,
2993  0, 0, 100000,
2994  NULL, NULL, NULL
2995  },
2996 
2997  {
2998  {"commit_siblings", PGC_USERSET, WAL_SETTINGS,
2999  gettext_noop("Sets the minimum number of concurrent open transactions "
3000  "required before performing commit_delay."),
3001  NULL
3002  },
3003  &CommitSiblings,
3004  5, 0, 1000,
3005  NULL, NULL, NULL
3006  },
3007 
3008  {
3009  {"extra_float_digits", PGC_USERSET, CLIENT_CONN_LOCALE,
3010  gettext_noop("Sets the number of digits displayed for floating-point values."),
3011  gettext_noop("This affects real, double precision, and geometric data types. "
3012  "A zero or negative parameter value is added to the standard "
3013  "number of digits (FLT_DIG or DBL_DIG as appropriate). "
3014  "Any value greater than zero selects precise output mode.")
3015  },
3016  &extra_float_digits,
3017  1, -15, 3,
3018  NULL, NULL, NULL
3019  },
3020 
3021  {
3022  {"log_min_duration_sample", PGC_SUSET, LOGGING_WHEN,
3023  gettext_noop("Sets the minimum execution time above which "
3024  "a sample of statements will be logged."
3025  " Sampling is determined by log_statement_sample_rate."),
3026  gettext_noop("Zero logs a sample of all queries. -1 turns this feature off."),
3027  GUC_UNIT_MS
3028  },
3029  &log_min_duration_sample,
3030  -1, -1, INT_MAX,
3031  NULL, NULL, NULL
3032  },
3033 
3034  {
3035  {"log_min_duration_statement", PGC_SUSET, LOGGING_WHEN,
3036  gettext_noop("Sets the minimum execution time above which "
3037  "all statements will be logged."),
3038  gettext_noop("Zero prints all queries. -1 turns this feature off."),
3039  GUC_UNIT_MS
3040  },
3041  &log_min_duration_statement,
3042  -1, -1, INT_MAX,
3043  NULL, NULL, NULL
3044  },
3045 
3046  {
3047  {"log_autovacuum_min_duration", PGC_SIGHUP, LOGGING_WHAT,
3048  gettext_noop("Sets the minimum execution time above which "
3049  "autovacuum actions will be logged."),
3050  gettext_noop("Zero prints all actions. -1 turns autovacuum logging off."),
3051  GUC_UNIT_MS
3052  },
3053  &Log_autovacuum_min_duration,
3054  600000, -1, INT_MAX,
3055  NULL, NULL, NULL
3056  },
3057 
3058  {
3059  {"log_parameter_max_length", PGC_SUSET, LOGGING_WHAT,
3060  gettext_noop("Sets the maximum length in bytes of data logged for bind "
3061  "parameter values when logging statements."),
3062  gettext_noop("-1 to print values in full."),
3063  GUC_UNIT_BYTE
3064  },
3065  &log_parameter_max_length,
3066  -1, -1, INT_MAX / 2,
3067  NULL, NULL, NULL
3068  },
3069 
3070  {
3071  {"log_parameter_max_length_on_error", PGC_USERSET, LOGGING_WHAT,
3072  gettext_noop("Sets the maximum length in bytes of data logged for bind "
3073  "parameter values when logging statements, on error."),
3074  gettext_noop("-1 to print values in full."),
3075  GUC_UNIT_BYTE
3076  },
3077  &log_parameter_max_length_on_error,
3078  0, -1, INT_MAX / 2,
3079  NULL, NULL, NULL
3080  },
3081 
3082  {
3083  {"bgwriter_delay", PGC_SIGHUP, RESOURCES_BGWRITER,
3084  gettext_noop("Background writer sleep time between rounds."),
3085  NULL,
3086  GUC_UNIT_MS
3087  },
3088  &BgWriterDelay,
3089  200, 10, 10000,
3090  NULL, NULL, NULL
3091  },
3092 
3093  {
3094  {"bgwriter_lru_maxpages", PGC_SIGHUP, RESOURCES_BGWRITER,
3095  gettext_noop("Background writer maximum number of LRU pages to flush per round."),
3096  NULL
3097  },
3098  &bgwriter_lru_maxpages,
3099  100, 0, INT_MAX / 2, /* Same upper limit as shared_buffers */
3100  NULL, NULL, NULL
3101  },
3102 
3103  {
3104  {"bgwriter_flush_after", PGC_SIGHUP, RESOURCES_BGWRITER,
3105  gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
3106  NULL,
3107  GUC_UNIT_BLOCKS
3108  },
3109  &bgwriter_flush_after,
3110  DEFAULT_BGWRITER_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
3111  NULL, NULL, NULL
3112  },
3113 
3114  {
3115  {"effective_io_concurrency",
3116  PGC_USERSET,
3117  RESOURCES_ASYNCHRONOUS,
3118  gettext_noop("Number of simultaneous requests that can be handled efficiently by the disk subsystem."),
3119  NULL,
3120  GUC_EXPLAIN
3121  },
3122  &effective_io_concurrency,
3123  DEFAULT_EFFECTIVE_IO_CONCURRENCY,
3124  0, MAX_IO_CONCURRENCY,
3125  check_effective_io_concurrency, NULL, NULL
3126  },
3127 
3128  {
3129  {"maintenance_io_concurrency",
3130  PGC_USERSET,
3131  RESOURCES_ASYNCHRONOUS,
3132  gettext_noop("A variant of effective_io_concurrency that is used for maintenance work."),
3133  NULL,
3134  GUC_EXPLAIN
3135  },
3136  &maintenance_io_concurrency,
3137  DEFAULT_MAINTENANCE_IO_CONCURRENCY,
3138  0, MAX_IO_CONCURRENCY,
3139  check_maintenance_io_concurrency, assign_maintenance_io_concurrency,
3140  NULL
3141  },
3142 
3143  {
3144  {"io_combine_limit",
3145  PGC_USERSET,
3146  RESOURCES_ASYNCHRONOUS,
3147  gettext_noop("Limit on the size of data reads and writes."),
3148  NULL,
3149  GUC_UNIT_BLOCKS
3150  },
3151  &io_combine_limit,
3152  DEFAULT_IO_COMBINE_LIMIT,
3153  1, MAX_IO_COMBINE_LIMIT,
3154  NULL, NULL, NULL
3155  },
3156 
3157  {
3158  {"backend_flush_after", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3159  gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
3160  NULL,
3161  GUC_UNIT_BLOCKS
3162  },
3163  &backend_flush_after,
3164  DEFAULT_BACKEND_FLUSH_AFTER, 0, WRITEBACK_MAX_PENDING_FLUSHES,
3165  NULL, NULL, NULL
3166  },
3167 
3168  {
3169  {"max_worker_processes",
3170  PGC_POSTMASTER,
3171  RESOURCES_ASYNCHRONOUS,
3172  gettext_noop("Maximum number of concurrent worker processes."),
3173  NULL,
3174  },
3175  &max_worker_processes,
3176  8, 0, MAX_BACKENDS,
3177  check_max_worker_processes, NULL, NULL
3178  },
3179 
3180  {
3181  {"max_logical_replication_workers",
3182  PGC_POSTMASTER,
3183  REPLICATION_SUBSCRIBERS,
3184  gettext_noop("Maximum number of logical replication worker processes."),
3185  NULL,
3186  },
3187  &max_logical_replication_workers,
3188  4, 0, MAX_BACKENDS,
3189  NULL, NULL, NULL
3190  },
3191 
3192  {
3193  {"max_sync_workers_per_subscription",
3194  PGC_SIGHUP,
3195  REPLICATION_SUBSCRIBERS,
3196  gettext_noop("Maximum number of table synchronization workers per subscription."),
3197  NULL,
3198  },
3199  &max_sync_workers_per_subscription,
3200  2, 0, MAX_BACKENDS,
3201  NULL, NULL, NULL
3202  },
3203 
3204  {
3205  {"max_parallel_apply_workers_per_subscription",
3206  PGC_SIGHUP,
3207  REPLICATION_SUBSCRIBERS,
3208  gettext_noop("Maximum number of parallel apply workers per subscription."),
3209  NULL,
3210  },
3211  &max_parallel_apply_workers_per_subscription,
3212  2, 0, MAX_PARALLEL_WORKER_LIMIT,
3213  NULL, NULL, NULL
3214  },
3215 
3216  {
3217  {"log_rotation_age", PGC_SIGHUP, LOGGING_WHERE,
3218  gettext_noop("Sets the amount of time to wait before forcing "
3219  "log file rotation."),
3220  NULL,
3221  GUC_UNIT_MIN
3222  },
3223  &Log_RotationAge,
3224  HOURS_PER_DAY * MINS_PER_HOUR, 0, INT_MAX / SECS_PER_MINUTE,
3225  NULL, NULL, NULL
3226  },
3227 
3228  {
3229  {"log_rotation_size", PGC_SIGHUP, LOGGING_WHERE,
3230  gettext_noop("Sets the maximum size a log file can reach before "
3231  "being rotated."),
3232  NULL,
3233  GUC_UNIT_KB
3234  },
3235  &Log_RotationSize,
3236  10 * 1024, 0, INT_MAX / 1024,
3237  NULL, NULL, NULL
3238  },
3239 
3240  {
3241  {"max_function_args", PGC_INTERNAL, PRESET_OPTIONS,
3242  gettext_noop("Shows the maximum number of function arguments."),
3243  NULL,
3244  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3245  },
3246  &max_function_args,
3247  FUNC_MAX_ARGS, FUNC_MAX_ARGS, FUNC_MAX_ARGS,
3248  NULL, NULL, NULL
3249  },
3250 
3251  {
3252  {"max_index_keys", PGC_INTERNAL, PRESET_OPTIONS,
3253  gettext_noop("Shows the maximum number of index keys."),
3254  NULL,
3255  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3256  },
3257  &max_index_keys,
3258  INDEX_MAX_KEYS, INDEX_MAX_KEYS, INDEX_MAX_KEYS,
3259  NULL, NULL, NULL
3260  },
3261 
3262  {
3263  {"max_identifier_length", PGC_INTERNAL, PRESET_OPTIONS,
3264  gettext_noop("Shows the maximum identifier length."),
3265  NULL,
3266  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3267  },
3268  &max_identifier_length,
3269  NAMEDATALEN - 1, NAMEDATALEN - 1, NAMEDATALEN - 1,
3270  NULL, NULL, NULL
3271  },
3272 
3273  {
3274  {"block_size", PGC_INTERNAL, PRESET_OPTIONS,
3275  gettext_noop("Shows the size of a disk block."),
3276  NULL,
3277  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3278  },
3279  &block_size,
3280  BLCKSZ, BLCKSZ, BLCKSZ,
3281  NULL, NULL, NULL
3282  },
3283 
3284  {
3285  {"segment_size", PGC_INTERNAL, PRESET_OPTIONS,
3286  gettext_noop("Shows the number of pages per disk file."),
3287  NULL,
3288  GUC_UNIT_BLOCKS | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3289  },
3290  &segment_size,
3291  RELSEG_SIZE, RELSEG_SIZE, RELSEG_SIZE,
3292  NULL, NULL, NULL
3293  },
3294 
3295  {
3296  {"wal_block_size", PGC_INTERNAL, PRESET_OPTIONS,
3297  gettext_noop("Shows the block size in the write ahead log."),
3298  NULL,
3299  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3300  },
3301  &wal_block_size,
3302  XLOG_BLCKSZ, XLOG_BLCKSZ, XLOG_BLCKSZ,
3303  NULL, NULL, NULL
3304  },
3305 
3306  {
3307  {"wal_retrieve_retry_interval", PGC_SIGHUP, REPLICATION_STANDBY,
3308  gettext_noop("Sets the time to wait before retrying to retrieve WAL "
3309  "after a failed attempt."),
3310  NULL,
3311  GUC_UNIT_MS
3312  },
3313  &wal_retrieve_retry_interval,
3314  5000, 1, INT_MAX,
3315  NULL, NULL, NULL
3316  },
3317 
3318  {
3319  {"wal_segment_size", PGC_INTERNAL, PRESET_OPTIONS,
3320  gettext_noop("Shows the size of write ahead log segments."),
3321  NULL,
3322  GUC_UNIT_BYTE | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_RUNTIME_COMPUTED
3323  },
3324  &wal_segment_size,
3325  DEFAULT_XLOG_SEG_SIZE,
3326  WalSegMinSize,
3327  WalSegMaxSize,
3328  check_wal_segment_size, NULL, NULL
3329  },
3330 
3331  {
3332  {"wal_summary_keep_time", PGC_SIGHUP, WAL_SUMMARIZATION,
3333  gettext_noop("Time for which WAL summary files should be kept."),
3334  NULL,
3335  GUC_UNIT_MIN,
3336  },
3337  &wal_summary_keep_time,
3338  10 * HOURS_PER_DAY * MINS_PER_HOUR, /* 10 days */
3339  0,
3340  INT_MAX / SECS_PER_MINUTE,
3341  NULL, NULL, NULL
3342  },
3343 
3344  {
3345  {"autovacuum_naptime", PGC_SIGHUP, AUTOVACUUM,
3346  gettext_noop("Time to sleep between autovacuum runs."),
3347  NULL,
3348  GUC_UNIT_S
3349  },
3350  &autovacuum_naptime,
3351  60, 1, INT_MAX / 1000,
3352  NULL, NULL, NULL
3353  },
3354  {
3355  {"autovacuum_vacuum_threshold", PGC_SIGHUP, AUTOVACUUM,
3356  gettext_noop("Minimum number of tuple updates or deletes prior to vacuum."),
3357  NULL
3358  },
3359  &autovacuum_vac_thresh,
3360  50, 0, INT_MAX,
3361  NULL, NULL, NULL
3362  },
3363  {
3364  {"autovacuum_vacuum_insert_threshold", PGC_SIGHUP, AUTOVACUUM,
3365  gettext_noop("Minimum number of tuple inserts prior to vacuum, or -1 to disable insert vacuums."),
3366  NULL
3367  },
3368  &autovacuum_vac_ins_thresh,
3369  1000, -1, INT_MAX,
3370  NULL, NULL, NULL
3371  },
3372  {
3373  {"autovacuum_analyze_threshold", PGC_SIGHUP, AUTOVACUUM,
3374  gettext_noop("Minimum number of tuple inserts, updates, or deletes prior to analyze."),
3375  NULL
3376  },
3377  &autovacuum_anl_thresh,
3378  50, 0, INT_MAX,
3379  NULL, NULL, NULL
3380  },
3381  {
3382  /* see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
3383  {"autovacuum_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
3384  gettext_noop("Age at which to autovacuum a table to prevent transaction ID wraparound."),
3385  NULL
3386  },
3387  &autovacuum_freeze_max_age,
3388 
3389  /* see vacuum_failsafe_age if you change the upper-limit value. */
3390  200000000, 100000, 2000000000,
3391  NULL, NULL, NULL
3392  },
3393  {
3394  /* see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP */
3395  {"autovacuum_multixact_freeze_max_age", PGC_POSTMASTER, AUTOVACUUM,
3396  gettext_noop("Multixact age at which to autovacuum a table to prevent multixact wraparound."),
3397  NULL
3398  },
3399  &autovacuum_multixact_freeze_max_age,
3400  400000000, 10000, 2000000000,
3401  NULL, NULL, NULL
3402  },
3403  {
3404  /* see max_connections */
3405  {"autovacuum_max_workers", PGC_POSTMASTER, AUTOVACUUM,
3406  gettext_noop("Sets the maximum number of simultaneously running autovacuum worker processes."),
3407  NULL
3408  },
3409  &autovacuum_max_workers,
3410  3, 1, MAX_BACKENDS,
3411  check_autovacuum_max_workers, NULL, NULL
3412  },
3413 
3414  {
3415  {"max_parallel_maintenance_workers", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3416  gettext_noop("Sets the maximum number of parallel processes per maintenance operation."),
3417  NULL
3418  },
3419  &max_parallel_maintenance_workers,
3420  2, 0, 1024,
3421  NULL, NULL, NULL
3422  },
3423 
3424  {
3425  {"max_parallel_workers_per_gather", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3426  gettext_noop("Sets the maximum number of parallel processes per executor node."),
3427  NULL,
3428  GUC_EXPLAIN
3429  },
3430  &max_parallel_workers_per_gather,
3431  2, 0, MAX_PARALLEL_WORKER_LIMIT,
3432  NULL, NULL, NULL
3433  },
3434 
3435  {
3436  {"max_parallel_workers", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
3437  gettext_noop("Sets the maximum number of parallel workers that can be active at one time."),
3438  NULL,
3439  GUC_EXPLAIN
3440  },
3441  &max_parallel_workers,
3442  8, 0, MAX_PARALLEL_WORKER_LIMIT,
3443  NULL, NULL, NULL
3444  },
3445 
3446  {
3447  {"autovacuum_work_mem", PGC_SIGHUP, RESOURCES_MEM,
3448  gettext_noop("Sets the maximum memory to be used by each autovacuum worker process."),
3449  NULL,
3450  GUC_UNIT_KB
3451  },
3452  &autovacuum_work_mem,
3453  -1, -1, MAX_KILOBYTES,
3454  check_autovacuum_work_mem, NULL, NULL
3455  },
3456 
3457  {
3458  {"tcp_keepalives_idle", PGC_USERSET, CONN_AUTH_TCP,
3459  gettext_noop("Time between issuing TCP keepalives."),
3460  gettext_noop("A value of 0 uses the system default."),
3461  GUC_UNIT_S
3462  },
3463  &tcp_keepalives_idle,
3464  0, 0, INT_MAX,
3465  NULL, assign_tcp_keepalives_idle, show_tcp_keepalives_idle
3466  },
3467 
3468  {
3469  {"tcp_keepalives_interval", PGC_USERSET, CONN_AUTH_TCP,
3470  gettext_noop("Time between TCP keepalive retransmits."),
3471  gettext_noop("A value of 0 uses the system default."),
3472  GUC_UNIT_S
3473  },
3474  &tcp_keepalives_interval,
3475  0, 0, INT_MAX,
3476  NULL, assign_tcp_keepalives_interval, show_tcp_keepalives_interval
3477  },
3478 
3479  {
3480  {"ssl_renegotiation_limit", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
3481  gettext_noop("SSL renegotiation is no longer supported; this can only be 0."),
3482  NULL,
3483  GUC_NO_SHOW_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE,
3484  },
3485  &ssl_renegotiation_limit,
3486  0, 0, 0,
3487  NULL, NULL, NULL
3488  },
3489 
3490  {
3491  {"tcp_keepalives_count", PGC_USERSET, CONN_AUTH_TCP,
3492  gettext_noop("Maximum number of TCP keepalive retransmits."),
3493  gettext_noop("Number of consecutive keepalive retransmits that can be "
3494  "lost before a connection is considered dead. A value of 0 uses the "
3495  "system default."),
3496  },
3497  &tcp_keepalives_count,
3498  0, 0, INT_MAX,
3499  NULL, assign_tcp_keepalives_count, show_tcp_keepalives_count
3500  },
3501 
3502  {
3503  {"gin_fuzzy_search_limit", PGC_USERSET, CLIENT_CONN_OTHER,
3504  gettext_noop("Sets the maximum allowed result for exact search by GIN."),
3505  NULL,
3506  0
3507  },
3508  &GinFuzzySearchLimit,
3509  0, 0, INT_MAX,
3510  NULL, NULL, NULL
3511  },
3512 
3513  {
3514  {"effective_cache_size", PGC_USERSET, QUERY_TUNING_COST,
3515  gettext_noop("Sets the planner's assumption about the total size of the data caches."),
3516  gettext_noop("That is, the total size of the caches (kernel cache and shared buffers) used for PostgreSQL data files. "
3517  "This is measured in disk pages, which are normally 8 kB each."),
3518  GUC_UNIT_BLOCKS | GUC_EXPLAIN,
3519  },
3520  &effective_cache_size,
3521  DEFAULT_EFFECTIVE_CACHE_SIZE, 1, INT_MAX,
3522  NULL, NULL, NULL
3523  },
3524 
3525  {
3526  {"min_parallel_table_scan_size", PGC_USERSET, QUERY_TUNING_COST,
3527  gettext_noop("Sets the minimum amount of table data for a parallel scan."),
3528  gettext_noop("If the planner estimates that it will read a number of table pages too small to reach this limit, a parallel scan will not be considered."),
3529  GUC_UNIT_BLOCKS | GUC_EXPLAIN,
3530  },
3531  &min_parallel_table_scan_size,
3532  (8 * 1024 * 1024) / BLCKSZ, 0, INT_MAX / 3,
3533  NULL, NULL, NULL
3534  },
3535 
3536  {
3537  {"min_parallel_index_scan_size", PGC_USERSET, QUERY_TUNING_COST,
3538  gettext_noop("Sets the minimum amount of index data for a parallel scan."),
3539  gettext_noop("If the planner estimates that it will read a number of index pages too small to reach this limit, a parallel scan will not be considered."),
3540  GUC_UNIT_BLOCKS | GUC_EXPLAIN,
3541  },
3542  &min_parallel_index_scan_size,
3543  (512 * 1024) / BLCKSZ, 0, INT_MAX / 3,
3544  NULL, NULL, NULL
3545  },
3546 
3547  {
3548  /* Can't be set in postgresql.conf */
3549  {"server_version_num", PGC_INTERNAL, PRESET_OPTIONS,
3550  gettext_noop("Shows the server version as an integer."),
3551  NULL,
3552  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3553  },
3554  &server_version_num,
3555  PG_VERSION_NUM, PG_VERSION_NUM, PG_VERSION_NUM,
3556  NULL, NULL, NULL
3557  },
3558 
3559  {
3560  {"log_temp_files", PGC_SUSET, LOGGING_WHAT,
3561  gettext_noop("Log the use of temporary files larger than this number of kilobytes."),
3562  gettext_noop("Zero logs all files. The default is -1 (turning this feature off)."),
3563  GUC_UNIT_KB
3564  },
3565  &log_temp_files,
3566  -1, -1, INT_MAX,
3567  NULL, NULL, NULL
3568  },
3569 
3570  {
3571  {"track_activity_query_size", PGC_POSTMASTER, STATS_CUMULATIVE,
3572  gettext_noop("Sets the size reserved for pg_stat_activity.query, in bytes."),
3573  NULL,
3574  GUC_UNIT_BYTE
3575  },
3576  &pgstat_track_activity_query_size,
3577  1024, 100, 1048576,
3578  NULL, NULL, NULL
3579  },
3580 
3581  {
3582  {"gin_pending_list_limit", PGC_USERSET, CLIENT_CONN_STATEMENT,
3583  gettext_noop("Sets the maximum size of the pending list for GIN index."),
3584  NULL,
3585  GUC_UNIT_KB
3586  },
3587  &gin_pending_list_limit,
3588  4096, 64, MAX_KILOBYTES,
3589  NULL, NULL, NULL
3590  },
3591 
3592  {
3593  {"tcp_user_timeout", PGC_USERSET, CONN_AUTH_TCP,
3594  gettext_noop("TCP user timeout."),
3595  gettext_noop("A value of 0 uses the system default."),
3596  GUC_UNIT_MS
3597  },
3598  &tcp_user_timeout,
3599  0, 0, INT_MAX,
3600  NULL, assign_tcp_user_timeout, show_tcp_user_timeout
3601  },
3602 
3603  {
3604  {"huge_page_size", PGC_POSTMASTER, RESOURCES_MEM,
3605  gettext_noop("The size of huge page that should be requested."),
3606  NULL,
3607  GUC_UNIT_KB
3608  },
3609  &huge_page_size,
3610  0, 0, INT_MAX,
3611  check_huge_page_size, NULL, NULL
3612  },
3613 
3614  {
3615  {"debug_discard_caches", PGC_SUSET, DEVELOPER_OPTIONS,
3616  gettext_noop("Aggressively flush system caches for debugging purposes."),
3617  NULL,
3618  GUC_NOT_IN_SAMPLE
3619  },
3620  &debug_discard_caches,
3621 #ifdef DISCARD_CACHES_ENABLED
3622  /* Set default based on older compile-time-only cache clobber macros */
3623 #if defined(CLOBBER_CACHE_RECURSIVELY)
3624  3,
3625 #elif defined(CLOBBER_CACHE_ALWAYS)
3626  1,
3627 #else
3628  0,
3629 #endif
3630  0, 5,
3631 #else /* not DISCARD_CACHES_ENABLED */
3632  0, 0, 0,
3633 #endif /* not DISCARD_CACHES_ENABLED */
3634  NULL, NULL, NULL
3635  },
3636 
3637  {
3638  {"client_connection_check_interval", PGC_USERSET, CONN_AUTH_TCP,
3639  gettext_noop("Sets the time interval between checks for disconnection while running queries."),
3640  NULL,
3641  GUC_UNIT_MS
3642  },
3643  &client_connection_check_interval,
3644  0, 0, INT_MAX,
3645  check_client_connection_check_interval, NULL, NULL
3646  },
3647 
3648  {
3649  {"log_startup_progress_interval", PGC_SIGHUP, LOGGING_WHEN,
3650  gettext_noop("Time between progress updates for "
3651  "long-running startup operations."),
3652  gettext_noop("0 turns this feature off."),
3653  GUC_UNIT_MS,
3654  },
3655  &log_startup_progress_interval,
3656  10000, 0, INT_MAX,
3657  NULL, NULL, NULL
3658  },
3659 
3660  {
3661  {"scram_iterations", PGC_USERSET, CONN_AUTH_AUTH,
3662  gettext_noop("Sets the iteration count for SCRAM secret generation."),
3663  NULL,
3664  GUC_REPORT
3665  },
3666  &scram_sha_256_iterations,
3667  SCRAM_SHA_256_DEFAULT_ITERATIONS, 1, INT_MAX,
3668  NULL, NULL, NULL
3669  },
3670 
3671  /* End-of-list marker */
3672  {
3673  {NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
3674  }
3675 };
3676 
3677 
3678 struct config_real ConfigureNamesReal[] =
3679 {
3680  {
3681  {"seq_page_cost", PGC_USERSET, QUERY_TUNING_COST,
3682  gettext_noop("Sets the planner's estimate of the cost of a "
3683  "sequentially fetched disk page."),
3684  NULL,
3685  GUC_EXPLAIN
3686  },
3687  &seq_page_cost,
3688  DEFAULT_SEQ_PAGE_COST, 0, DBL_MAX,
3689  NULL, NULL, NULL
3690  },
3691  {
3692  {"random_page_cost", PGC_USERSET, QUERY_TUNING_COST,
3693  gettext_noop("Sets the planner's estimate of the cost of a "
3694  "nonsequentially fetched disk page."),
3695  NULL,
3696  GUC_EXPLAIN
3697  },
3698  &random_page_cost,
3699  DEFAULT_RANDOM_PAGE_COST, 0, DBL_MAX,
3700  NULL, NULL, NULL
3701  },
3702  {
3703  {"cpu_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
3704  gettext_noop("Sets the planner's estimate of the cost of "
3705  "processing each tuple (row)."),
3706  NULL,
3707  GUC_EXPLAIN
3708  },
3709  &cpu_tuple_cost,
3710  DEFAULT_CPU_TUPLE_COST, 0, DBL_MAX,
3711  NULL, NULL, NULL
3712  },
3713  {
3714  {"cpu_index_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
3715  gettext_noop("Sets the planner's estimate of the cost of "
3716  "processing each index entry during an index scan."),
3717  NULL,
3718  GUC_EXPLAIN
3719  },
3720  &cpu_index_tuple_cost,
3721  DEFAULT_CPU_INDEX_TUPLE_COST, 0, DBL_MAX,
3722  NULL, NULL, NULL
3723  },
3724  {
3725  {"cpu_operator_cost", PGC_USERSET, QUERY_TUNING_COST,
3726  gettext_noop("Sets the planner's estimate of the cost of "
3727  "processing each operator or function call."),
3728  NULL,
3729  GUC_EXPLAIN
3730  },
3731  &cpu_operator_cost,
3732  DEFAULT_CPU_OPERATOR_COST, 0, DBL_MAX,
3733  NULL, NULL, NULL
3734  },
3735  {
3736  {"parallel_tuple_cost", PGC_USERSET, QUERY_TUNING_COST,
3737  gettext_noop("Sets the planner's estimate of the cost of "
3738  "passing each tuple (row) from worker to leader backend."),
3739  NULL,
3740  GUC_EXPLAIN
3741  },
3742  &parallel_tuple_cost,
3743  DEFAULT_PARALLEL_TUPLE_COST, 0, DBL_MAX,
3744  NULL, NULL, NULL
3745  },
3746  {
3747  {"parallel_setup_cost", PGC_USERSET, QUERY_TUNING_COST,
3748  gettext_noop("Sets the planner's estimate of the cost of "
3749  "starting up worker processes for parallel query."),
3750  NULL,
3751  GUC_EXPLAIN
3752  },
3753  &parallel_setup_cost,
3754  DEFAULT_PARALLEL_SETUP_COST, 0, DBL_MAX,
3755  NULL, NULL, NULL
3756  },
3757 
3758  {
3759  {"jit_above_cost", PGC_USERSET, QUERY_TUNING_COST,
3760  gettext_noop("Perform JIT compilation if query is more expensive."),
3761  gettext_noop("-1 disables JIT compilation."),
3762  GUC_EXPLAIN
3763  },
3764  &jit_above_cost,
3765  100000, -1, DBL_MAX,
3766  NULL, NULL, NULL
3767  },
3768 
3769  {
3770  {"jit_optimize_above_cost", PGC_USERSET, QUERY_TUNING_COST,
3771  gettext_noop("Optimize JIT-compiled functions if query is more expensive."),
3772  gettext_noop("-1 disables optimization."),
3773  GUC_EXPLAIN
3774  },
3775  &jit_optimize_above_cost,
3776  500000, -1, DBL_MAX,
3777  NULL, NULL, NULL
3778  },
3779 
3780  {
3781  {"jit_inline_above_cost", PGC_USERSET, QUERY_TUNING_COST,
3782  gettext_noop("Perform JIT inlining if query is more expensive."),
3783  gettext_noop("-1 disables inlining."),
3784  GUC_EXPLAIN
3785  },
3786  &jit_inline_above_cost,
3787  500000, -1, DBL_MAX,
3788  NULL, NULL, NULL
3789  },
3790 
3791  {
3792  {"cursor_tuple_fraction", PGC_USERSET, QUERY_TUNING_OTHER,
3793  gettext_noop("Sets the planner's estimate of the fraction of "
3794  "a cursor's rows that will be retrieved."),
3795  NULL,
3796  GUC_EXPLAIN
3797  },
3798  &cursor_tuple_fraction,
3799  DEFAULT_CURSOR_TUPLE_FRACTION, 0.0, 1.0,
3800  NULL, NULL, NULL
3801  },
3802 
3803  {
3804  {"recursive_worktable_factor", PGC_USERSET, QUERY_TUNING_OTHER,
3805  gettext_noop("Sets the planner's estimate of the average size "
3806  "of a recursive query's working table."),
3807  NULL,
3808  GUC_EXPLAIN
3809  },
3810  &recursive_worktable_factor,
3811  DEFAULT_RECURSIVE_WORKTABLE_FACTOR, 0.001, 1000000.0,
3812  NULL, NULL, NULL
3813  },
3814 
3815  {
3816  {"geqo_selection_bias", PGC_USERSET, QUERY_TUNING_GEQO,
3817  gettext_noop("GEQO: selective pressure within the population."),
3818  NULL,
3819  GUC_EXPLAIN
3820  },
3821  &Geqo_selection_bias,
3822  DEFAULT_GEQO_SELECTION_BIAS,
3823  MIN_GEQO_SELECTION_BIAS, MAX_GEQO_SELECTION_BIAS,
3824  NULL, NULL, NULL
3825  },
3826  {
3827  {"geqo_seed", PGC_USERSET, QUERY_TUNING_GEQO,
3828  gettext_noop("GEQO: seed for random path selection."),
3829  NULL,
3830  GUC_EXPLAIN
3831  },
3832  &Geqo_seed,
3833  0.0, 0.0, 1.0,
3834  NULL, NULL, NULL
3835  },
3836 
3837  {
3838  {"hash_mem_multiplier", PGC_USERSET, RESOURCES_MEM,
3839  gettext_noop("Multiple of work_mem to use for hash tables."),
3840  NULL,
3841  GUC_EXPLAIN
3842  },
3843  &hash_mem_multiplier,
3844  2.0, 1.0, 1000.0,
3845  NULL, NULL, NULL
3846  },
3847 
3848  {
3849  {"bgwriter_lru_multiplier", PGC_SIGHUP, RESOURCES_BGWRITER,
3850  gettext_noop("Multiple of the average buffer usage to free per round."),
3851  NULL
3852  },
3853  &bgwriter_lru_multiplier,
3854  2.0, 0.0, 10.0,
3855  NULL, NULL, NULL
3856  },
3857 
3858  {
3859  {"seed", PGC_USERSET, UNGROUPED,
3860  gettext_noop("Sets the seed for random-number generation."),
3861  NULL,
3862  GUC_NO_SHOW_ALL | GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
3863  },
3864  &phony_random_seed,
3865  0.0, -1.0, 1.0,
3866  check_random_seed, assign_random_seed, show_random_seed
3867  },
3868 
3869  {
3870  {"vacuum_cost_delay", PGC_USERSET, RESOURCES_VACUUM_DELAY,
3871  gettext_noop("Vacuum cost delay in milliseconds."),
3872  NULL,
3873  GUC_UNIT_MS
3874  },
3875  &VacuumCostDelay,
3876  0, 0, 100,
3877  NULL, NULL, NULL
3878  },
3879 
3880  {
3881  {"autovacuum_vacuum_cost_delay", PGC_SIGHUP, AUTOVACUUM,
3882  gettext_noop("Vacuum cost delay in milliseconds, for autovacuum."),
3883  NULL,
3884  GUC_UNIT_MS
3885  },
3886  &autovacuum_vac_cost_delay,
3887  2, -1, 100,
3888  NULL, NULL, NULL
3889  },
3890 
3891  {
3892  {"autovacuum_vacuum_scale_factor", PGC_SIGHUP, AUTOVACUUM,
3893  gettext_noop("Number of tuple updates or deletes prior to vacuum as a fraction of reltuples."),
3894  NULL
3895  },
3896  &autovacuum_vac_scale,
3897  0.2, 0.0, 100.0,
3898  NULL, NULL, NULL
3899  },
3900 
3901  {
3902  {"autovacuum_vacuum_insert_scale_factor", PGC_SIGHUP, AUTOVACUUM,
3903  gettext_noop("Number of tuple inserts prior to vacuum as a fraction of reltuples."),
3904  NULL
3905  },
3906  &autovacuum_vac_ins_scale,
3907  0.2, 0.0, 100.0,
3908  NULL, NULL, NULL
3909  },
3910 
3911  {
3912  {"autovacuum_analyze_scale_factor", PGC_SIGHUP, AUTOVACUUM,
3913  gettext_noop("Number of tuple inserts, updates, or deletes prior to analyze as a fraction of reltuples."),
3914  NULL
3915  },
3916  &autovacuum_anl_scale,
3917  0.1, 0.0, 100.0,
3918  NULL, NULL, NULL
3919  },
3920 
3921  {
3922  {"checkpoint_completion_target", PGC_SIGHUP, WAL_CHECKPOINTS,
3923  gettext_noop("Time spent flushing dirty buffers during checkpoint, as fraction of checkpoint interval."),
3924  NULL
3925  },
3926  &CheckPointCompletionTarget,
3927  0.9, 0.0, 1.0,
3928  NULL, assign_checkpoint_completion_target, NULL
3929  },
3930 
3931  {
3932  {"log_statement_sample_rate", PGC_SUSET, LOGGING_WHEN,
3933  gettext_noop("Fraction of statements exceeding log_min_duration_sample to be logged."),
3934  gettext_noop("Use a value between 0.0 (never log) and 1.0 (always log).")
3935  },
3936  &log_statement_sample_rate,
3937  1.0, 0.0, 1.0,
3938  NULL, NULL, NULL
3939  },
3940 
3941  {
3942  {"log_transaction_sample_rate", PGC_SUSET, LOGGING_WHEN,
3943  gettext_noop("Sets the fraction of transactions from which to log all statements."),
3944  gettext_noop("Use a value between 0.0 (never log) and 1.0 (log all "
3945  "statements for all transactions).")
3946  },
3947  &log_xact_sample_rate,
3948  0.0, 0.0, 1.0,
3949  NULL, NULL, NULL
3950  },
3951 
3952  /* End-of-list marker */
3953  {
3954  {NULL, 0, 0, NULL, NULL}, NULL, 0.0, 0.0, 0.0, NULL, NULL, NULL
3955  }
3956 };
3957 
3958 
3959 struct config_string ConfigureNamesString[] =
3960 {
3961  {
3962  {"archive_command", PGC_SIGHUP, WAL_ARCHIVING,
3963  gettext_noop("Sets the shell command that will be called to archive a WAL file."),
3964  gettext_noop("This is used only if archive_library is not set.")
3965  },
3966  &XLogArchiveCommand,
3967  "",
3968  NULL, NULL, show_archive_command
3969  },
3970 
3971  {
3972  {"archive_library", PGC_SIGHUP, WAL_ARCHIVING,
3973  gettext_noop("Sets the library that will be called to archive a WAL file."),
3974  gettext_noop("An empty string indicates that archive_command should be used.")
3975  },
3976  &XLogArchiveLibrary,
3977  "",
3978  NULL, NULL, NULL
3979  },
3980 
3981  {
3982  {"restore_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
3983  gettext_noop("Sets the shell command that will be called to retrieve an archived WAL file."),
3984  NULL
3985  },
3986  &recoveryRestoreCommand,
3987  "",
3988  NULL, NULL, NULL
3989  },
3990 
3991  {
3992  {"archive_cleanup_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
3993  gettext_noop("Sets the shell command that will be executed at every restart point."),
3994  NULL
3995  },
3996  &archiveCleanupCommand,
3997  "",
3998  NULL, NULL, NULL
3999  },
4000 
4001  {
4002  {"recovery_end_command", PGC_SIGHUP, WAL_ARCHIVE_RECOVERY,
4003  gettext_noop("Sets the shell command that will be executed once at the end of recovery."),
4004  NULL
4005  },
4006  &recoveryEndCommand,
4007  "",
4008  NULL, NULL, NULL
4009  },
4010 
4011  {
4012  {"recovery_target_timeline", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4013  gettext_noop("Specifies the timeline to recover into."),
4014  NULL
4015  },
4016  &recovery_target_timeline_string,
4017  "latest",
4018  check_recovery_target_timeline, assign_recovery_target_timeline, NULL
4019  },
4020 
4021  {
4022  {"recovery_target", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4023  gettext_noop("Set to \"immediate\" to end recovery as soon as a consistent state is reached."),
4024  NULL
4025  },
4026  &recovery_target_string,
4027  "",
4028  check_recovery_target, assign_recovery_target, NULL
4029  },
4030  {
4031  {"recovery_target_xid", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4032  gettext_noop("Sets the transaction ID up to which recovery will proceed."),
4033  NULL
4034  },
4035  &recovery_target_xid_string,
4036  "",
4037  check_recovery_target_xid, assign_recovery_target_xid, NULL
4038  },
4039  {
4040  {"recovery_target_time", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4041  gettext_noop("Sets the time stamp up to which recovery will proceed."),
4042  NULL
4043  },
4044  &recovery_target_time_string,
4045  "",
4046  check_recovery_target_time, assign_recovery_target_time, NULL
4047  },
4048  {
4049  {"recovery_target_name", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4050  gettext_noop("Sets the named restore point up to which recovery will proceed."),
4051  NULL
4052  },
4053  &recovery_target_name_string,
4054  "",
4055  check_recovery_target_name, assign_recovery_target_name, NULL
4056  },
4057  {
4058  {"recovery_target_lsn", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4059  gettext_noop("Sets the LSN of the write-ahead log location up to which recovery will proceed."),
4060  NULL
4061  },
4062  &recovery_target_lsn_string,
4063  "",
4064  check_recovery_target_lsn, assign_recovery_target_lsn, NULL
4065  },
4066 
4067  {
4068  {"primary_conninfo", PGC_SIGHUP, REPLICATION_STANDBY,
4069  gettext_noop("Sets the connection string to be used to connect to the sending server."),
4070  NULL,
4071  GUC_SUPERUSER_ONLY
4072  },
4073  &PrimaryConnInfo,
4074  "",
4075  NULL, NULL, NULL
4076  },
4077 
4078  {
4079  {"primary_slot_name", PGC_SIGHUP, REPLICATION_STANDBY,
4080  gettext_noop("Sets the name of the replication slot to use on the sending server."),
4081  NULL
4082  },
4083  &PrimarySlotName,
4084  "",
4085  check_primary_slot_name, NULL, NULL
4086  },
4087 
4088  {
4089  {"client_encoding", PGC_USERSET, CLIENT_CONN_LOCALE,
4090  gettext_noop("Sets the client's character set encoding."),
4091  NULL,
4092  GUC_IS_NAME | GUC_REPORT
4093  },
4094  &client_encoding_string,
4095  "SQL_ASCII",
4096  check_client_encoding, assign_client_encoding, NULL
4097  },
4098 
4099  {
4100  {"log_line_prefix", PGC_SIGHUP, LOGGING_WHAT,
4101  gettext_noop("Controls information prefixed to each log line."),
4102  gettext_noop("If blank, no prefix is used.")
4103  },
4104  &Log_line_prefix,
4105  "%m [%p] ",
4106  NULL, NULL, NULL
4107  },
4108 
4109  {
4110  {"log_timezone", PGC_SIGHUP, LOGGING_WHAT,
4111  gettext_noop("Sets the time zone to use in log messages."),
4112  NULL
4113  },
4114  &log_timezone_string,
4115  "GMT",
4116  check_log_timezone, assign_log_timezone, show_log_timezone
4117  },
4118 
4119  {
4120  {"DateStyle", PGC_USERSET, CLIENT_CONN_LOCALE,
4121  gettext_noop("Sets the display format for date and time values."),
4122  gettext_noop("Also controls interpretation of ambiguous "
4123  "date inputs."),
4124  GUC_LIST_INPUT | GUC_REPORT
4125  },
4126  &datestyle_string,
4127  "ISO, MDY",
4128  check_datestyle, assign_datestyle, NULL
4129  },
4130 
4131  {
4132  {"default_table_access_method", PGC_USERSET, CLIENT_CONN_STATEMENT,
4133  gettext_noop("Sets the default table access method for new tables."),
4134  NULL,
4135  GUC_IS_NAME
4136  },
4137  &default_table_access_method,
4138  DEFAULT_TABLE_ACCESS_METHOD,
4139  check_default_table_access_method, NULL, NULL
4140  },
4141 
4142  {
4143  {"default_tablespace", PGC_USERSET, CLIENT_CONN_STATEMENT,
4144  gettext_noop("Sets the default tablespace to create tables and indexes in."),
4145  gettext_noop("An empty string selects the database's default tablespace."),
4146  GUC_IS_NAME
4147  },
4148  &default_tablespace,
4149  "",
4150  check_default_tablespace, NULL, NULL
4151  },
4152 
4153  {
4154  {"temp_tablespaces", PGC_USERSET, CLIENT_CONN_STATEMENT,
4155  gettext_noop("Sets the tablespace(s) to use for temporary tables and sort files."),
4156  NULL,
4157  GUC_LIST_INPUT | GUC_LIST_QUOTE
4158  },
4159  &temp_tablespaces,
4160  "",
4161  check_temp_tablespaces, assign_temp_tablespaces, NULL
4162  },
4163 
4164  {
4165  {"createrole_self_grant", PGC_USERSET, CLIENT_CONN_STATEMENT,
4166  gettext_noop("Sets whether a CREATEROLE user automatically grants "
4167  "the role to themselves, and with which options."),
4168  NULL,
4169  GUC_LIST_INPUT
4170  },
4171  &createrole_self_grant,
4172  "",
4173  check_createrole_self_grant, assign_createrole_self_grant, NULL
4174  },
4175 
4176  {
4177  {"dynamic_library_path", PGC_SUSET, CLIENT_CONN_OTHER,
4178  gettext_noop("Sets the path for dynamically loadable modules."),
4179  gettext_noop("If a dynamically loadable module needs to be opened and "
4180  "the specified name does not have a directory component (i.e., the "
4181  "name does not contain a slash), the system will search this path for "
4182  "the specified file."),
4183  GUC_SUPERUSER_ONLY
4184  },
4185  &Dynamic_library_path,
4186  "$libdir",
4187  NULL, NULL, NULL
4188  },
4189 
4190  {
4191  {"krb_server_keyfile", PGC_SIGHUP, CONN_AUTH_AUTH,
4192  gettext_noop("Sets the location of the Kerberos server key file."),
4193  NULL,
4194  GUC_SUPERUSER_ONLY
4195  },
4196  &pg_krb_server_keyfile,
4197  PG_KRB_SRVTAB,
4198  NULL, NULL, NULL
4199  },
4200 
4201  {
4202  {"bonjour_name", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4203  gettext_noop("Sets the Bonjour service name."),
4204  NULL
4205  },
4206  &bonjour_name,
4207  "",
4208  NULL, NULL, NULL
4209  },
4210 
4211  {
4212  {"lc_messages", PGC_SUSET, CLIENT_CONN_LOCALE,
4213  gettext_noop("Sets the language in which messages are displayed."),
4214  NULL
4215  },
4216  &locale_messages,
4217  "",
4218  check_locale_messages, assign_locale_messages, NULL
4219  },
4220 
4221  {
4222  {"lc_monetary", PGC_USERSET, CLIENT_CONN_LOCALE,
4223  gettext_noop("Sets the locale for formatting monetary amounts."),
4224  NULL
4225  },
4226  &locale_monetary,
4227  "C",
4228  check_locale_monetary, assign_locale_monetary, NULL
4229  },
4230 
4231  {
4232  {"lc_numeric", PGC_USERSET, CLIENT_CONN_LOCALE,
4233  gettext_noop("Sets the locale for formatting numbers."),
4234  NULL
4235  },
4236  &locale_numeric,
4237  "C",
4238  check_locale_numeric, assign_locale_numeric, NULL
4239  },
4240 
4241  {
4242  {"lc_time", PGC_USERSET, CLIENT_CONN_LOCALE,
4243  gettext_noop("Sets the locale for formatting date and time values."),
4244  NULL
4245  },
4246  &locale_time,
4247  "C",
4248  check_locale_time, assign_locale_time, NULL
4249  },
4250 
4251  {
4252  {"session_preload_libraries", PGC_SUSET, CLIENT_CONN_PRELOAD,
4253  gettext_noop("Lists shared libraries to preload into each backend."),
4254  NULL,
4255  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
4256  },
4257  &session_preload_libraries_string,
4258  "",
4259  NULL, NULL, NULL
4260  },
4261 
4262  {
4263  {"shared_preload_libraries", PGC_POSTMASTER, CLIENT_CONN_PRELOAD,
4264  gettext_noop("Lists shared libraries to preload into server."),
4265  NULL,
4266  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
4267  },
4268  &shared_preload_libraries_string,
4269  "",
4270  NULL, NULL, NULL
4271  },
4272 
4273  {
4274  {"local_preload_libraries", PGC_USERSET, CLIENT_CONN_PRELOAD,
4275  gettext_noop("Lists unprivileged shared libraries to preload into each backend."),
4276  NULL,
4277  GUC_LIST_INPUT | GUC_LIST_QUOTE
4278  },
4279  &local_preload_libraries_string,
4280  "",
4281  NULL, NULL, NULL
4282  },
4283 
4284  {
4285  {"search_path", PGC_USERSET, CLIENT_CONN_STATEMENT,
4286  gettext_noop("Sets the schema search order for names that are not schema-qualified."),
4287  NULL,
4288  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_EXPLAIN
4289  },
4290  &namespace_search_path,
4291  "\"$user\", public",
4292  check_search_path, assign_search_path, NULL
4293  },
4294 
4295  {
4296  /* Can't be set in postgresql.conf */
4297  {"server_encoding", PGC_INTERNAL, PRESET_OPTIONS,
4298  gettext_noop("Shows the server (database) character set encoding."),
4299  NULL,
4300  GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4301  },
4302  &server_encoding_string,
4303  "SQL_ASCII",
4304  NULL, NULL, NULL
4305  },
4306 
4307  {
4308  /* Can't be set in postgresql.conf */
4309  {"server_version", PGC_INTERNAL, PRESET_OPTIONS,
4310  gettext_noop("Shows the server version."),
4311  NULL,
4312  GUC_REPORT | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4313  },
4314  &server_version_string,
4315  PG_VERSION,
4316  NULL, NULL, NULL
4317  },
4318 
4319  {
4320  /* Not for general use --- used by SET ROLE */
4321  {"role", PGC_USERSET, UNGROUPED,
4322  gettext_noop("Sets the current role."),
4323  NULL,
4324  GUC_IS_NAME | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_NOT_WHILE_SEC_REST
4325  },
4326  &role_string,
4327  "none",
4328  check_role, assign_role, show_role
4329  },
4330 
4331  {
4332  /* Not for general use --- used by SET SESSION AUTHORIZATION */
4333  {"session_authorization", PGC_USERSET, UNGROUPED,
4334  gettext_noop("Sets the session user name."),
4335  NULL,
4336  GUC_IS_NAME | GUC_REPORT | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_NOT_WHILE_SEC_REST
4337  },
4338  &session_authorization_string,
4339  NULL,
4340  check_session_authorization, assign_session_authorization, NULL
4341  },
4342 
4343  {
4344  {"log_destination", PGC_SIGHUP, LOGGING_WHERE,
4345  gettext_noop("Sets the destination for server log output."),
4346  gettext_noop("Valid values are combinations of \"stderr\", "
4347  "\"syslog\", \"csvlog\", \"jsonlog\", and \"eventlog\", "
4348  "depending on the platform."),
4349  GUC_LIST_INPUT
4350  },
4351  &Log_destination_string,
4352  "stderr",
4353  check_log_destination, assign_log_destination, NULL
4354  },
4355  {
4356  {"log_directory", PGC_SIGHUP, LOGGING_WHERE,
4357  gettext_noop("Sets the destination directory for log files."),
4358  gettext_noop("Can be specified as relative to the data directory "
4359  "or as absolute path."),
4360  GUC_SUPERUSER_ONLY
4361  },
4362  &Log_directory,
4363  "log",
4364  check_canonical_path, NULL, NULL
4365  },
4366  {
4367  {"log_filename", PGC_SIGHUP, LOGGING_WHERE,
4368  gettext_noop("Sets the file name pattern for log files."),
4369  NULL,
4370  GUC_SUPERUSER_ONLY
4371  },
4372  &Log_filename,
4373  "postgresql-%Y-%m-%d_%H%M%S.log",
4374  NULL, NULL, NULL
4375  },
4376 
4377  {
4378  {"syslog_ident", PGC_SIGHUP, LOGGING_WHERE,
4379  gettext_noop("Sets the program name used to identify PostgreSQL "
4380  "messages in syslog."),
4381  NULL
4382  },
4383  &syslog_ident_str,
4384  "postgres",
4385  NULL, assign_syslog_ident, NULL
4386  },
4387 
4388  {
4389  {"event_source", PGC_POSTMASTER, LOGGING_WHERE,
4390  gettext_noop("Sets the application name used to identify "
4391  "PostgreSQL messages in the event log."),
4392  NULL
4393  },
4394  &event_source,
4395  DEFAULT_EVENT_SOURCE,
4396  NULL, NULL, NULL
4397  },
4398 
4399  {
4400  {"TimeZone", PGC_USERSET, CLIENT_CONN_LOCALE,
4401  gettext_noop("Sets the time zone for displaying and interpreting time stamps."),
4402  NULL,
4403  GUC_REPORT
4404  },
4405  &timezone_string,
4406  "GMT",
4407  check_timezone, assign_timezone, show_timezone
4408  },
4409  {
4410  {"timezone_abbreviations", PGC_USERSET, CLIENT_CONN_LOCALE,
4411  gettext_noop("Selects a file of time zone abbreviations."),
4412  NULL
4413  },
4414  &timezone_abbreviations_string,
4415  NULL,
4416  check_timezone_abbreviations, assign_timezone_abbreviations, NULL
4417  },
4418 
4419  {
4420  {"unix_socket_group", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4421  gettext_noop("Sets the owning group of the Unix-domain socket."),
4422  gettext_noop("The owning user of the socket is always the user "
4423  "that starts the server.")
4424  },
4425  &Unix_socket_group,
4426  "",
4427  NULL, NULL, NULL
4428  },
4429 
4430  {
4431  {"unix_socket_directories", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4432  gettext_noop("Sets the directories where Unix-domain sockets will be created."),
4433  NULL,
4434  GUC_LIST_INPUT | GUC_LIST_QUOTE | GUC_SUPERUSER_ONLY
4435  },
4436  &Unix_socket_directories,
4437  DEFAULT_PGSOCKET_DIR,
4438  NULL, NULL, NULL
4439  },
4440 
4441  {
4442  {"listen_addresses", PGC_POSTMASTER, CONN_AUTH_SETTINGS,
4443  gettext_noop("Sets the host name or IP address(es) to listen to."),
4444  NULL,
4445  GUC_LIST_INPUT
4446  },
4447  &ListenAddresses,
4448  "localhost",
4449  NULL, NULL, NULL
4450  },
4451 
4452  {
4453  /*
4454  * Can't be set by ALTER SYSTEM as it can lead to recursive definition
4455  * of data_directory.
4456  */
4457  {"data_directory", PGC_POSTMASTER, FILE_LOCATIONS,
4458  gettext_noop("Sets the server's data directory."),
4459  NULL,
4460  GUC_SUPERUSER_ONLY | GUC_DISALLOW_IN_AUTO_FILE
4461  },
4462  &data_directory,
4463  NULL,
4464  NULL, NULL, NULL
4465  },
4466 
4467  {
4468  {"config_file", PGC_POSTMASTER, FILE_LOCATIONS,
4469  gettext_noop("Sets the server's main configuration file."),
4470  NULL,
4471  GUC_DISALLOW_IN_FILE | GUC_SUPERUSER_ONLY
4472  },
4473  &ConfigFileName,
4474  NULL,
4475  NULL, NULL, NULL
4476  },
4477 
4478  {
4479  {"hba_file", PGC_POSTMASTER, FILE_LOCATIONS,
4480  gettext_noop("Sets the server's \"hba\" configuration file."),
4481  NULL,
4482  GUC_SUPERUSER_ONLY
4483  },
4484  &HbaFileName,
4485  NULL,
4486  NULL, NULL, NULL
4487  },
4488 
4489  {
4490  {"ident_file", PGC_POSTMASTER, FILE_LOCATIONS,
4491  gettext_noop("Sets the server's \"ident\" configuration file."),
4492  NULL,
4493  GUC_SUPERUSER_ONLY
4494  },
4495  &IdentFileName,
4496  NULL,
4497  NULL, NULL, NULL
4498  },
4499 
4500  {
4501  {"external_pid_file", PGC_POSTMASTER, FILE_LOCATIONS,
4502  gettext_noop("Writes the postmaster PID to the specified file."),
4503  NULL,
4504  GUC_SUPERUSER_ONLY
4505  },
4506  &external_pid_file,
4507  NULL,
4508  check_canonical_path, NULL, NULL
4509  },
4510 
4511  {
4512  {"ssl_library", PGC_INTERNAL, PRESET_OPTIONS,
4513  gettext_noop("Shows the name of the SSL library."),
4514  NULL,
4515  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4516  },
4517  &ssl_library,
4518 #ifdef USE_SSL
4519  "OpenSSL",
4520 #else
4521  "",
4522 #endif
4523  NULL, NULL, NULL
4524  },
4525 
4526  {
4527  {"ssl_cert_file", PGC_SIGHUP, CONN_AUTH_SSL,
4528  gettext_noop("Location of the SSL server certificate file."),
4529  NULL
4530  },
4531  &ssl_cert_file,
4532  "server.crt",
4533  NULL, NULL, NULL
4534  },
4535 
4536  {
4537  {"ssl_key_file", PGC_SIGHUP, CONN_AUTH_SSL,
4538  gettext_noop("Location of the SSL server private key file."),
4539  NULL
4540  },
4541  &ssl_key_file,
4542  "server.key",
4543  NULL, NULL, NULL
4544  },
4545 
4546  {
4547  {"ssl_ca_file", PGC_SIGHUP, CONN_AUTH_SSL,
4548  gettext_noop("Location of the SSL certificate authority file."),
4549  NULL
4550  },
4551  &ssl_ca_file,
4552  "",
4553  NULL, NULL, NULL
4554  },
4555 
4556  {
4557  {"ssl_crl_file", PGC_SIGHUP, CONN_AUTH_SSL,
4558  gettext_noop("Location of the SSL certificate revocation list file."),
4559  NULL
4560  },
4561  &ssl_crl_file,
4562  "",
4563  NULL, NULL, NULL
4564  },
4565 
4566  {
4567  {"ssl_crl_dir", PGC_SIGHUP, CONN_AUTH_SSL,
4568  gettext_noop("Location of the SSL certificate revocation list directory."),
4569  NULL
4570  },
4571  &ssl_crl_dir,
4572  "",
4573  NULL, NULL, NULL
4574  },
4575 
4576  {
4577  {"synchronous_standby_names", PGC_SIGHUP, REPLICATION_PRIMARY,
4578  gettext_noop("Number of synchronous standbys and list of names of potential synchronous ones."),
4579  NULL,
4580  GUC_LIST_INPUT
4581  },
4582  &SyncRepStandbyNames,
4583  "",
4584  check_synchronous_standby_names, assign_synchronous_standby_names, NULL
4585  },
4586 
4587  {
4588  {"default_text_search_config", PGC_USERSET, CLIENT_CONN_LOCALE,
4589  gettext_noop("Sets default text search configuration."),
4590  NULL
4591  },
4592  &TSCurrentConfig,
4593  "pg_catalog.simple",
4594  check_default_text_search_config, assign_default_text_search_config, NULL
4595  },
4596 
4597  {
4598  {"ssl_ciphers", PGC_SIGHUP, CONN_AUTH_SSL,
4599  gettext_noop("Sets the list of allowed SSL ciphers."),
4600  NULL,
4601  GUC_SUPERUSER_ONLY
4602  },
4603  &SSLCipherSuites,
4604 #ifdef USE_OPENSSL
4605  "HIGH:MEDIUM:+3DES:!aNULL",
4606 #else
4607  "none",
4608 #endif
4609  NULL, NULL, NULL
4610  },
4611 
4612  {
4613  {"ssl_ecdh_curve", PGC_SIGHUP, CONN_AUTH_SSL,
4614  gettext_noop("Sets the curve to use for ECDH."),
4615  NULL,
4616  GUC_SUPERUSER_ONLY
4617  },
4618  &SSLECDHCurve,
4619 #ifdef USE_SSL
4620  "prime256v1",
4621 #else
4622  "none",
4623 #endif
4624  NULL, NULL, NULL
4625  },
4626 
4627  {
4628  {"ssl_dh_params_file", PGC_SIGHUP, CONN_AUTH_SSL,
4629  gettext_noop("Location of the SSL DH parameters file."),
4630  NULL,
4631  GUC_SUPERUSER_ONLY
4632  },
4633  &ssl_dh_params_file,
4634  "",
4635  NULL, NULL, NULL
4636  },
4637 
4638  {
4639  {"ssl_passphrase_command", PGC_SIGHUP, CONN_AUTH_SSL,
4640  gettext_noop("Command to obtain passphrases for SSL."),
4641  NULL,
4642  GUC_SUPERUSER_ONLY
4643  },
4644  &ssl_passphrase_command,
4645  "",
4646  NULL, NULL, NULL
4647  },
4648 
4649  {
4650  {"application_name", PGC_USERSET, LOGGING_WHAT,
4651  gettext_noop("Sets the application name to be reported in statistics and logs."),
4652  NULL,
4653  GUC_IS_NAME | GUC_REPORT | GUC_NOT_IN_SAMPLE
4654  },
4655  &application_name,
4656  "",
4657  check_application_name, assign_application_name, NULL
4658  },
4659 
4660  {
4661  {"cluster_name", PGC_POSTMASTER, PROCESS_TITLE,
4662  gettext_noop("Sets the name of the cluster, which is included in the process title."),
4663  NULL,
4664  GUC_IS_NAME
4665  },
4666  &cluster_name,
4667  "",
4668  check_cluster_name, NULL, NULL
4669  },
4670 
4671  {
4672  {"wal_consistency_checking", PGC_SUSET, DEVELOPER_OPTIONS,
4673  gettext_noop("Sets the WAL resource managers for which WAL consistency checks are done."),
4674  gettext_noop("Full-page images will be logged for all data blocks and cross-checked against the results of WAL replay."),
4675  GUC_LIST_INPUT | GUC_NOT_IN_SAMPLE
4676  },
4677  &wal_consistency_checking_string,
4678  "",
4679  check_wal_consistency_checking, assign_wal_consistency_checking, NULL
4680  },
4681 
4682  {
4683  {"jit_provider", PGC_POSTMASTER, CLIENT_CONN_PRELOAD,
4684  gettext_noop("JIT provider to use."),
4685  NULL,
4686  GUC_SUPERUSER_ONLY
4687  },
4688  &jit_provider,
4689  "llvmjit",
4690  NULL, NULL, NULL
4691  },
4692 
4693  {
4694  {"backtrace_functions", PGC_SUSET, DEVELOPER_OPTIONS,
4695  gettext_noop("Log backtrace for errors in these functions."),
4696  NULL,
4697  GUC_NOT_IN_SAMPLE
4698  },
4699  &backtrace_functions,
4700  "",
4701  check_backtrace_functions, assign_backtrace_functions, NULL
4702  },
4703 
4704  {
4705  {"debug_io_direct", PGC_POSTMASTER, DEVELOPER_OPTIONS,
4706  gettext_noop("Use direct I/O for file access."),
4707  NULL,
4708  GUC_LIST_INPUT | GUC_NOT_IN_SAMPLE
4709  },
4710  &debug_io_direct_string,
4711  "",
4712  check_debug_io_direct, assign_debug_io_direct, NULL
4713  },
4714 
4715  {
4716  {"standby_slot_names", PGC_SIGHUP, REPLICATION_PRIMARY,
4717  gettext_noop("Lists streaming replication standby server slot "
4718  "names that logical WAL sender processes will wait for."),
4719  gettext_noop("Logical WAL sender processes will send decoded "
4720  "changes to plugins only after the specified "
4721  "replication slots confirm receiving WAL."),
4722  GUC_LIST_INPUT
4723  },
4724  &standby_slot_names,
4725  "",
4726  check_standby_slot_names, assign_standby_slot_names, NULL
4727  },
4728 
4729  /* End-of-list marker */
4730  {
4731  {NULL, 0, 0, NULL, NULL}, NULL, NULL, NULL, NULL, NULL
4732  }
4733 };
4734 
4735 
4736 struct config_enum ConfigureNamesEnum[] =
4737 {
4738  {
4739  {"backslash_quote", PGC_USERSET, COMPAT_OPTIONS_PREVIOUS,
4740  gettext_noop("Sets whether \"\\'\" is allowed in string literals."),
4741  NULL
4742  },
4743  &backslash_quote,
4744  BACKSLASH_QUOTE_SAFE_ENCODING, backslash_quote_options,
4745  NULL, NULL, NULL
4746  },
4747 
4748  {
4749  {"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
4750  gettext_noop("Sets the output format for bytea."),
4751  NULL
4752  },
4753  &bytea_output,
4754  BYTEA_OUTPUT_HEX, bytea_output_options,
4755  NULL, NULL, NULL
4756  },
4757 
4758  {
4759  {"client_min_messages", PGC_USERSET, CLIENT_CONN_STATEMENT,
4760  gettext_noop("Sets the message levels that are sent to the client."),
4761  gettext_noop("Each level includes all the levels that follow it. The later"
4762  " the level, the fewer messages are sent.")
4763  },
4764  &client_min_messages,
4765  NOTICE, client_message_level_options,
4766  NULL, NULL, NULL
4767  },
4768 
4769  {
4770  {"compute_query_id", PGC_SUSET, STATS_MONITORING,
4771  gettext_noop("Enables in-core computation of query identifiers."),
4772  NULL
4773  },
4774  &compute_query_id,
4775  COMPUTE_QUERY_ID_AUTO, compute_query_id_options,
4776  NULL, NULL, NULL
4777  },
4778 
4779  {
4780  {"constraint_exclusion", PGC_USERSET, QUERY_TUNING_OTHER,
4781  gettext_noop("Enables the planner to use constraints to optimize queries."),
4782  gettext_noop("Table scans will be skipped if their constraints"
4783  " guarantee that no rows match the query."),
4784  GUC_EXPLAIN
4785  },
4786  &constraint_exclusion,
4787  CONSTRAINT_EXCLUSION_PARTITION, constraint_exclusion_options,
4788  NULL, NULL, NULL
4789  },
4790 
4791  {
4792  {"default_toast_compression", PGC_USERSET, CLIENT_CONN_STATEMENT,
4793  gettext_noop("Sets the default compression method for compressible values."),
4794  NULL
4795  },
4796  &default_toast_compression,
4797  TOAST_PGLZ_COMPRESSION,
4798  default_toast_compression_options,
4799  NULL, NULL, NULL
4800  },
4801 
4802  {
4803  {"default_transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
4804  gettext_noop("Sets the transaction isolation level of each new transaction."),
4805  NULL
4806  },
4807  &DefaultXactIsoLevel,
4808  XACT_READ_COMMITTED, isolation_level_options,
4809  NULL, NULL, NULL
4810  },
4811 
4812  {
4813  {"transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
4814  gettext_noop("Sets the current transaction's isolation level."),
4815  NULL,
4816  GUC_NO_RESET | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
4817  },
4818  &XactIsoLevel,
4819  XACT_READ_COMMITTED, isolation_level_options,
4820  check_transaction_isolation, NULL, NULL
4821  },
4822 
4823  {
4824  {"IntervalStyle", PGC_USERSET, CLIENT_CONN_LOCALE,
4825  gettext_noop("Sets the display format for interval values."),
4826  NULL,
4827  GUC_REPORT
4828  },
4829  &IntervalStyle,
4830  INTSTYLE_POSTGRES, intervalstyle_options,
4831  NULL, NULL, NULL
4832  },
4833 
4834  {
4835  {"icu_validation_level", PGC_USERSET, CLIENT_CONN_LOCALE,
4836  gettext_noop("Log level for reporting invalid ICU locale strings."),
4837  NULL
4838  },
4839  &icu_validation_level,
4840  WARNING, icu_validation_level_options,
4841  NULL, NULL, NULL
4842  },
4843 
4844  {
4845  {"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
4846  gettext_noop("Sets the verbosity of logged messages."),
4847  NULL
4848  },
4849  &Log_error_verbosity,
4850  PGERROR_DEFAULT, log_error_verbosity_options,
4851  NULL, NULL, NULL
4852  },
4853 
4854  {
4855  {"log_min_messages", PGC_SUSET, LOGGING_WHEN,
4856  gettext_noop("Sets the message levels that are logged."),
4857  gettext_noop("Each level includes all the levels that follow it. The later"
4858  " the level, the fewer messages are sent.")
4859  },
4860  &log_min_messages,
4861  WARNING, server_message_level_options,
4862  NULL, NULL, NULL
4863  },
4864 
4865  {
4866  {"log_min_error_statement", PGC_SUSET, LOGGING_WHEN,
4867  gettext_noop("Causes all statements generating error at or above this level to be logged."),
4868  gettext_noop("Each level includes all the levels that follow it. The later"
4869  " the level, the fewer messages are sent.")
4870  },
4871  &log_min_error_statement,
4872  ERROR, server_message_level_options,
4873  NULL, NULL, NULL
4874  },
4875 
4876  {
4877  {"log_statement", PGC_SUSET, LOGGING_WHAT,
4878  gettext_noop("Sets the type of statements logged."),
4879  NULL
4880  },
4881  &log_statement,
4882  LOGSTMT_NONE, log_statement_options,
4883  NULL, NULL, NULL
4884  },
4885 
4886  {
4887  {"syslog_facility", PGC_SIGHUP, LOGGING_WHERE,
4888  gettext_noop("Sets the syslog \"facility\" to be used when syslog enabled."),
4889  NULL
4890  },
4891  &syslog_facility,
4892  DEFAULT_SYSLOG_FACILITY,
4893  syslog_facility_options,
4894  NULL, assign_syslog_facility, NULL
4895  },
4896 
4897  {
4898  {"session_replication_role", PGC_SUSET, CLIENT_CONN_STATEMENT,
4899  gettext_noop("Sets the session's behavior for triggers and rewrite rules."),
4900  NULL
4901  },
4902  &SessionReplicationRole,
4903  SESSION_REPLICATION_ROLE_ORIGIN, session_replication_role_options,
4904  NULL, assign_session_replication_role, NULL
4905  },
4906 
4907  {
4908  {"synchronous_commit", PGC_USERSET, WAL_SETTINGS,
4909  gettext_noop("Sets the current transaction's synchronization level."),
4910  NULL
4911  },
4912  &synchronous_commit,
4913  SYNCHRONOUS_COMMIT_ON, synchronous_commit_options,
4914  NULL, assign_synchronous_commit, NULL
4915  },
4916 
4917  {
4918  {"archive_mode", PGC_POSTMASTER, WAL_ARCHIVING,
4919  gettext_noop("Allows archiving of WAL files using archive_command."),
4920  NULL
4921  },
4922  &XLogArchiveMode,
4923  ARCHIVE_MODE_OFF, archive_mode_options,
4924  NULL, NULL, NULL
4925  },
4926 
4927  {
4928  {"recovery_target_action", PGC_POSTMASTER, WAL_RECOVERY_TARGET,
4929  gettext_noop("Sets the action to perform upon reaching the recovery target."),
4930  NULL
4931  },
4932  &recoveryTargetAction,
4933  RECOVERY_TARGET_ACTION_PAUSE, recovery_target_action_options,
4934  NULL, NULL, NULL
4935  },
4936 
4937  {
4938  {"track_functions", PGC_SUSET, STATS_CUMULATIVE,
4939  gettext_noop("Collects function-level statistics on database activity."),
4940  NULL
4941  },
4942  &pgstat_track_functions,
4943  TRACK_FUNC_OFF, track_function_options,
4944  NULL, NULL, NULL
4945  },
4946 
4947 
4948  {
4949  {"stats_fetch_consistency", PGC_USERSET, STATS_CUMULATIVE,
4950  gettext_noop("Sets the consistency of accesses to statistics data."),
4951  NULL
4952  },
4953  &pgstat_fetch_consistency,
4954  PGSTAT_FETCH_CONSISTENCY_CACHE, stats_fetch_consistency,
4955  NULL, assign_stats_fetch_consistency, NULL
4956  },
4957 
4958  {
4959  {"wal_compression", PGC_SUSET, WAL_SETTINGS,
4960  gettext_noop("Compresses full-page writes written in WAL file with specified method."),
4961  NULL
4962  },
4963  &wal_compression,
4964  WAL_COMPRESSION_NONE, wal_compression_options,
4965  NULL, NULL, NULL
4966  },
4967 
4968  {
4969  {"wal_level", PGC_POSTMASTER, WAL_SETTINGS,
4970  gettext_noop("Sets the level of information written to the WAL."),
4971  NULL
4972  },
4973  &wal_level,
4974  WAL_LEVEL_REPLICA, wal_level_options,
4975  NULL, NULL, NULL
4976  },
4977 
4978  {
4979  {"dynamic_shared_memory_type", PGC_POSTMASTER, RESOURCES_MEM,
4980  gettext_noop("Selects the dynamic shared memory implementation used."),
4981  NULL
4982  },
4983  &dynamic_shared_memory_type,
4984  DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE, dynamic_shared_memory_options,
4985  NULL, NULL, NULL
4986  },
4987 
4988  {
4989  {"shared_memory_type", PGC_POSTMASTER, RESOURCES_MEM,
4990  gettext_noop("Selects the shared memory implementation used for the main shared memory region."),
4991  NULL
4992  },
4993  &shared_memory_type,
4994  DEFAULT_SHARED_MEMORY_TYPE, shared_memory_options,
4995  NULL, NULL, NULL
4996  },
4997 
4998  {
4999  {"wal_sync_method", PGC_SIGHUP, WAL_SETTINGS,
5000  gettext_noop("Selects the method used for forcing WAL updates to disk."),
5001  NULL
5002  },
5003  &wal_sync_method,
5004  DEFAULT_WAL_SYNC_METHOD, wal_sync_method_options,
5005  NULL, assign_wal_sync_method, NULL
5006  },
5007 
5008  {
5009  {"xmlbinary", PGC_USERSET, CLIENT_CONN_STATEMENT,
5010  gettext_noop("Sets how binary values are to be encoded in XML."),
5011  NULL
5012  },
5013  &xmlbinary,
5014  XMLBINARY_BASE64, xmlbinary_options,
5015  NULL, NULL, NULL
5016  },
5017 
5018  {
5019  {"xmloption", PGC_USERSET, CLIENT_CONN_STATEMENT,
5020  gettext_noop("Sets whether XML data in implicit parsing and serialization "
5021  "operations is to be considered as documents or content fragments."),
5022  NULL
5023  },
5024  &xmloption,
5025  XMLOPTION_CONTENT, xmloption_options,
5026  NULL, NULL, NULL
5027  },
5028 
5029  {
5030  {"huge_pages", PGC_POSTMASTER, RESOURCES_MEM,
5031  gettext_noop("Use of huge pages on Linux or Windows."),
5032  NULL
5033  },
5034  &huge_pages,
5035  HUGE_PAGES_TRY, huge_pages_options,
5036  NULL, NULL, NULL
5037  },
5038 
5039  {
5040  {"huge_pages_status", PGC_INTERNAL, PRESET_OPTIONS,
5041  gettext_noop("Indicates the status of huge pages."),
5042  NULL,
5043  GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
5044  },
5045  &huge_pages_status,
5046  HUGE_PAGES_UNKNOWN, huge_pages_status_options,
5047  NULL, NULL, NULL
5048  },
5049 
5050  {
5051  {"recovery_prefetch", PGC_SIGHUP, WAL_RECOVERY,
5052  gettext_noop("Prefetch referenced blocks during recovery."),
5053  gettext_noop("Look ahead in the WAL to find references to uncached data.")
5054  },
5055  &recovery_prefetch,
5056  RECOVERY_PREFETCH_TRY, recovery_prefetch_options,
5057  check_recovery_prefetch, assign_recovery_prefetch, NULL
5058  },
5059 
5060  {
5061  {"debug_parallel_query", PGC_USERSET, DEVELOPER_OPTIONS,
5062  gettext_noop("Forces the planner's use parallel query nodes."),
5063  gettext_noop("This can be useful for testing the parallel query infrastructure "
5064  "by forcing the planner to generate plans that contain nodes "
5065  "that perform tuple communication between workers and the main process."),
5066  GUC_NOT_IN_SAMPLE | GUC_EXPLAIN
5067  },
5068  &debug_parallel_query,
5069  DEBUG_PARALLEL_OFF, debug_parallel_query_options,
5070  NULL, NULL, NULL
5071  },
5072 
5073  {
5074  {"password_encryption", PGC_USERSET, CONN_AUTH_AUTH,
5075  gettext_noop("Chooses the algorithm for encrypting passwords."),
5076  NULL
5077  },
5078  &Password_encryption,
5079  PASSWORD_TYPE_SCRAM_SHA_256, password_encryption_options,
5080  NULL, NULL, NULL
5081  },
5082 
5083  {
5084  {"plan_cache_mode", PGC_USERSET, QUERY_TUNING_OTHER,
5085  gettext_noop("Controls the planner's selection of custom or generic plan."),
5086  gettext_noop("Prepared statements can have custom and generic plans, and the planner "
5087  "will attempt to choose which is better. This can be set to override "
5088  "the default behavior."),
5089  GUC_EXPLAIN
5090  },
5091  &plan_cache_mode,
5092  PLAN_CACHE_MODE_AUTO, plan_cache_mode_options,
5093  NULL, NULL, NULL
5094  },
5095 
5096  {
5097  {"ssl_min_protocol_version", PGC_SIGHUP, CONN_AUTH_SSL,
5098  gettext_noop("Sets the minimum SSL/TLS protocol version to use."),
5099  NULL,
5100  GUC_SUPERUSER_ONLY
5101  },
5102  &ssl_min_protocol_version,
5103  PG_TLS1_2_VERSION,
5104  ssl_protocol_versions_info + 1, /* don't allow PG_TLS_ANY */
5105  NULL, NULL, NULL
5106  },
5107 
5108  {
5109  {"ssl_max_protocol_version", PGC_SIGHUP, CONN_AUTH_SSL,
5110  gettext_noop("Sets the maximum SSL/TLS protocol version to use."),
5111  NULL,
5112  GUC_SUPERUSER_ONLY
5113  },
5114  &ssl_max_protocol_version,
5115  PG_TLS_ANY,
5116  ssl_protocol_versions_info,
5117  NULL, NULL, NULL
5118  },
5119 
5120  {
5121  {"recovery_init_sync_method", PGC_SIGHUP, ERROR_HANDLING_OPTIONS,
5122  gettext_noop("Sets the method for synchronizing the data directory before crash recovery."),
5123  },
5124  &recovery_init_sync_method,
5125  DATA_DIR_SYNC_METHOD_FSYNC, recovery_init_sync_method_options,
5126  NULL, NULL, NULL
5127  },
5128 
5129  {
5130  {"debug_logical_replication_streaming", PGC_USERSET, DEVELOPER_OPTIONS,
5131  gettext_noop("Forces immediate streaming or serialization of changes in large transactions."),
5132  gettext_noop("On the publisher, it allows streaming or serializing each change in logical decoding. "
5133  "On the subscriber, it allows serialization of all changes to files and notifies the "
5134  "parallel apply workers to read and apply them at the end of the transaction."),
5135  GUC_NOT_IN_SAMPLE
5136  },
5137  &debug_logical_replication_streaming,
5138  DEBUG_LOGICAL_REP_STREAMING_BUFFERED, debug_logical_replication_streaming_options,
5139  NULL, NULL, NULL
5140  },
5141 
5142  /* End-of-list marker */
5143  {
5144  {NULL, 0, 0, NULL, NULL}, NULL, 0, NULL, NULL, NULL, NULL
5145  }
5146 };
geqo_threshold
int geqo_threshold
Definition: allpaths.c:80
enable_geqo
bool enable_geqo
Definition: allpaths.c:79
min_parallel_index_scan_size
int min_parallel_index_scan_size
Definition: allpaths.c:82
min_parallel_table_scan_size
int min_parallel_table_scan_size
Definition: allpaths.c:81
enable_self_join_removal
bool enable_self_join_removal
Definition: analyzejoins.c:44
archive_module.h
Array_nulls
bool Array_nulls
Definition: arrayfuncs.c:43
max_notify_queue_pages
int max_notify_queue_pages
Definition: async.c:428
Trace_notify
bool Trace_notify
Definition: async.c:425
check_notify_buffers
bool check_notify_buffers(int *newval, void **extra, GucSource source)
Definition: async.c:2394
scram_sha_256_iterations
int scram_sha_256_iterations
Definition: auth-scram.c:192
pg_krb_server_keyfile
char * pg_krb_server_keyfile
Definition: auth.c:164
pg_krb_caseins_users
bool pg_krb_caseins_users
Definition: auth.c:165
pg_gss_accept_delegation
bool pg_gss_accept_delegation
Definition: auth.c:166
autovacuum_multixact_freeze_max_age
int autovacuum_multixact_freeze_max_age
Definition: autovacuum.c:127
autovacuum_naptime
int autovacuum_naptime
Definition: autovacuum.c:119
autovacuum_vac_scale
double autovacuum_vac_scale
Definition: autovacuum.c:121
Log_autovacuum_min_duration
int Log_autovacuum_min_duration
Definition: autovacuum.c:132
autovacuum_anl_thresh
int autovacuum_anl_thresh
Definition: autovacuum.c:124
check_autovacuum_work_mem
bool check_autovacuum_work_mem(int *newval, void **extra, GucSource source)
Definition: autovacuum.c:3320
autovacuum_vac_cost_limit
int autovacuum_vac_cost_limit
Definition: autovacuum.c:130
autovacuum_max_workers
int autovacuum_max_workers
Definition: autovacuum.c:117
autovacuum_freeze_max_age
int autovacuum_freeze_max_age
Definition: autovacuum.c:126
autovacuum_vac_cost_delay
double autovacuum_vac_cost_delay
Definition: autovacuum.c:129
autovacuum_vac_thresh
int autovacuum_vac_thresh
Definition: autovacuum.c:120
autovacuum_work_mem
int autovacuum_work_mem
Definition: autovacuum.c:118
autovacuum_anl_scale
double autovacuum_anl_scale
Definition: autovacuum.c:125
autovacuum_vac_ins_thresh
int autovacuum_vac_ins_thresh
Definition: autovacuum.c:122
autovacuum_start_daemon
bool autovacuum_start_daemon
Definition: autovacuum.c:116
autovacuum_vac_ins_scale
double autovacuum_vac_ins_scale
Definition: autovacuum.c:123
check_default_tablespace
bool check_default_tablespace(char **newval, void **extra, GucSource source)
Definition: tablespace.c:1091
assign_temp_tablespaces
void assign_temp_tablespaces(const char *newval, void *extra)
Definition: tablespace.c:1306
check_temp_tablespaces
bool check_temp_tablespaces(char **newval, void **extra, GucSource source)
Definition: tablespace.c:1198
allow_in_place_tablespaces
bool allow_in_place_tablespaces
Definition: tablespace.c:85
Password_encryption
int Password_encryption
Definition: user.c:85
check_createrole_self_grant
bool check_createrole_self_grant(char **newval, void **extra, GucSource source)
Definition: user.c:2515
assign_createrole_self_grant
void assign_createrole_self_grant(const char *newval, void *extra)
Definition: user.c:2566
createrole_self_grant
char * createrole_self_grant
Definition: user.c:86
show_unix_socket_permissions
const char * show_unix_socket_permissions(void)
Definition: variable.c:1157
assign_application_name
void assign_application_name(const char *newval, void *extra)
Definition: variable.c:1075
check_bonjour
bool check_bonjour(bool *newval, void **extra, GucSource source)
Definition: variable.c:1172
check_maintenance_io_concurrency
bool check_maintenance_io_concurrency(int *newval, void **extra, GucSource source)
Definition: variable.c:1213
assign_session_authorization
void assign_session_authorization(const char *newval, void *extra)
Definition: variable.c:885
check_transaction_deferrable
bool check_transaction_deferrable(bool *newval, void **extra, GucSource source)
Definition: variable.c:620
check_canonical_path
bool check_canonical_path(char **newval, void **extra, GucSource source)
Definition: variable.c:1028
show_timezone
const char * show_timezone(void)
Definition: variable.c:390
check_transaction_isolation
bool check_transaction_isolation(int *newval, void **extra, GucSource source)
Definition: variable.c:583
check_default_with_oids
bool check_default_with_oids(bool *newval, void **extra, GucSource source)
Definition: variable.c:1185
assign_timezone_abbreviations
void assign_timezone_abbreviations(const char *newval, void *extra)
Definition: variable.c:517
check_effective_io_concurrency
bool check_effective_io_concurrency(int *newval, void **extra, GucSource source)
Definition: variable.c:1200
check_application_name
bool check_application_name(char **newval, void **extra, GucSource source)
Definition: variable.c:1049
assign_timezone
void assign_timezone(const char *newval, void *extra)
Definition: variable.c:381
check_role
bool check_role(char **newval, void **extra, GucSource source)
Definition: variable.c:907
check_cluster_name
bool check_cluster_name(char **newval, void **extra, GucSource source)
Definition: variable.c:1085
show_log_timezone
const char * show_log_timezone(void)
Definition: variable.c:463
check_session_authorization
bool check_session_authorization(char **newval, void **extra, GucSource source)
Definition: variable.c:802
check_transaction_read_only
bool check_transaction_read_only(bool *newval, void **extra, GucSource source)
Definition: variable.c:544
assign_maintenance_io_concurrency
void assign_maintenance_io_concurrency(int newval, void *extra)
Definition: variable.c:1111
check_timezone_abbreviations
bool check_timezone_abbreviations(char **newval, void **extra, GucSource source)
Definition: variable.c:485
assign_client_encoding
void assign_client_encoding(const char *newval, void *extra)
Definition: variable.c:756
assign_role
void assign_role(const char *newval, void *extra)
Definition: variable.c:995
check_timezone
bool check_timezone(char **newval, void **extra, GucSource source)
Definition: variable.c:261
show_random_seed
const char * show_random_seed(void)
Definition: variable.c:669
check_ssl
bool check_ssl(bool *newval, void **extra, GucSource source)
Definition: variable.c:1226
assign_datestyle
void assign_datestyle(const char *newval, void *extra)
Definition: variable.c:244
assign_random_seed
void assign_random_seed(double newval, void *extra)
Definition: variable.c:660
check_log_timezone
bool check_log_timezone(char **newval, void **extra, GucSource source)
Definition: variable.c:416
check_random_seed
bool check_random_seed(double *newval, void **extra, GucSource source)
Definition: variable.c:648
show_role
const char * show_role(void)
Definition: variable.c:1003
check_datestyle
bool check_datestyle(char **newval, void **extra, GucSource source)
Definition: variable.c:52
check_client_encoding
bool check_client_encoding(char **newval, void **extra, GucSource source)
Definition: variable.c:680
show_log_file_mode
const char * show_log_file_mode(void)
Definition: variable.c:1145
show_data_directory_mode
const char * show_data_directory_mode(void)
Definition: variable.c:1133
assign_log_timezone
void assign_log_timezone(const char *newval, void *extra)
Definition: variable.c:454
log_startup_progress_interval
int log_startup_progress_interval
Definition: startup.c:76
pgstat_track_activities
bool pgstat_track_activities
Definition: backend_status.c:44
pgstat_track_activity_query_size
int pgstat_track_activity_query_size
Definition: backend_status.c:45
ssl_crl_dir
char * ssl_crl_dir
Definition: be-secure.c:40
ssl_dh_params_file
char * ssl_dh_params_file
Definition: be-secure.c:41
ssl_min_protocol_version
int ssl_min_protocol_version
Definition: be-secure.c:58
ssl_cert_file
char * ssl_cert_file
Definition: be-secure.c:36
SSLPreferServerCiphers
bool SSLPreferServerCiphers
Definition: be-secure.c:56
ssl_library
char * ssl_library
Definition: be-secure.c:35
ssl_max_protocol_version
int ssl_max_protocol_version
Definition: be-secure.c:59
ssl_passphrase_command
char * ssl_passphrase_command
Definition: be-secure.c:42
ssl_passphrase_command_supports_reload
bool ssl_passphrase_command_supports_reload
Definition: be-secure.c:43
SSLCipherSuites
char * SSLCipherSuites
Definition: be-secure.c:50
SSLECDHCurve
char * SSLECDHCurve
Definition: be-secure.c:53
ssl_key_file
char * ssl_key_file
Definition: be-secure.c:37
ssl_crl_file
char * ssl_crl_file
Definition: be-secure.c:39
ssl_ca_file
char * ssl_ca_file
Definition: be-secure.c:38
bgworker_internals.h
MAX_PARALLEL_WORKER_LIMIT
#define MAX_PARALLEL_WORKER_LIMIT
Definition: bgworker_internals.h:24
BgWriterDelay
int BgWriterDelay
Definition: bgwriter.c:57
track_io_timing
bool track_io_timing
Definition: bufmgr.c:142
zero_damaged_pages
bool zero_damaged_pages
Definition: bufmgr.c:139
bgwriter_flush_after
int bgwriter_flush_after
Definition: bufmgr.c:171
checkpoint_flush_after
int checkpoint_flush_after
Definition: bufmgr.c:170
bgwriter_lru_multiplier
double bgwriter_lru_multiplier
Definition: bufmgr.c:141
backend_flush_after
int backend_flush_after
Definition: bufmgr.c:172
maintenance_io_concurrency
int maintenance_io_concurrency
Definition: bufmgr.c:157
effective_io_concurrency
int effective_io_concurrency
Definition: bufmgr.c:150
io_combine_limit
int io_combine_limit
Definition: bufmgr.c:164
bgwriter_lru_maxpages
int bgwriter_lru_maxpages
Definition: bufmgr.c:140
DEFAULT_IO_COMBINE_LIMIT
#define DEFAULT_IO_COMBINE_LIMIT
Definition: bufmgr.h:173
MAX_IO_COMBINE_LIMIT
#define MAX_IO_COMBINE_LIMIT
Definition: bufmgr.h:172
MAX_IO_CONCURRENCY
#define MAX_IO_CONCURRENCY
Definition: bufmgr.h:189
DEFAULT_EFFECTIVE_IO_CONCURRENCY
#define DEFAULT_EFFECTIVE_IO_CONCURRENCY
Definition: bufmgr.h:166
DEFAULT_MAINTENANCE_IO_CONCURRENCY
#define DEFAULT_MAINTENANCE_IO_CONCURRENCY
Definition: bufmgr.h:167
BYTEA_OUTPUT_HEX
@ BYTEA_OUTPUT_HEX
Definition: bytea.h:22
BYTEA_OUTPUT_ESCAPE
@ BYTEA_OUTPUT_ESCAPE
Definition: bytea.h:21
Min
#define Min(x, y)
Definition: c.h:1004
gettext_noop
#define gettext_noop(x)
Definition: c.h:1196
lengthof
#define lengthof(array)
Definition: c.h:788
CheckPointCompletionTarget
double CheckPointCompletionTarget
Definition: checkpointer.c:138
CheckPointWarning
int CheckPointWarning
Definition: checkpointer.c:137
CheckPointTimeout
int CheckPointTimeout
Definition: checkpointer.c:136
check_transaction_buffers
bool check_transaction_buffers(int *newval, void **extra, GucSource source)
Definition: clog.c:821
default_statistics_target
int default_statistics_target
Definition: analyze.c:73
track_commit_timestamp
bool track_commit_timestamp
Definition: commit_ts.c:109
check_commit_ts_buffers
bool check_commit_ts_buffers(int *newval, void **extra, GucSource source)
Definition: commit_ts.c:584
commit_ts.h
DEFAULT_PARALLEL_TUPLE_COST
#define DEFAULT_PARALLEL_TUPLE_COST
Definition: cost.h:29
DEFAULT_PARALLEL_SETUP_COST
#define DEFAULT_PARALLEL_SETUP_COST
Definition: cost.h:30
CONSTRAINT_EXCLUSION_OFF
@ CONSTRAINT_EXCLUSION_OFF
Definition: cost.h:38
CONSTRAINT_EXCLUSION_PARTITION
@ CONSTRAINT_EXCLUSION_PARTITION
Definition: cost.h:40
CONSTRAINT_EXCLUSION_ON
@ CONSTRAINT_EXCLUSION_ON
Definition: cost.h:39
DEFAULT_CPU_INDEX_TUPLE_COST
#define DEFAULT_CPU_INDEX_TUPLE_COST
Definition: cost.h:27
DEFAULT_CPU_TUPLE_COST
#define DEFAULT_CPU_TUPLE_COST
Definition: cost.h:26
DEFAULT_RANDOM_PAGE_COST
#define DEFAULT_RANDOM_PAGE_COST
Definition: cost.h:25
DEFAULT_RECURSIVE_WORKTABLE_FACTOR
#define DEFAULT_RECURSIVE_WORKTABLE_FACTOR
Definition: cost.h:33
DEFAULT_EFFECTIVE_CACHE_SIZE
#define DEFAULT_EFFECTIVE_CACHE_SIZE
Definition: cost.h:34
DEFAULT_SEQ_PAGE_COST
#define DEFAULT_SEQ_PAGE_COST
Definition: cost.h:24
DEFAULT_CPU_OPERATOR_COST
#define DEFAULT_CPU_OPERATOR_COST
Definition: cost.h:28
random_page_cost
double random_page_cost
Definition: costsize.c:120
cpu_operator_cost
double cpu_operator_cost
Definition: costsize.c:123
enable_partitionwise_aggregate
bool enable_partitionwise_aggregate
Definition: costsize.c:149
enable_seqscan
bool enable_seqscan
Definition: costsize.c:134
max_parallel_workers_per_gather
int max_parallel_workers_per_gather
Definition: costsize.c:132
enable_memoize
bool enable_memoize
Definition: costsize.c:144
parallel_setup_cost
double parallel_setup_cost
Definition: costsize.c:125
recursive_worktable_factor
double recursive_worktable_factor
Definition: costsize.c:126
enable_gathermerge
bool enable_gathermerge
Definition: costsize.c:147
parallel_tuple_cost
double parallel_tuple_cost
Definition: costsize.c:124
enable_indexonlyscan
bool enable_indexonlyscan
Definition: costsize.c:136
enable_tidscan
bool enable_tidscan
Definition: costsize.c:138
cpu_tuple_cost
double cpu_tuple_cost
Definition: costsize.c:121
enable_material
bool enable_material
Definition: costsize.c:143
enable_hashjoin
bool enable_hashjoin
Definition: costsize.c:146
enable_mergejoin
bool enable_mergejoin
Definition: costsize.c:145
enable_presorted_aggregate
bool enable_presorted_aggregate
Definition: costsize.c:153
enable_parallel_hash
bool enable_parallel_hash
Definition: costsize.c:151
enable_partitionwise_join
bool enable_partitionwise_join
Definition: costsize.c:148
enable_async_append
bool enable_async_append
Definition: costsize.c:154
seq_page_cost
double seq_page_cost
Definition: costsize.c:119
enable_parallel_append
bool enable_parallel_append
Definition: costsize.c:150
enable_nestloop
bool enable_nestloop
Definition: costsize.c:142
enable_bitmapscan
bool enable_bitmapscan
Definition: costsize.c:137
enable_hashagg
bool enable_hashagg
Definition: costsize.c:141
enable_partition_pruning
bool enable_partition_pruning
Definition: costsize.c:152
enable_sort
bool enable_sort
Definition: costsize.c:139
effective_cache_size
int effective_cache_size
Definition: costsize.c:128
cpu_index_tuple_cost
double cpu_index_tuple_cost
Definition: costsize.c:122
enable_indexscan
bool enable_indexscan
Definition: costsize.c:135
enable_incremental_sort
bool enable_incremental_sort
Definition: costsize.c:140
PASSWORD_TYPE_SCRAM_SHA_256
@ PASSWORD_TYPE_SCRAM_SHA_256
Definition: crypt.h:31
PASSWORD_TYPE_MD5
@ PASSWORD_TYPE_MD5
Definition: crypt.h:30
MINS_PER_HOUR
#define MINS_PER_HOUR
Definition: timestamp.h:129
SECS_PER_MINUTE
#define SECS_PER_MINUTE
Definition: timestamp.h:128
HOURS_PER_DAY
#define HOURS_PER_DAY
Definition: timestamp.h:118
Dynamic_library_path
char * Dynamic_library_path
Definition: dfmgr.c:77
min_dynamic_shared_memory
int min_dynamic_shared_memory
Definition: dsm_impl.c:115
dynamic_shared_memory_type
int dynamic_shared_memory_type
Definition: dsm_impl.c:112
DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE
#define DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE
Definition: dsm_impl.h:36
assign_syslog_facility
void assign_syslog_facility(int newval, void *extra)
Definition: elog.c:2304
assign_syslog_ident
void assign_syslog_ident(const char *newval, void *extra)
Definition: elog.c:2272
syslog_split_messages
bool syslog_split_messages
Definition: elog.c:115
assign_backtrace_functions
void assign_backtrace_functions(const char *newval, void *extra)
Definition: elog.c:2192
Log_error_verbosity
int Log_error_verbosity
Definition: elog.c:110
check_backtrace_functions
bool check_backtrace_functions(char **newval, void **extra, GucSource source)
Definition: elog.c:2133
check_log_destination
bool check_log_destination(char **newval, void **extra, GucSource source)
Definition: elog.c:2201
syslog_sequence_numbers
bool syslog_sequence_numbers
Definition: elog.c:114
Log_destination_string
char * Log_destination_string
Definition: elog.c:113
Log_line_prefix
char * Log_line_prefix
Definition: elog.c:111
assign_log_destination
void assign_log_destination(const char *newval, void *extra)
Definition: elog.c:2263
PGERROR_VERBOSE
@ PGERROR_VERBOSE
Definition: elog.h:481
PGERROR_DEFAULT
@ PGERROR_DEFAULT
Definition: elog.h:480
PGERROR_TERSE
@ PGERROR_TERSE
Definition: elog.h:479
LOG
#define LOG
Definition: elog.h:31
DEBUG3
#define DEBUG3
Definition: elog.h:28
FATAL
#define FATAL
Definition: elog.h:41
WARNING
#define WARNING
Definition: elog.h:36
DEBUG2
#define DEBUG2
Definition: elog.h:29
PANIC
#define PANIC
Definition: elog.h:42
DEBUG1
#define DEBUG1
Definition: elog.h:30
ERROR
#define ERROR
Definition: elog.h:39
NOTICE
#define NOTICE
Definition: elog.h:35
INFO
#define INFO
Definition: elog.h:34
DEBUG5
#define DEBUG5
Definition: elog.h:26
DEBUG4
#define DEBUG4
Definition: elog.h:27
event_triggers
bool event_triggers
Definition: event_trigger.c:84
event_trigger.h
max_files_per_process
int max_files_per_process
Definition: fd.c:146
recovery_init_sync_method
int recovery_init_sync_method
Definition: fd.c:165
assign_debug_io_direct
void assign_debug_io_direct(const char *newval, void *extra)
Definition: fd.c:4024
data_sync_retry
bool data_sync_retry
Definition: fd.c:162
check_debug_io_direct
bool check_debug_io_direct(char **newval, void **extra, GucSource source)
Definition: fd.c:3942
file_utils.h
DATA_DIR_SYNC_METHOD_SYNCFS
@ DATA_DIR_SYNC_METHOD_SYNCFS
Definition: file_utils.h:30
DATA_DIR_SYNC_METHOD_FSYNC
@ DATA_DIR_SYNC_METHOD_FSYNC
Definition: file_utils.h:29
extra_float_digits
int extra_float_digits
Definition: float.c:41
DEFAULT_GEQO_EFFORT
#define DEFAULT_GEQO_EFFORT
Definition: geqo.h:55
MAX_GEQO_EFFORT
#define MAX_GEQO_EFFORT
Definition: geqo.h:57
MAX_GEQO_SELECTION_BIAS
#define MAX_GEQO_SELECTION_BIAS
Definition: geqo.h:67
MIN_GEQO_EFFORT
#define MIN_GEQO_EFFORT
Definition: geqo.h:56
DEFAULT_GEQO_SELECTION_BIAS
#define DEFAULT_GEQO_SELECTION_BIAS
Definition: geqo.h:65
MIN_GEQO_SELECTION_BIAS
#define MIN_GEQO_SELECTION_BIAS
Definition: geqo.h:66
Geqo_pool_size
int Geqo_pool_size
Definition: geqo_main.c:45
Geqo_seed
double Geqo_seed
Definition: geqo_main.c:48
Geqo_generations
int Geqo_generations
Definition: geqo_main.c:46
Geqo_effort
int Geqo_effort
Definition: geqo_main.c:44
Geqo_selection_bias
double Geqo_selection_bias
Definition: geqo_main.c:47
gin_pending_list_limit
int gin_pending_list_limit
Definition: ginfast.c:39
GinFuzzySearchLimit
int GinFuzzySearchLimit
Definition: ginget.c:27
multixact_offset_buffers
int multixact_offset_buffers
Definition: globals.c:164
hash_mem_multiplier
double hash_mem_multiplier
Definition: globals.c:129
VacuumCostLimit
int VacuumCostLimit
Definition: globals.c:151
max_parallel_maintenance_workers
int max_parallel_maintenance_workers
Definition: globals.c:131
NBuffers
int NBuffers
Definition: globals.c:139
transaction_buffers
int transaction_buffers
Definition: globals.c:168
enableFsync
bool enableFsync
Definition: globals.c:126
VacuumCostPageMiss
int VacuumCostPageMiss
Definition: globals.c:149
MaxConnections
int MaxConnections
Definition: globals.c:140
multixact_member_buffers
int multixact_member_buffers
Definition: globals.c:163
data_directory_mode
int data_directory_mode
Definition: globals.c:74
allowSystemTableMods
bool allowSystemTableMods
Definition: globals.c:127
maintenance_work_mem
int maintenance_work_mem
Definition: globals.c:130
max_parallel_workers
int max_parallel_workers
Definition: globals.c:142
VacuumCostPageDirty
int VacuumCostPageDirty
Definition: globals.c:150
ExitOnAnyError
bool ExitOnAnyError
Definition: globals.c:120
IntervalStyle
int IntervalStyle
Definition: globals.c:124
notify_buffers
int notify_buffers
Definition: globals.c:165
work_mem
int work_mem
Definition: globals.c:128
VacuumBufferUsageLimit
int VacuumBufferUsageLimit
Definition: globals.c:146
VacuumCostPageHit
int VacuumCostPageHit
Definition: globals.c:148
commit_timestamp_buffers
int commit_timestamp_buffers
Definition: globals.c:162
VacuumCostDelay
double VacuumCostDelay
Definition: globals.c:152
subtransaction_buffers
int subtransaction_buffers
Definition: globals.c:167
max_worker_processes
int max_worker_processes
Definition: globals.c:141
serializable_buffers
int serializable_buffers
Definition: globals.c:166
GUC_UNIT_MB
#define GUC_UNIT_MB
Definition: guc.h:230
GUC_EXPLAIN
#define GUC_EXPLAIN
Definition: guc.h:215
GUC_SUPERUSER_ONLY
#define GUC_SUPERUSER_ONLY
Definition: guc.h:220
GUC_NO_RESET_ALL
#define GUC_NO_RESET_ALL
Definition: guc.h:214
GUC_NO_RESET
#define GUC_NO_RESET
Definition: guc.h:213
GUC_LIST_QUOTE
#define GUC_LIST_QUOTE
Definition: guc.h:211
GUC_UNIT_MS
#define GUC_UNIT_MS
Definition: guc.h:234
GUC_NOT_WHILE_SEC_REST
#define GUC_NOT_WHILE_SEC_REST
Definition: guc.h:222
GUC_UNIT_BLOCKS
#define GUC_UNIT_BLOCKS
Definition: guc.h:228
GUC_UNIT_XBLOCKS
#define GUC_UNIT_XBLOCKS
Definition: guc.h:229
GUC_IS_NAME
#define GUC_IS_NAME
Definition: guc.h:221
GUC_DISALLOW_IN_FILE
#define GUC_DISALLOW_IN_FILE
Definition: guc.h:218
GUC_LIST_INPUT
#define GUC_LIST_INPUT
Definition: guc.h:210
GUC_RUNTIME_COMPUTED
#define GUC_RUNTIME_COMPUTED
Definition: guc.h:225
PGC_S_DEFAULT
@ PGC_S_DEFAULT
Definition: guc.h:109
PGC_S_DYNAMIC_DEFAULT
@ PGC_S_DYNAMIC_DEFAULT
Definition: guc.h:110
PGC_S_FILE
@ PGC_S_FILE
Definition: guc.h:112
PGC_S_GLOBAL
@ PGC_S_GLOBAL
Definition: guc.h:114
PGC_S_DATABASE
@ PGC_S_DATABASE
Definition: guc.h:115
PGC_S_OVERRIDE
@ PGC_S_OVERRIDE
Definition: guc.h:119
PGC_S_ARGV
@ PGC_S_ARGV
Definition: guc.h:113
PGC_S_SESSION
@ PGC_S_SESSION
Definition: guc.h:122
PGC_S_CLIENT
@ PGC_S_CLIENT
Definition: guc.h:118
PGC_S_DATABASE_USER
@ PGC_S_DATABASE_USER
Definition: guc.h:117
PGC_S_ENV_VAR
@ PGC_S_ENV_VAR
Definition: guc.h:111
PGC_S_USER
@ PGC_S_USER
Definition: guc.h:116
PGC_S_TEST
@ PGC_S_TEST
Definition: guc.h:121
PGC_S_INTERACTIVE
@ PGC_S_INTERACTIVE
Definition: guc.h:120
GUC_NO_SHOW_ALL
#define GUC_NO_SHOW_ALL
Definition: guc.h:212
GUC_DISALLOW_IN_AUTO_FILE
#define GUC_DISALLOW_IN_AUTO_FILE
Definition: guc.h:223
PGC_SUSET
@ PGC_SUSET
Definition: guc.h:74
PGC_INTERNAL
@ PGC_INTERNAL
Definition: guc.h:69
PGC_USERSET
@ PGC_USERSET
Definition: guc.h:75
PGC_SU_BACKEND
@ PGC_SU_BACKEND
Definition: guc.h:72
PGC_POSTMASTER
@ PGC_POSTMASTER
Definition: guc.h:70
PGC_SIGHUP
@ PGC_SIGHUP
Definition: guc.h:71
PGC_BACKEND
@ PGC_BACKEND
Definition: guc.h:73
GUC_UNIT_BYTE
#define GUC_UNIT_BYTE
Definition: guc.h:231
GUC_NOT_IN_SAMPLE
#define GUC_NOT_IN_SAMPLE
Definition: guc.h:217
GUC_UNIT_S
#define GUC_UNIT_S
Definition: guc.h:235
GUC_REPORT
#define GUC_REPORT
Definition: guc.h:216
MAX_KILOBYTES
#define MAX_KILOBYTES
Definition: guc.h:25
GUC_UNIT_KB
#define GUC_UNIT_KB
Definition: guc.h:227
GUC_UNIT_MIN
#define GUC_UNIT_MIN
Definition: guc.h:236
guc_hooks.h
recovery_target_lsn_string
static char * recovery_target_lsn_string
Definition: guc_tables.c:617
log_statement_stats
bool log_statement_stats
Definition: guc_tables.c:508
client_encoding_string
static char * client_encoding_string
Definition: guc_tables.c:576
segment_size
static int segment_size
Definition: guc_tables.c:599
timezone_abbreviations_string
static char * timezone_abbreviations_string
Definition: guc_tables.c:592
stats_fetch_consistency
static const struct config_enum_entry stats_fetch_consistency[]
Definition: guc_tables.c:258
Debug_print_plan
bool Debug_print_plan
Definition: guc_tables.c:500
event_source
char * event_source
Definition: guc_tables.c:511
check_function_bodies
bool check_function_bodies
Definition: guc_tables.c:514
num_temp_buffers
int num_temp_buffers
Definition: guc_tables.c:538
client_min_messages
int client_min_messages
Definition: guc_tables.c:525
ignore_checksum_failure
bool ignore_checksum_failure
Definition: bufpage.c:27
max_identifier_length
static int max_identifier_length
Definition: guc_tables.c:597
password_encryption_options
static const struct config_enum_entry password_encryption_options[]
Definition: guc_tables.c:414
ssl_protocol_versions_info
static const struct config_enum_entry ssl_protocol_versions_info[]
Definition: guc_tables.c:420
recovery_target_action_options
const struct config_enum_entry recovery_target_action_options[]
Definition: xlogrecovery.c:74
default_with_oids
bool default_with_oids
Definition: guc_tables.c:520
ignore_invalid_pages
bool ignore_invalid_pages
Definition: xlogutils.c:34
ConfigureNamesString
struct config_string ConfigureNamesString[]
Definition: guc_tables.c:3959
CommitDelay
int CommitDelay
Definition: xlog.c:132
timezone_string
static char * timezone_string
Definition: guc_tables.c:590
Trace_connection_negotiation
bool Trace_connection_negotiation
Definition: backend_startup.c:41
PG_KRB_SRVTAB
#define PG_KRB_SRVTAB
Definition: guc_tables.c:94
debug_parallel_query_options
static const struct config_enum_entry debug_parallel_query_options[]
Definition: guc_tables.c:394
server_version_string
static char * server_version_string
Definition: guc_tables.c:579
log_min_error_statement
int log_min_error_statement
Definition: guc_tables.c:523
data_checksums
static bool data_checksums
Definition: guc_tables.c:603
syslog_facility_options
static const struct config_enum_entry syslog_facility_options[]
Definition: guc_tables.c:232
icu_validation_level_options
static const struct config_enum_entry icu_validation_level_options[]
Definition: guc_tables.c:174
recovery_prefetch_options
static const struct config_enum_entry recovery_prefetch_options[]
Definition: guc_tables.c:381
recovery_init_sync_method_options
static const struct config_enum_entry recovery_init_sync_method_options[]
Definition: guc_tables.c:438
tcp_keepalives_idle
int tcp_keepalives_idle
Definition: guc_tables.c:548
HbaFileName
char * HbaFileName
Definition: guc_tables.c:542
temp_file_limit
int temp_file_limit
Definition: guc_tables.c:536
GucContext_Names
const char *const GucContext_Names[]
Definition: guc_tables.c:631
ssl_renegotiation_limit
int ssl_renegotiation_limit
Definition: guc_tables.c:559
syslog_facility
static int syslog_facility
Definition: guc_tables.c:588
max_function_args
static int max_function_args
Definition: guc_tables.c:595
tcp_keepalives_interval
int tcp_keepalives_interval
Definition: guc_tables.c:549
max_index_keys
static int max_index_keys
Definition: guc_tables.c:596
backslash_quote_options
static const struct config_enum_entry backslash_quote_options[]
Definition: guc_tables.c:290
syslog_ident_str
static char * syslog_ident_str
Definition: guc_tables.c:574
DEFAULT_SYSLOG_FACILITY
#define DEFAULT_SYSLOG_FACILITY
Definition: guc_tables.c:586
CommitSiblings
int CommitSiblings
Definition: xlog.c:133
GucSource_Names
const char *const GucSource_Names[]
Definition: guc_tables.c:650
ConfigFileName
char * ConfigFileName
Definition: guc_tables.c:541
log_parser_stats
bool log_parser_stats
Definition: guc_tables.c:505
block_size
static int block_size
Definition: guc_tables.c:598
tcp_keepalives_count
int tcp_keepalives_count
Definition: guc_tables.c:550
log_xact_sample_rate
double log_xact_sample_rate
Definition: guc_tables.c:532
DEFAULT_ASSERT_ENABLED
#define DEFAULT_ASSERT_ENABLED
Definition: guc_tables.c:609
shared_memory_options
static const struct config_enum_entry shared_memory_options[]
Definition: guc_tables.c:446
ConfigureNamesInt
struct config_int ConfigureNamesInt[]
Definition: guc_tables.c:2056
huge_pages_status_options
static const struct config_enum_entry huge_pages_status_options[]
Definition: guc_tables.c:374
config_type_names
const char *const config_type_names[]
Definition: guc_tables.c:731
Debug_pretty_print
bool Debug_pretty_print
Definition: guc_tables.c:503
role_string
char * role_string
Definition: guc_tables.c:620
server_encoding_string
static char * server_encoding_string
Definition: guc_tables.c:578
wal_block_size
static int wal_block_size
Definition: guc_tables.c:602
log_statement_options
static const struct config_enum_entry log_statement_options[]
Definition: guc_tables.c:203
plan_cache_mode_options
static const struct config_enum_entry plan_cache_mode_options[]
Definition: guc_tables.c:407
temp_tablespaces
char * temp_tablespaces
Definition: tablespace.c:84
huge_pages
int huge_pages
Definition: guc_tables.c:565
wal_compression_options
static const struct config_enum_entry wal_compression_options[]
Definition: guc_tables.c:467
debug_logical_replication_streaming_options
static const struct config_enum_entry debug_logical_replication_streaming_options[]
Definition: guc_tables.c:429
datestyle_string
static char * datestyle_string
Definition: guc_tables.c:577
recovery_target_timeline_string
static char * recovery_target_timeline_string
Definition: guc_tables.c:613
log_parameter_max_length_on_error
int log_parameter_max_length_on_error
Definition: guc_tables.c:529
dynamic_shared_memory_options
const struct config_enum_entry dynamic_shared_memory_options[]
Definition: dsm_impl.c:95
xmlbinary_options
static const struct config_enum_entry xmlbinary_options[]
Definition: guc_tables.c:268
log_min_duration_statement
int log_min_duration_statement
Definition: guc_tables.c:527
recovery_target_xid_string
static char * recovery_target_xid_string
Definition: guc_tables.c:615
AllowAlterSystem
bool AllowAlterSystem
Definition: guc_tables.c:498
log_min_duration_sample
int log_min_duration_sample
Definition: guc_tables.c:526
log_btree_build_stats
bool log_btree_build_stats
Definition: guc_tables.c:510
log_planner_stats
bool log_planner_stats
Definition: guc_tables.c:506
ConfigureNamesBool
struct config_bool ConfigureNamesBool[]
Definition: guc_tables.c:771
bytea_output_options
static const struct config_enum_entry bytea_output_options[]
Definition: guc_tables.c:120
row_security
bool row_security
Definition: guc_tables.c:513
archive_mode_options
const struct config_enum_entry archive_mode_options[]
Definition: xlog.c:191
huge_pages_options
static const struct config_enum_entry huge_pages_options[]
Definition: guc_tables.c:361
synchronous_commit_options
static const struct config_enum_entry synchronous_commit_options[]
Definition: guc_tables.c:342
recovery_target_string
static char * recovery_target_string
Definition: guc_tables.c:614
cluster_name
char * cluster_name
Definition: guc_tables.c:540
assert_enabled
static bool assert_enabled
Definition: guc_tables.c:611
default_toast_compression_options
static const struct config_enum_entry default_toast_compression_options[]
Definition: guc_tables.c:459
log_timezone_string
static char * log_timezone_string
Definition: guc_tables.c:591
session_authorization_string
static char * session_authorization_string
Definition: guc_tables.c:594
in_hot_standby_guc
bool in_hot_standby_guc
Definition: guc_tables.c:623
Debug_print_rewritten
bool Debug_print_rewritten
Definition: guc_tables.c:502
shared_memory_size_in_huge_pages
static int shared_memory_size_in_huge_pages
Definition: guc_tables.c:601
isolation_level_options
static const struct config_enum_entry isolation_level_options[]
Definition: guc_tables.c:214
log_error_verbosity_options
static const struct config_enum_entry log_error_verbosity_options[]
Definition: guc_tables.c:193
wal_sync_method_options
const struct config_enum_entry wal_sync_method_options[]
Definition: xlog.c:171
server_version_num
static int server_version_num
Definition: guc_tables.c:580
Debug_print_parse
bool Debug_print_parse
Definition: guc_tables.c:501
application_name
char * application_name
Definition: guc_tables.c:546
intervalstyle_options
static const struct config_enum_entry intervalstyle_options[]
Definition: guc_tables.c:166
log_parameter_max_length
int log_parameter_max_length
Definition: guc_tables.c:528
ConfigureNamesReal
struct config_real ConfigureNamesReal[]
Definition: guc_tables.c:3678
IdentFileName
char * IdentFileName
Definition: guc_tables.c:543
wal_level_options
const struct config_enum_entry wal_level_options[]
Definition: xlogdesc.c:27
ConfigureNamesEnum
struct config_enum ConfigureNamesEnum[]
Definition: guc_tables.c:4736
client_message_level_options
static const struct config_enum_entry client_message_level_options[]
Definition: guc_tables.c:134
tcp_user_timeout
int tcp_user_timeout
Definition: guc_tables.c:551
current_role_is_superuser
bool current_role_is_superuser
Definition: guc_tables.c:521
default_tablespace
char * default_tablespace
Definition: tablespace.c:83
constraint_exclusion_options
static const struct config_enum_entry constraint_exclusion_options[]
Definition: guc_tables.c:325
server_message_level_options
static const struct config_enum_entry server_message_level_options[]
Definition: guc_tables.c:149
compute_query_id_options
static const struct config_enum_entry compute_query_id_options[]
Definition: guc_tables.c:307
recovery_target_name_string
static char * recovery_target_name_string
Definition: guc_tables.c:616
huge_page_size
int huge_page_size
Definition: guc_tables.c:566
data_directory
static char * data_directory
Definition: guc_tables.c:593
StaticAssertDecl
StaticAssertDecl(lengthof(bytea_output_options)==(BYTEA_OUTPUT_HEX+2), "array length mismatch")
log_statement_sample_rate
double log_statement_sample_rate
Definition: guc_tables.c:531
backtrace_on_internal_error
bool backtrace_on_internal_error
Definition: guc_tables.c:534
log_duration
bool log_duration
Definition: guc_tables.c:499
config_group_names
const char *const config_group_names[]
Definition: guc_tables.c:674
integer_datetimes
static bool integer_datetimes
Definition: guc_tables.c:604
Log_disconnections
bool Log_disconnections
Definition: postgres.c:93
phony_random_seed
static double phony_random_seed
Definition: guc_tables.c:575
external_pid_file
char * external_pid_file
Definition: guc_tables.c:544
log_temp_files
int log_temp_files
Definition: guc_tables.c:530
log_min_messages
int log_min_messages
Definition: guc_tables.c:524
log_executor_stats
bool log_executor_stats
Definition: guc_tables.c:507
backtrace_functions
char * backtrace_functions
Definition: guc_tables.c:533
shared_memory_size_mb
static int shared_memory_size_mb
Definition: guc_tables.c:600
session_replication_role_options
static const struct config_enum_entry session_replication_role_options[]
Definition: guc_tables.c:222
track_function_options
static const struct config_enum_entry track_function_options[]
Definition: guc_tables.c:248
xmloption_options
static const struct config_enum_entry xmloption_options[]
Definition: guc_tables.c:277
huge_pages_status
int huge_pages_status
Definition: guc_tables.c:567
debug_io_direct_string
static char * debug_io_direct_string
Definition: guc_tables.c:581
guc_tables.h
RESOURCES_KERNEL
@ RESOURCES_KERNEL
Definition: guc_tables.h:65
CLIENT_CONN_LOCALE
@ CLIENT_CONN_LOCALE
Definition: guc_tables.h:92
WAL_ARCHIVE_RECOVERY
@ WAL_ARCHIVE_RECOVERY
Definition: guc_tables.h:73
STATS_CUMULATIVE
@ STATS_CUMULATIVE
Definition: guc_tables.h:89
AUTOVACUUM
@ AUTOVACUUM
Definition: guc_tables.h:90
CLIENT_CONN_PRELOAD
@ CLIENT_CONN_PRELOAD
Definition: guc_tables.h:93
QUERY_TUNING_OTHER
@ QUERY_TUNING_OTHER
Definition: guc_tables.h:83
LOGGING_WHERE
@ LOGGING_WHERE
Definition: guc_tables.h:84
CONN_AUTH_AUTH
@ CONN_AUTH_AUTH
Definition: guc_tables.h:61
ERROR_HANDLING_OPTIONS
@ ERROR_HANDLING_OPTIONS
Definition: guc_tables.h:98
PROCESS_TITLE
@ PROCESS_TITLE
Definition: guc_tables.h:87
RESOURCES_DISK
@ RESOURCES_DISK
Definition: guc_tables.h:64
REPLICATION_SENDING
@ REPLICATION_SENDING
Definition: guc_tables.h:76
LOCK_MANAGEMENT
@ LOCK_MANAGEMENT
Definition: guc_tables.h:95
CUSTOM_OPTIONS
@ CUSTOM_OPTIONS
Definition: guc_tables.h:100
REPLICATION_PRIMARY
@ REPLICATION_PRIMARY
Definition: guc_tables.h:77
STATS_MONITORING
@ STATS_MONITORING
Definition: guc_tables.h:88
WAL_RECOVERY_TARGET
@ WAL_RECOVERY_TARGET
Definition: guc_tables.h:74
WAL_RECOVERY
@ WAL_RECOVERY
Definition: guc_tables.h:72
CONN_AUTH_SSL
@ CONN_AUTH_SSL
Definition: guc_tables.h:62
RESOURCES_MEM
@ RESOURCES_MEM
Definition: guc_tables.h:63
RESOURCES_BGWRITER
@ RESOURCES_BGWRITER
Definition: guc_tables.h:67
PRESET_OPTIONS
@ PRESET_OPTIONS
Definition: guc_tables.h:99
DEVELOPER_OPTIONS
@ DEVELOPER_OPTIONS
Definition: guc_tables.h:101
RESOURCES_VACUUM_DELAY
@ RESOURCES_VACUUM_DELAY
Definition: guc_tables.h:66
QUERY_TUNING_METHOD
@ QUERY_TUNING_METHOD
Definition: guc_tables.h:80
LOGGING_WHAT
@ LOGGING_WHAT
Definition: guc_tables.h:86
RESOURCES_ASYNCHRONOUS
@ RESOURCES_ASYNCHRONOUS
Definition: guc_tables.h:68
QUERY_TUNING_GEQO
@ QUERY_TUNING_GEQO
Definition: guc_tables.h:82
WAL_SETTINGS
@ WAL_SETTINGS
Definition: guc_tables.h:69
COMPAT_OPTIONS_OTHER
@ COMPAT_OPTIONS_OTHER
Definition: guc_tables.h:97
CLIENT_CONN_STATEMENT
@ CLIENT_CONN_STATEMENT
Definition: guc_tables.h:91
FILE_LOCATIONS
@ FILE_LOCATIONS
Definition: guc_tables.h:58
REPLICATION_STANDBY
@ REPLICATION_STANDBY
Definition: guc_tables.h:78
QUERY_TUNING_COST
@ QUERY_TUNING_COST
Definition: guc_tables.h:81
WAL_ARCHIVING
@ WAL_ARCHIVING
Definition: guc_tables.h:71
COMPAT_OPTIONS_PREVIOUS
@ COMPAT_OPTIONS_PREVIOUS
Definition: guc_tables.h:96
WAL_CHECKPOINTS
@ WAL_CHECKPOINTS
Definition: guc_tables.h:70
CLIENT_CONN_OTHER
@ CLIENT_CONN_OTHER
Definition: guc_tables.h:94
LOGGING_WHEN
@ LOGGING_WHEN
Definition: guc_tables.h:85
CONN_AUTH_TCP
@ CONN_AUTH_TCP
Definition: guc_tables.h:60
REPLICATION_SUBSCRIBERS
@ REPLICATION_SUBSCRIBERS
Definition: guc_tables.h:79
WAL_SUMMARIZATION
@ WAL_SUMMARIZATION
Definition: guc_tables.h:75
CONN_AUTH_SETTINGS
@ CONN_AUTH_SETTINGS
Definition: guc_tables.h:59
UNGROUPED
@ UNGROUPED
Definition: guc_tables.h:57
PGC_BOOL
@ PGC_BOOL
Definition: guc_tables.h:25
PGC_STRING
@ PGC_STRING
Definition: guc_tables.h:28
PGC_ENUM
@ PGC_ENUM
Definition: guc_tables.h:29
PGC_REAL
@ PGC_REAL
Definition: guc_tables.h:27
PGC_INT
@ PGC_INT
Definition: guc_tables.h:26
join_collapse_limit
int join_collapse_limit
Definition: initsplan.c:39
from_collapse_limit
int from_collapse_limit
Definition: initsplan.c:38
lo_compat_privileges
bool lo_compat_privileges
Definition: inv_api.c:57
debug_discard_caches
int debug_discard_caches
Definition: inval.c:240
shared_memory_type
int shared_memory_type
Definition: ipci.c:57
jit_optimize_above_cost
double jit_optimize_above_cost
Definition: jit.c:41
jit_dump_bitcode
bool jit_dump_bitcode
Definition: jit.c:35
jit_enabled
bool jit_enabled
Definition: jit.c:32
jit_provider
char * jit_provider
Definition: jit.c:33
jit_expressions
bool jit_expressions
Definition: jit.c:36
jit_tuple_deforming
bool jit_tuple_deforming
Definition: jit.c:38
jit_above_cost
double jit_above_cost
Definition: jit.c:39
jit_inline_above_cost
double jit_inline_above_cost
Definition: jit.c:40
jit_profiling_support
bool jit_profiling_support
Definition: jit.c:37
jit_debugging_support
bool jit_debugging_support
Definition: jit.c:34
large_object.h
max_logical_replication_workers
int max_logical_replication_workers
Definition: launcher.c:50
max_sync_workers_per_subscription
int max_sync_workers_per_subscription
Definition: launcher.c:51
max_parallel_apply_workers_per_subscription
int max_parallel_apply_workers_per_subscription
Definition: launcher.c:52
PG_TLS1_VERSION
@ PG_TLS1_VERSION
Definition: libpq.h:129
PG_TLS1_3_VERSION
@ PG_TLS1_3_VERSION
Definition: libpq.h:132
PG_TLS1_1_VERSION
@ PG_TLS1_1_VERSION
Definition: libpq.h:130
PG_TLS1_2_VERSION
@ PG_TLS1_2_VERSION
Definition: libpq.h:131
PG_TLS_ANY
@ PG_TLS_ANY
Definition: libpq.h:128
check_temp_buffers
bool check_temp_buffers(int *newval, void **extra, GucSource source)
Definition: localbuf.c:704
max_locks_per_xact
int max_locks_per_xact
Definition: lock.c:53
MaxAllocSize
#define MaxAllocSize
Definition: memutils.h:40
INTSTYLE_SQL_STANDARD
#define INTSTYLE_SQL_STANDARD
Definition: miscadmin.h:257
INTSTYLE_POSTGRES_VERBOSE
#define INTSTYLE_POSTGRES_VERBOSE
Definition: miscadmin.h:256
MAX_BAS_VAC_RING_SIZE_KB
#define MAX_BAS_VAC_RING_SIZE_KB
Definition: miscadmin.h:277
INTSTYLE_ISO_8601
#define INTSTYLE_ISO_8601
Definition: miscadmin.h:258
INTSTYLE_POSTGRES
#define INTSTYLE_POSTGRES
Definition: miscadmin.h:255
IgnoreSystemIndexes
bool IgnoreSystemIndexes
Definition: miscinit.c:80
shared_preload_libraries_string
char * shared_preload_libraries_string
Definition: miscinit.c:1774
session_preload_libraries_string
char * session_preload_libraries_string
Definition: miscinit.c:1773
local_preload_libraries_string
char * local_preload_libraries_string
Definition: miscinit.c:1775
check_multixact_offset_buffers
bool check_multixact_offset_buffers(int *newval, void **extra, GucSource source)
Definition: multixact.c:1965
check_multixact_member_buffers
bool check_multixact_member_buffers(int *newval, void **extra, GucSource source)
Definition: multixact.c:1974
assign_search_path
void assign_search_path(const char *newval, void *extra)
Definition: namespace.c:4698
namespace_search_path
char * namespace_search_path
Definition: namespace.c:211
check_search_path
bool check_search_path(char **newval, void **extra, GucSource source)
Definition: namespace.c:4642
DEBUG_PARALLEL_REGRESS
@ DEBUG_PARALLEL_REGRESS
Definition: optimizer.h:108
DEBUG_PARALLEL_ON
@ DEBUG_PARALLEL_ON
Definition: optimizer.h:107
DEBUG_PARALLEL_OFF
@ DEBUG_PARALLEL_OFF
Definition: optimizer.h:106
Transform_null_equals
bool Transform_null_equals
Definition: parse_expr.c:46
parse_expr.h
escape_string_warning
PGDLLIMPORT bool escape_string_warning
standard_conforming_strings
PGDLLIMPORT bool standard_conforming_strings
BACKSLASH_QUOTE_ON
@ BACKSLASH_QUOTE_ON
Definition: parser.h:51
BACKSLASH_QUOTE_SAFE_ENCODING
@ BACKSLASH_QUOTE_SAFE_ENCODING
Definition: parser.h:52
BACKSLASH_QUOTE_OFF
@ BACKSLASH_QUOTE_OFF
Definition: parser.h:50
backslash_quote
PGDLLIMPORT int backslash_quote
enable_group_by_reordering
bool enable_group_by_reordering
Definition: pathkeys.c:31
WRITEBACK_MAX_PENDING_FLUSHES
#define WRITEBACK_MAX_PENDING_FLUSHES
Definition: pg_config_manual.h:181
INDEX_MAX_KEYS
#define INDEX_MAX_KEYS
Definition: pg_config_manual.h:69
NAMEDATALEN
#define NAMEDATALEN
Definition: pg_config_manual.h:29
DEFAULT_PGSOCKET_DIR
#define DEFAULT_PGSOCKET_DIR
Definition: pg_config_manual.h:209
DEFAULT_XLOG_SEG_SIZE
#define DEFAULT_XLOG_SEG_SIZE
Definition: pg_config_manual.h:20
DEFAULT_EVENT_SOURCE
#define DEFAULT_EVENT_SOURCE
Definition: pg_config_manual.h:217
DEFAULT_BACKEND_FLUSH_AFTER
#define DEFAULT_BACKEND_FLUSH_AFTER
Definition: pg_config_manual.h:176
DEFAULT_CHECKPOINT_FLUSH_AFTER
#define DEFAULT_CHECKPOINT_FLUSH_AFTER
Definition: pg_config_manual.h:178
FUNC_MAX_ARGS
#define FUNC_MAX_ARGS
Definition: pg_config_manual.h:43
DEFAULT_BGWRITER_FLUSH_AFTER
#define DEFAULT_BGWRITER_FLUSH_AFTER
Definition: pg_config_manual.h:177
icu_validation_level
int icu_validation_level
Definition: pg_locale.c:102
assign_locale_time
void assign_locale_time(const char *newval, void *extra)
Definition: pg_locale.c:388
check_locale_time
bool check_locale_time(char **newval, void **extra, GucSource source)
Definition: pg_locale.c:382
locale_messages
char * locale_messages
Definition: pg_locale.c:97
locale_numeric
char * locale_numeric
Definition: pg_locale.c:99
locale_time
char * locale_time
Definition: pg_locale.c:100
check_locale_numeric
bool check_locale_numeric(char **newval, void **extra, GucSource source)
Definition: pg_locale.c:370
assign_locale_numeric
void assign_locale_numeric(const char *newval, void *extra)
Definition: pg_locale.c:376
check_locale_messages
bool check_locale_messages(char **newval, void **extra, GucSource source)
Definition: pg_locale.c:404
assign_locale_messages
void assign_locale_messages(const char *newval, void *extra)
Definition: pg_locale.c:427
assign_locale_monetary
void assign_locale_monetary(const char *newval, void *extra)
Definition: pg_locale.c:364
locale_monetary
char * locale_monetary
Definition: pg_locale.c:98
check_locale_monetary
bool check_locale_monetary(char **newval, void **extra, GucSource source)
Definition: pg_locale.c:358
pg_locale.h
pg_shmem.h
HUGE_PAGES_UNKNOWN
@ HUGE_PAGES_UNKNOWN
Definition: pg_shmem.h:55
HUGE_PAGES_ON
@ HUGE_PAGES_ON
Definition: pg_shmem.h:53
HUGE_PAGES_OFF
@ HUGE_PAGES_OFF
Definition: pg_shmem.h:52
HUGE_PAGES_TRY
@ HUGE_PAGES_TRY
Definition: pg_shmem.h:54
DEFAULT_SHARED_MEMORY_TYPE
#define DEFAULT_SHARED_MEMORY_TYPE
Definition: pg_shmem.h:75
SHMEM_TYPE_MMAP
@ SHMEM_TYPE_MMAP
Definition: pg_shmem.h:63
SHMEM_TYPE_SYSV
@ SHMEM_TYPE_SYSV
Definition: pg_shmem.h:62
SHMEM_TYPE_WINDOWS
@ SHMEM_TYPE_WINDOWS
Definition: pg_shmem.h:61
XLogArchiveLibrary
char * XLogArchiveLibrary
Definition: pgarch.c:92
pgstat_fetch_consistency
int pgstat_fetch_consistency
Definition: pgstat.c:185
pgstat_track_counts
bool pgstat_track_counts
Definition: pgstat.c:184
assign_stats_fetch_consistency
void assign_stats_fetch_consistency(int newval, void *extra)
Definition: pgstat.c:1707
PGSTAT_FETCH_CONSISTENCY_NONE
@ PGSTAT_FETCH_CONSISTENCY_NONE
Definition: pgstat.h:70
PGSTAT_FETCH_CONSISTENCY_CACHE
@ PGSTAT_FETCH_CONSISTENCY_CACHE
Definition: pgstat.h:71
PGSTAT_FETCH_CONSISTENCY_SNAPSHOT
@ PGSTAT_FETCH_CONSISTENCY_SNAPSHOT
Definition: pgstat.h:72
TRACK_FUNC_PL
@ TRACK_FUNC_PL
Definition: pgstat.h:64
TRACK_FUNC_ALL
@ TRACK_FUNC_ALL
Definition: pgstat.h:65
TRACK_FUNC_OFF
@ TRACK_FUNC_OFF
Definition: pgstat.h:63
pgstat_track_functions
int pgstat_track_functions
Definition: pgstat_function.c:30
plan_cache_mode
int plan_cache_mode
Definition: plancache.c:147
PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN
@ PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN
Definition: plancache.h:34
PLAN_CACHE_MODE_FORCE_GENERIC_PLAN
@ PLAN_CACHE_MODE_FORCE_GENERIC_PLAN
Definition: plancache.h:33
PLAN_CACHE_MODE_AUTO
@ PLAN_CACHE_MODE_AUTO
Definition: plancache.h:32
constraint_exclusion
int constraint_exclusion
Definition: plancat.c:56
DEFAULT_CURSOR_TUPLE_FRACTION
#define DEFAULT_CURSOR_TUPLE_FRACTION
Definition: planmain.h:21
cursor_tuple_fraction
double cursor_tuple_fraction
Definition: planner.c:66
parallel_leader_participation
bool parallel_leader_participation
Definition: planner.c:68
debug_parallel_query
int debug_parallel_query
Definition: planner.c:67
log_statement
int log_statement
Definition: postgres.c:95
assign_transaction_timeout
void assign_transaction_timeout(int newval, void *extra)
Definition: postgres.c:3656
PostAuthDelay
int PostAuthDelay
Definition: postgres.c:101
max_stack_depth
int max_stack_depth
Definition: postgres.c:98
check_max_stack_depth
bool check_max_stack_depth(int *newval, void **extra, GucSource source)
Definition: postgres.c:3578
client_connection_check_interval
int client_connection_check_interval
Definition: postgres.c:104
check_log_stats
bool check_log_stats(bool *newval, void **extra, GucSource source)
Definition: postgres.c:3641
assign_max_stack_depth
void assign_max_stack_depth(int newval, void *extra)
Definition: postgres.c:3595
check_client_connection_check_interval
bool check_client_connection_check_interval(int *newval, void **extra, GucSource source)
Definition: postgres.c:3606
check_stage_log_stats
bool check_stage_log_stats(bool *newval, void **extra, GucSource source)
Definition: postgres.c:3627
check_autovacuum_max_workers
bool check_autovacuum_max_workers(int *newval, void **extra, GucSource source)
Definition: postinit.c:604
check_max_connections
bool check_max_connections(int *newval, void **extra, GucSource source)
Definition: postinit.c:592
check_max_wal_senders
bool check_max_wal_senders(int *newval, void **extra, GucSource source)
Definition: postinit.c:628
check_max_worker_processes
bool check_max_worker_processes(int *newval, void **extra, GucSource source)
Definition: postinit.c:616
PreAuthDelay
int PreAuthDelay
Definition: postmaster.c:227
send_abort_for_kill
bool send_abort_for_kill
Definition: postmaster.c:238
PostPortNumber
int PostPortNumber
Definition: postmaster.c:190
log_hostname
bool log_hostname
Definition: postmaster.c:230
remove_temp_files_after_crash
bool remove_temp_files_after_crash
Definition: postmaster.c:236
enable_bonjour
bool enable_bonjour
Definition: postmaster.c:233
restart_after_crash
bool restart_after_crash
Definition: postmaster.c:235
Log_connections
bool Log_connections
Definition: postmaster.c:231
ReservedConnections
int ReservedConnections
Definition: postmaster.c:217
Unix_socket_directories
char * Unix_socket_directories
Definition: postmaster.c:193
send_abort_for_crash
bool send_abort_for_crash
Definition: postmaster.c:237
AuthenticationTimeout
int AuthenticationTimeout
Definition: postmaster.c:228
EnableSSL
bool EnableSSL
Definition: postmaster.c:225
ListenAddresses
char * ListenAddresses
Definition: postmaster.c:196
SuperuserReservedConnections
int SuperuserReservedConnections
Definition: postmaster.c:216
bonjour_name
char * bonjour_name
Definition: postmaster.c:234
MAX_BACKENDS
#define MAX_BACKENDS
Definition: postmaster.h:95
assign_tcp_keepalives_count
void assign_tcp_keepalives_count(int newval, void *extra)
Definition: pqcomm.c:2007
Unix_socket_permissions
int Unix_socket_permissions
Definition: pqcomm.c:105
show_tcp_keepalives_interval
const char * show_tcp_keepalives_interval(void)
Definition: pqcomm.c:1994
Unix_socket_group
char * Unix_socket_group
Definition: pqcomm.c:106
show_tcp_user_timeout
const char * show_tcp_user_timeout(void)
Definition: pqcomm.c:2040
assign_tcp_keepalives_idle
void assign_tcp_keepalives_idle(int newval, void *extra)
Definition: pqcomm.c:1951
assign_tcp_user_timeout
void assign_tcp_user_timeout(int newval, void *extra)
Definition: pqcomm.c:2030
show_tcp_keepalives_idle
const char * show_tcp_keepalives_idle(void)
Definition: pqcomm.c:1971
show_tcp_keepalives_count
const char * show_tcp_keepalives_count(void)
Definition: pqcomm.c:2017
assign_tcp_keepalives_interval
void assign_tcp_keepalives_interval(int newval, void *extra)
Definition: pqcomm.c:1984
max_predicate_locks_per_page
int max_predicate_locks_per_page
Definition: predicate.c:373
max_predicate_locks_per_relation
int max_predicate_locks_per_relation
Definition: predicate.c:372
check_serial_buffers
bool check_serial_buffers(int *newval, void **extra, GucSource source)
Definition: predicate.c:847
max_predicate_locks_per_xact
int max_predicate_locks_per_xact
Definition: predicate.c:371
XMLOPTION_CONTENT
@ XMLOPTION_CONTENT
Definition: primnodes.h:1563
XMLOPTION_DOCUMENT
@ XMLOPTION_DOCUMENT
Definition: primnodes.h:1562
update_process_title
bool update_process_title
Definition: ps_status.c:29
ps_status.h
DEFAULT_UPDATE_PROCESS_TITLE
#define DEFAULT_UPDATE_PROCESS_TITLE
Definition: ps_status.h:19
COMPUTE_QUERY_ID_AUTO
@ COMPUTE_QUERY_ID_AUTO
Definition: queryjumble.h:58
COMPUTE_QUERY_ID_REGRESS
@ COMPUTE_QUERY_ID_REGRESS
Definition: queryjumble.h:59
COMPUTE_QUERY_ID_ON
@ COMPUTE_QUERY_ID_ON
Definition: queryjumble.h:57
COMPUTE_QUERY_ID_OFF
@ COMPUTE_QUERY_ID_OFF
Definition: queryjumble.h:56
compute_query_id
int compute_query_id
Definition: queryjumblefuncs.c:43
logical_decoding_work_mem
int logical_decoding_work_mem
Definition: reorderbuffer.c:212
debug_logical_replication_streaming
int debug_logical_replication_streaming
Definition: reorderbuffer.c:216
DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE
@ DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE
Definition: reorderbuffer.h:29
DEBUG_LOGICAL_REP_STREAMING_BUFFERED
@ DEBUG_LOGICAL_REP_STREAMING_BUFFERED
Definition: reorderbuffer.h:28
quote_all_identifiers
bool quote_all_identifiers
Definition: ruleutils.c:323
SCRAM_SHA_256_DEFAULT_ITERATIONS
#define SCRAM_SHA_256_DEFAULT_ITERATIONS
Definition: scram-common.h:50
standby_slot_names
char * standby_slot_names
Definition: slot.c:148
max_replication_slots
int max_replication_slots
Definition: slot.c:141
assign_standby_slot_names
void assign_standby_slot_names(const char *newval, void *extra)
Definition: slot.c:2534
check_standby_slot_names
bool check_standby_slot_names(char **newval, void **extra, GucSource source)
Definition: slot.c:2480
sync_replication_slots
bool sync_replication_slots
Definition: slotsync.c:109
SLRU_MAX_ALLOWED_BUFFERS
#define SLRU_MAX_ALLOWED_BUFFERS
Definition: slru.h:24
log_lock_waits
bool log_lock_waits
Definition: proc.c:63
IdleSessionTimeout
int IdleSessionTimeout
Definition: proc.c:62
StatementTimeout
int StatementTimeout
Definition: proc.c:58
IdleInTransactionSessionTimeout
int IdleInTransactionSessionTimeout
Definition: proc.c:60
DeadlockTimeout
int DeadlockTimeout
Definition: proc.c:57
TransactionTimeout
int TransactionTimeout
Definition: proc.c:61
LockTimeout
int LockTimeout
Definition: proc.c:59
log_recovery_conflict_waits
bool log_recovery_conflict_waits
Definition: standby.c:41
max_standby_archive_delay
int max_standby_archive_delay
Definition: standby.c:39
max_standby_streaming_delay
int max_standby_streaming_delay
Definition: standby.c:40
wal_skip_threshold
int wal_skip_threshold
Definition: storage.c:39
config_bool
Definition: guc_tables.h:199
config_enum_entry
Definition: guc.h:170
config_enum
Definition: guc_tables.h:269
config_int
Definition: guc_tables.h:213
config_real
Definition: guc_tables.h:229
config_string
Definition: guc_tables.h:255
check_subtrans_buffers
bool check_subtrans_buffers(int *newval, void **extra, GucSource source)
Definition: subtrans.c:254
assign_synchronous_commit
void assign_synchronous_commit(int newval, void *extra)
Definition: syncrep.c:1054
assign_synchronous_standby_names
void assign_synchronous_standby_names(const char *newval, void *extra)
Definition: syncrep.c:1048
SyncRepStandbyNames
char * SyncRepStandbyNames
Definition: syncrep.c:90
check_synchronous_standby_names
bool check_synchronous_standby_names(char **newval, void **extra, GucSource source)
Definition: syncrep.c:991
Log_truncate_on_rotation
bool Log_truncate_on_rotation
Definition: syslogger.c:75
Log_directory
char * Log_directory
Definition: syslogger.c:73
Log_RotationAge
int Log_RotationAge
Definition: syslogger.c:71
Log_filename
char * Log_filename
Definition: syslogger.c:74
Logging_collector
bool Logging_collector
Definition: syslogger.c:70
Log_RotationSize
int Log_RotationSize
Definition: syslogger.c:72
Log_file_mode
int Log_file_mode
Definition: syslogger.c:76
check_huge_page_size
bool check_huge_page_size(int *newval, void **extra, GucSource source)
Definition: sysv_shmem.c:578
default_table_access_method
char * default_table_access_method
Definition: tableam.c:48
synchronize_seqscans
bool synchronize_seqscans
Definition: tableam.c:49
DEFAULT_TABLE_ACCESS_METHOD
#define DEFAULT_TABLE_ACCESS_METHOD
Definition: tableam.h:29
check_default_table_access_method
bool check_default_table_access_method(char **newval, void **extra, GucSource source)
Definition: tableamapi.c:105
LOGSTMT_NONE
@ LOGSTMT_NONE
Definition: tcopprot.h:37
LOGSTMT_MOD
@ LOGSTMT_MOD
Definition: tcopprot.h:39
LOGSTMT_DDL
@ LOGSTMT_DDL
Definition: tcopprot.h:38
LOGSTMT_ALL
@ LOGSTMT_ALL
Definition: tcopprot.h:40
default_toast_compression
int default_toast_compression
Definition: toast_compression.c:26
toast_compression.h
TOAST_PGLZ_COMPRESSION
#define TOAST_PGLZ_COMPRESSION
Definition: toast_compression.h:49
TOAST_LZ4_COMPRESSION
#define TOAST_LZ4_COMPRESSION
Definition: toast_compression.h:50
FirstNormalObjectId
#define FirstNormalObjectId
Definition: transam.h:197
SessionReplicationRole
int SessionReplicationRole
Definition: trigger.c:63
assign_session_replication_role
void assign_session_replication_role(int newval, void *extra)
Definition: trigger.c:6579
SESSION_REPLICATION_ROLE_REPLICA
#define SESSION_REPLICATION_ROLE_REPLICA
Definition: trigger.h:141
SESSION_REPLICATION_ROLE_LOCAL
#define SESSION_REPLICATION_ROLE_LOCAL
Definition: trigger.h:142
SESSION_REPLICATION_ROLE_ORIGIN
#define SESSION_REPLICATION_ROLE_ORIGIN
Definition: trigger.h:140
check_default_text_search_config
bool check_default_text_search_config(char **newval, void **extra, GucSource source)
Definition: ts_cache.c:602
TSCurrentConfig
char * TSCurrentConfig
Definition: ts_cache.c:76
assign_default_text_search_config
void assign_default_text_search_config(const char *newval, void *extra)
Definition: ts_cache.c:670
ts_cache.h
trace_sort
bool trace_sort
Definition: tuplesort.c:124
max_prepared_xacts
int max_prepared_xacts
Definition: twophase.c:115
vacuum_freeze_min_age
int vacuum_freeze_min_age
Definition: vacuum.c:67
check_vacuum_buffer_usage_limit
bool check_vacuum_buffer_usage_limit(int *newval, void **extra, GucSource source)
Definition: vacuum.c:125
vacuum_multixact_freeze_table_age
int vacuum_multixact_freeze_table_age
Definition: vacuum.c:70
vacuum_freeze_table_age
int vacuum_freeze_table_age
Definition: vacuum.c:68
vacuum_multixact_failsafe_age
int vacuum_multixact_failsafe_age
Definition: vacuum.c:72
vacuum_multixact_freeze_min_age
int vacuum_multixact_freeze_min_age
Definition: vacuum.c:69
vacuum_failsafe_age
int vacuum_failsafe_age
Definition: vacuum.c:71
MAX_STATISTICS_TARGET
#define MAX_STATISTICS_TARGET
Definition: vacuum.h:305
bytea_output
int bytea_output
Definition: varlena.c:48
hot_standby_feedback
bool hot_standby_feedback
Definition: walreceiver.c:89
wal_receiver_status_interval
int wal_receiver_status_interval
Definition: walreceiver.c:87
wal_receiver_timeout
int wal_receiver_timeout
Definition: walreceiver.c:88
max_wal_senders
int max_wal_senders
Definition: walsender.c:121
log_replication_commands
bool log_replication_commands
Definition: walsender.c:125
wal_sender_timeout
int wal_sender_timeout
Definition: walsender.c:123
summarize_wal
bool summarize_wal
Definition: walsummarizer.c:142
wal_summary_keep_time
int wal_summary_keep_time
Definition: walsummarizer.c:143
WalWriterFlushAfter
int WalWriterFlushAfter
Definition: walwriter.c:72
WalWriterDelay
int WalWriterDelay
Definition: walwriter.c:71
DEFAULT_WAL_WRITER_FLUSH_AFTER
#define DEFAULT_WAL_WRITER_FLUSH_AFTER
Definition: walwriter.h:15
synchronous_commit
int synchronous_commit
Definition: xact.c:85
XactDeferrable
bool XactDeferrable
Definition: xact.c:83
DefaultXactDeferrable
bool DefaultXactDeferrable
Definition: xact.c:82
XactReadOnly
bool XactReadOnly
Definition: xact.c:80
XactIsoLevel
int XactIsoLevel
Definition: xact.c:77
DefaultXactIsoLevel
int DefaultXactIsoLevel
Definition: xact.c:76
DefaultXactReadOnly
bool DefaultXactReadOnly
Definition: xact.c:79
XACT_SERIALIZABLE
#define XACT_SERIALIZABLE
Definition: xact.h:39
SYNCHRONOUS_COMMIT_LOCAL_FLUSH
@ SYNCHRONOUS_COMMIT_LOCAL_FLUSH
Definition: xact.h:71
SYNCHRONOUS_COMMIT_REMOTE_WRITE
@ SYNCHRONOUS_COMMIT_REMOTE_WRITE
Definition: xact.h:72
SYNCHRONOUS_COMMIT_REMOTE_APPLY
@ SYNCHRONOUS_COMMIT_REMOTE_APPLY
Definition: xact.h:75
SYNCHRONOUS_COMMIT_OFF
@ SYNCHRONOUS_COMMIT_OFF
Definition: xact.h:70
SYNCHRONOUS_COMMIT_ON
#define SYNCHRONOUS_COMMIT_ON
Definition: xact.h:80
XACT_READ_UNCOMMITTED
#define XACT_READ_UNCOMMITTED
Definition: xact.h:36
XACT_REPEATABLE_READ
#define XACT_REPEATABLE_READ
Definition: xact.h:38
XACT_READ_COMMITTED
#define XACT_READ_COMMITTED
Definition: xact.h:37
assign_wal_sync_method
void assign_wal_sync_method(int new_wal_sync_method, void *extra)
Definition: xlog.c:8561
wal_decode_buffer_size
int wal_decode_buffer_size
Definition: xlog.c:136
fullPageWrites
bool fullPageWrites
Definition: xlog.c:122
check_max_slot_wal_keep_size
bool check_max_slot_wal_keep_size(int *newval, void **extra, GucSource source)
Definition: xlog.c:2218
show_in_hot_standby
const char * show_in_hot_standby(void)
Definition: xlog.c:4789
XLogArchiveCommand
char * XLogArchiveCommand
Definition: xlog.c:120
wal_keep_size_mb
int wal_keep_size_mb
Definition: xlog.c:116
EnableHotStandby
bool EnableHotStandby
Definition: xlog.c:121
assign_wal_consistency_checking
void assign_wal_consistency_checking(const char *newval, void *extra)
Definition: xlog.c:4724
wal_init_zero
bool wal_init_zero
Definition: xlog.c:127
XLogArchiveMode
int XLogArchiveMode
Definition: xlog.c:119
wal_level
int wal_level
Definition: xlog.c:131
assign_checkpoint_completion_target
void assign_checkpoint_completion_target(double newval, void *extra)
Definition: xlog.c:2193
wal_segment_size
int wal_segment_size
Definition: xlog.c:143
max_wal_size_mb
int max_wal_size_mb
Definition: xlog.c:114
XLogArchiveTimeout
int XLogArchiveTimeout
Definition: xlog.c:118
wal_recycle
bool wal_recycle
Definition: xlog.c:128
wal_consistency_checking_string
char * wal_consistency_checking_string
Definition: xlog.c:125
wal_log_hints
bool wal_log_hints
Definition: xlog.c:123
wal_sync_method
int wal_sync_method
Definition: xlog.c:130
max_slot_wal_keep_size_mb
int max_slot_wal_keep_size_mb
Definition: xlog.c:135
log_checkpoints
bool log_checkpoints
Definition: xlog.c:129
assign_max_wal_size
void assign_max_wal_size(int newval, void *extra)
Definition: xlog.c:2186
wal_compression
int wal_compression
Definition: xlog.c:124
wal_retrieve_retry_interval
int wal_retrieve_retry_interval
Definition: xlog.c:134
XLOGbuffers
int XLOGbuffers
Definition: xlog.c:117
track_wal_io_timing
bool track_wal_io_timing
Definition: xlog.c:137
show_archive_command
const char * show_archive_command(void)
Definition: xlog.c:4777
check_wal_segment_size
bool check_wal_segment_size(int *newval, void **extra, GucSource source)
Definition: xlog.c:2200
check_wal_consistency_checking
bool check_wal_consistency_checking(char **newval, void **extra, GucSource source)
Definition: xlog.c:4639
min_wal_size_mb
int min_wal_size_mb
Definition: xlog.c:115
check_wal_buffers
bool check_wal_buffers(int *newval, void **extra, GucSource source)
Definition: xlog.c:4604
ARCHIVE_MODE_OFF
@ ARCHIVE_MODE_OFF
Definition: xlog.h:63
WAL_COMPRESSION_NONE
@ WAL_COMPRESSION_NONE
Definition: xlog.h:80
WAL_COMPRESSION_LZ4
@ WAL_COMPRESSION_LZ4
Definition: xlog.h:82
WAL_COMPRESSION_PGLZ
@ WAL_COMPRESSION_PGLZ
Definition: xlog.h:81
WAL_COMPRESSION_ZSTD
@ WAL_COMPRESSION_ZSTD
Definition: xlog.h:83
WAL_LEVEL_REPLICA
@ WAL_LEVEL_REPLICA
Definition: xlog.h:73
xlog_internal.h
RECOVERY_TARGET_ACTION_PAUSE
@ RECOVERY_TARGET_ACTION_PAUSE
Definition: xlog_internal.h:323
WalSegMinSize
#define WalSegMinSize
Definition: xlog_internal.h:88
DEFAULT_MAX_WAL_SEGS
#define DEFAULT_MAX_WAL_SEGS
Definition: xlog_internal.h:92
WalSegMaxSize
#define WalSegMaxSize
Definition: xlog_internal.h:89
DEFAULT_MIN_WAL_SEGS
#define DEFAULT_MIN_WAL_SEGS
Definition: xlog_internal.h:91
DEFAULT_WAL_SYNC_METHOD
#define DEFAULT_WAL_SYNC_METHOD
Definition: xlogdefs.h:79
recovery_prefetch
int recovery_prefetch
Definition: xlogprefetcher.c:68
assign_recovery_prefetch
void assign_recovery_prefetch(int new_value, void *extra)
Definition: xlogprefetcher.c:1097
check_recovery_prefetch
bool check_recovery_prefetch(int *new_value, void **extra, GucSource source)
Definition: xlogprefetcher.c:1083
RECOVERY_PREFETCH_OFF
@ RECOVERY_PREFETCH_OFF
Definition: xlogprefetcher.h:26
RECOVERY_PREFETCH_ON
@ RECOVERY_PREFETCH_ON
Definition: xlogprefetcher.h:27
RECOVERY_PREFETCH_TRY
@ RECOVERY_PREFETCH_TRY
Definition: xlogprefetcher.h:28
check_primary_slot_name
bool check_primary_slot_name(char **newval, void **extra, GucSource source)
Definition: xlogrecovery.c:4740
assign_recovery_target_xid
void assign_recovery_target_xid(const char *newval, void *extra)
Definition: xlogrecovery.c:5034
recovery_min_apply_delay
int recovery_min_apply_delay
Definition: xlogrecovery.c:93
check_recovery_target
bool check_recovery_target(char **newval, void **extra, GucSource source)
Definition: xlogrecovery.c:4781
recoveryTargetAction
int recoveryTargetAction
Definition: xlogrecovery.c:87
check_recovery_target_timeline
bool check_recovery_target_timeline(char **newval, void **extra, GucSource source)
Definition: xlogrecovery.c:4965
PrimarySlotName
char * PrimarySlotName
Definition: xlogrecovery.c:97
recoveryRestoreCommand
char * recoveryRestoreCommand
Definition: xlogrecovery.c:82
assign_recovery_target
void assign_recovery_target(const char *newval, void *extra)
Definition: xlogrecovery.c:4795
archiveCleanupCommand
char * archiveCleanupCommand
Definition: xlogrecovery.c:84
recovery_target_time_string
char * recovery_target_time_string
Definition: xlogrecovery.c:89
assign_recovery_target_name
void assign_recovery_target_name(const char *newval, void *extra)
Definition: xlogrecovery.c:4869
assign_recovery_target_time
void assign_recovery_target_time(const char *newval, void *extra)
Definition: xlogrecovery.c:4949
check_recovery_target_xid
bool check_recovery_target_xid(char **newval, void **extra, GucSource source)
Definition: xlogrecovery.c:5011
check_recovery_target_time
bool check_recovery_target_time(char **newval, void **extra, GucSource source)
Definition: xlogrecovery.c:4894
wal_receiver_create_temp_slot
bool wal_receiver_create_temp_slot
Definition: xlogrecovery.c:98
recoveryEndCommand
char * recoveryEndCommand
Definition: xlogrecovery.c:83
assign_recovery_target_lsn
void assign_recovery_target_lsn(const char *newval, void *extra)
Definition: xlogrecovery.c:4834
check_recovery_target_lsn
bool check_recovery_target_lsn(char **newval, void **extra, GucSource source)
Definition: xlogrecovery.c:4811
PrimaryConnInfo
char * PrimaryConnInfo
Definition: xlogrecovery.c:96
check_recovery_target_name
bool check_recovery_target_name(char **newval, void **extra, GucSource source)
Definition: xlogrecovery.c:4853
recoveryTargetInclusive
bool recoveryTargetInclusive
Definition: xlogrecovery.c:86
assign_recovery_target_timeline
void assign_recovery_target_timeline(const char *newval, void *extra)
Definition: xlogrecovery.c:4998
xmlbinary
int xmlbinary
Definition: xml.c:109
xmloption
int xmloption
Definition: xml.c:110
XMLBINARY_BASE64
@ XMLBINARY_BASE64
Definition: xml.h:35
XMLBINARY_HEX
@ XMLBINARY_HEX
Definition: xml.h:36