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