=== Applying patches on top of PostgreSQL commit ID 7a662a46ebf74e9fa15cb62b592b4bf00c96fc94 === /etc/rc.d/jail: WARNING: Per-jail configuration via jail_* variables is obsolete. Please consider migrating to /etc/jail.conf. Mon Oct 13 04:53:26 UTC 2025 On branch cf/6105 nothing to commit, working tree clean === using 'git am' to apply patch ./v1-0001-Modernize-some-for-loops.patch === Applying: Modernize some for loops === using 'git am' to apply patch ./v1-0002-Add-some-const-qualifiers.patch === Applying: Add some const qualifiers === using 'git am' to apply patch ./v1-0003-Change-reset_extra-into-a-config_generic-common-f.patch === Applying: Change reset_extra into a config_generic common field === using 'git am' to apply patch ./v1-0004-Use-designated-initializers-for-guc_tables.patch === Applying: Use designated initializers for guc_tables === using 'git am' to apply patch ./v1-0005-Change-config_generic.vartype-to-be-initialized-a.patch === Applying: Change config_generic.vartype to be initialized at compile time === using 'git am' to apply patch ./v1-0006-Reorganize-GUC-structs.patch === Applying: Reorganize GUC structs === using 'git am' to apply patch ./v1-0007-Sort-guc_parameters.dat-alphabetically-by-name.patch === Applying: Sort guc_parameters.dat alphabetically by name Using index info to reconstruct a base tree... M src/backend/utils/misc/guc_parameters.dat Falling back to patching base and 3-way merge... Auto-merging src/backend/utils/misc/guc_parameters.dat CONFLICT (content): Merge conflict in src/backend/utils/misc/guc_parameters.dat error: Failed to merge in the changes. hint: Use 'git am --show-current-patch=diff' to see the failed patch Patch failed at 0001 Sort guc_parameters.dat alphabetically by name When you have resolved this problem, run "git am --continue". If you prefer to skip this patch, run "git am --skip" instead. To restore the original branch and stop patching, run "git am --abort". Unstaged changes after reset: M src/backend/utils/misc/guc_parameters.dat === using patch(1) to apply patch ./v1-0007-Sort-guc_parameters.dat-alphabetically-by-name.patch === patching file src/backend/utils/misc/guc_parameters.dat Hunk #1 FAILED at 33. Hunk #2 succeeded at 623 (offset 7 lines). Hunk #3 succeeded at 648 (offset 7 lines). Hunk #4 succeeded at 872 (offset 7 lines). Hunk #5 succeeded at 920 (offset 7 lines). Hunk #6 succeeded at 951 (offset 7 lines). Hunk #7 succeeded at 1536 (offset 7 lines). Hunk #8 succeeded at 1572 (offset 7 lines). Hunk #9 succeeded at 1733 (offset 7 lines). Hunk #10 succeeded at 1758 (offset 7 lines). Hunk #11 succeeded at 1767 (offset 7 lines). Hunk #12 succeeded at 1818 (offset 7 lines). Hunk #13 succeeded at 1836 (offset 7 lines). Hunk #14 succeeded at 1984 (offset 7 lines). Hunk #15 FAILED at 2151. Hunk #16 succeeded at 2260 (offset 16 lines). Hunk #17 succeeded at 2344 (offset 16 lines). Hunk #18 succeeded at 2814 (offset 16 lines). Hunk #19 succeeded at 3218 (offset 16 lines). 2 out of 19 hunks FAILED -- saving rejects to file src/backend/utils/misc/guc_parameters.dat.rej Unstaged changes after reset: M src/backend/utils/misc/guc_parameters.dat Removing src/backend/utils/misc/guc_parameters.dat.rej === using 'git apply' to apply patch ./v1-0007-Sort-guc_parameters.dat-alphabetically-by-name.patch === Applied patch to 'src/backend/utils/misc/guc_parameters.dat' with conflicts. U src/backend/utils/misc/guc_parameters.dat diff --cc src/backend/utils/misc/guc_parameters.dat index b176d5130e4,d54c65ee9c3..00000000000 --- a/src/backend/utils/misc/guc_parameters.dat +++ b/src/backend/utils/misc/guc_parameters.dat @@@ -124,211 -128,235 +128,250 @@@ boot_val => 'true', }, - { name => 'enable_gathermerge', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables the planner\'s use of gather merge plans.', - flags => 'GUC_EXPLAIN', - variable => 'enable_gathermerge', - boot_val => 'true', + { name => 'autovacuum_analyze_scale_factor', type => 'real', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Number of tuple inserts, updates, or deletes prior to analyze as a fraction of reltuples.', + variable => 'autovacuum_anl_scale', + boot_val => '0.1', + min => '0.0', + max => '100.0', }, - { name => 'enable_partitionwise_join', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables partitionwise join.', - flags => 'GUC_EXPLAIN', - variable => 'enable_partitionwise_join', - boot_val => 'false', + { name => 'autovacuum_analyze_threshold', type => 'int', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Minimum number of tuple inserts, updates, or deletes prior to analyze.', + variable => 'autovacuum_anl_thresh', + boot_val => '50', + min => '0', + max => 'INT_MAX', }, - { name => 'enable_partitionwise_aggregate', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables partitionwise aggregation and grouping.', - flags => 'GUC_EXPLAIN', - variable => 'enable_partitionwise_aggregate', - boot_val => 'false', + # see varsup.c for why this is PGC_POSTMASTER not PGC_SIGHUP + # see vacuum_failsafe_age if you change the upper-limit value. + { name => 'autovacuum_freeze_max_age', type => 'int', context => 'PGC_POSTMASTER', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Age at which to autovacuum a table to prevent transaction ID wraparound.', + variable => 'autovacuum_freeze_max_age', + boot_val => '200000000', + min => '100000', + max => '2000000000', }, ++<<<<<<< ours +{ name => 'enable_eager_aggregate', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', + short_desc => 'Enables eager aggregation.', + flags => 'GUC_EXPLAIN', + variable => 'enable_eager_aggregate', + boot_val => 'true', +}, + +{ name => 'enable_parallel_append', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', + short_desc => 'Enables the planner\'s use of parallel append plans.', + flags => 'GUC_EXPLAIN', + variable => 'enable_parallel_append', + boot_val => 'true', ++======= + { name => 'autovacuum_max_workers', type => 'int', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Sets the maximum number of simultaneously running autovacuum worker processes.', + variable => 'autovacuum_max_workers', + boot_val => '3', + min => '1', + max => 'MAX_BACKENDS', ++>>>>>>> theirs }, - { name => 'enable_parallel_hash', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables the planner\'s use of parallel hash plans.', - flags => 'GUC_EXPLAIN', - variable => 'enable_parallel_hash', - boot_val => 'true', - }, - - { name => 'enable_partition_pruning', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables plan-time and execution-time partition pruning.', - long_desc => 'Allows the query planner and executor to compare partition bounds to conditions in the query to determine which partitions must be scanned.', - flags => 'GUC_EXPLAIN', - variable => 'enable_partition_pruning', - boot_val => 'true', + # see multixact.c for why this is PGC_POSTMASTER not PGC_SIGHUP + { name => 'autovacuum_multixact_freeze_max_age', type => 'int', context => 'PGC_POSTMASTER', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Multixact age at which to autovacuum a table to prevent multixact wraparound.', + variable => 'autovacuum_multixact_freeze_max_age', + boot_val => '400000000', + min => '10000', + max => '2000000000', }, - { name => 'enable_presorted_aggregate', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables the planner\'s ability to produce plans that provide presorted input for ORDER BY / DISTINCT aggregate functions.', - long_desc => 'Allows the query planner to build plans that provide presorted input for aggregate functions with an ORDER BY / DISTINCT clause. When disabled, implicit sorts are always performed during execution.', - flags => 'GUC_EXPLAIN', - variable => 'enable_presorted_aggregate', - boot_val => 'true', + { name => 'autovacuum_naptime', type => 'int', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Time to sleep between autovacuum runs.', + flags => 'GUC_UNIT_S', + variable => 'autovacuum_naptime', + boot_val => '60', + min => '1', + max => 'INT_MAX / 1000', }, - { name => 'enable_async_append', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables the planner\'s use of async append plans.', - flags => 'GUC_EXPLAIN', - variable => 'enable_async_append', - boot_val => 'true', + { name => 'autovacuum_vacuum_cost_delay', type => 'real', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Vacuum cost delay in milliseconds, for autovacuum.', + long_desc => '-1 means use "vacuum_cost_delay".', + flags => 'GUC_UNIT_MS', + variable => 'autovacuum_vac_cost_delay', + boot_val => '2', + min => '-1', + max => '100', }, - { name => 'enable_self_join_elimination', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables removal of unique self-joins.', - flags => 'GUC_EXPLAIN', - variable => 'enable_self_join_elimination', - boot_val => 'true', + { name => 'autovacuum_vacuum_cost_limit', type => 'int', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Vacuum cost amount available before napping, for autovacuum.', + long_desc => '-1 means use "vacuum_cost_limit".', + variable => 'autovacuum_vac_cost_limit', + boot_val => '-1', + min => '-1', + max => '10000', }, - { name => 'enable_group_by_reordering', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables reordering of GROUP BY keys.', - flags => 'GUC_EXPLAIN', - variable => 'enable_group_by_reordering', - boot_val => 'true', + { name => 'autovacuum_vacuum_insert_scale_factor', type => 'real', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Number of tuple inserts prior to vacuum as a fraction of reltuples.', + variable => 'autovacuum_vac_ins_scale', + boot_val => '0.2', + min => '0.0', + max => '100.0', }, - { name => 'enable_distinct_reordering', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_METHOD', - short_desc => 'Enables reordering of DISTINCT keys.', - flags => 'GUC_EXPLAIN', - variable => 'enable_distinct_reordering', - boot_val => 'true', + { name => 'autovacuum_vacuum_insert_threshold', type => 'int', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Minimum number of tuple inserts prior to vacuum.', + long_desc => '-1 disables insert vacuums.', + variable => 'autovacuum_vac_ins_thresh', + boot_val => '1000', + min => '-1', + max => 'INT_MAX', }, - { name => 'geqo', type => 'bool', context => 'PGC_USERSET', group => 'QUERY_TUNING_GEQO', - short_desc => 'Enables genetic query optimization.', - long_desc => 'This algorithm attempts to do planning without exhaustive searching.', - flags => 'GUC_EXPLAIN', - variable => 'enable_geqo', - boot_val => 'true', + { name => 'autovacuum_vacuum_max_threshold', type => 'int', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Maximum number of tuple updates or deletes prior to vacuum.', + long_desc => '-1 disables the maximum threshold.', + variable => 'autovacuum_vac_max_thresh', + boot_val => '100000000', + min => '-1', + max => 'INT_MAX', }, - # Not for general use --- used by SET SESSION AUTHORIZATION and SET - # ROLE - { name => 'is_superuser', type => 'bool', context => 'PGC_INTERNAL', group => 'UNGROUPED', - short_desc => 'Shows whether the current user is a superuser.', - flags => 'GUC_REPORT | GUC_NO_SHOW_ALL | GUC_NO_RESET_ALL | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE | GUC_ALLOW_IN_PARALLEL', - variable => 'current_role_is_superuser', - boot_val => 'false', + { name => 'autovacuum_vacuum_scale_factor', type => 'real', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Number of tuple updates or deletes prior to vacuum as a fraction of reltuples.', + variable => 'autovacuum_vac_scale', + boot_val => '0.2', + min => '0.0', + max => '100.0', }, - # This setting itself cannot be set by ALTER SYSTEM to avoid an - # operator turning this setting off by using ALTER SYSTEM, without a - # way to turn it back on. - { name => 'allow_alter_system', type => 'bool', context => 'PGC_SIGHUP', group => 'COMPAT_OPTIONS_OTHER', - short_desc => 'Allows running the ALTER SYSTEM command.', - long_desc => 'Can be set to off for environments where global configuration changes should be made using a different method.', - flags => 'GUC_DISALLOW_IN_AUTO_FILE', - variable => 'AllowAlterSystem', - boot_val => 'true', + { name => 'autovacuum_vacuum_threshold', type => 'int', context => 'PGC_SIGHUP', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Minimum number of tuple updates or deletes prior to vacuum.', + variable => 'autovacuum_vac_thresh', + boot_val => '50', + min => '0', + max => 'INT_MAX', }, - { name => 'bonjour', type => 'bool', context => 'PGC_POSTMASTER', group => 'CONN_AUTH_SETTINGS', - short_desc => 'Enables advertising the server via Bonjour.', - variable => 'enable_bonjour', - boot_val => 'false', - check_hook => 'check_bonjour', + { name => 'autovacuum_work_mem', type => 'int', context => 'PGC_SIGHUP', group => 'RESOURCES_MEM', + short_desc => 'Sets the maximum memory to be used by each autovacuum worker process.', + long_desc => '-1 means use "maintenance_work_mem".', + flags => 'GUC_UNIT_KB', + variable => 'autovacuum_work_mem', + boot_val => '-1', + min => '-1', + max => 'MAX_KILOBYTES', + check_hook => 'check_autovacuum_work_mem', }, - { name => 'track_commit_timestamp', type => 'bool', context => 'PGC_POSTMASTER', group => 'REPLICATION_SENDING', - short_desc => 'Collects transaction commit time.', - variable => 'track_commit_timestamp', - boot_val => 'false', + # see max_connections + { name => 'autovacuum_worker_slots', type => 'int', context => 'PGC_POSTMASTER', group => 'VACUUM_AUTOVACUUM', + short_desc => 'Sets the number of backend slots to allocate for autovacuum workers.', + variable => 'autovacuum_worker_slots', + boot_val => '16', + min => '1', + max => 'MAX_BACKENDS', }, - { name => 'ssl', type => 'bool', context => 'PGC_SIGHUP', group => 'CONN_AUTH_SSL', - short_desc => 'Enables SSL connections.', - variable => 'EnableSSL', - boot_val => 'false', - check_hook => 'check_ssl', + { name => 'backend_flush_after', type => 'int', context => 'PGC_USERSET', group => 'RESOURCES_IO', + short_desc => 'Number of pages after which previously performed writes are flushed to disk.', + long_desc => '0 disables forced writeback.', + flags => 'GUC_UNIT_BLOCKS', + variable => 'backend_flush_after', + boot_val => 'DEFAULT_BACKEND_FLUSH_AFTER', + min => '0', + max => 'WRITEBACK_MAX_PENDING_FLUSHES', }, - { name => 'ssl_passphrase_command_supports_reload', type => 'bool', context => 'PGC_SIGHUP', group => 'CONN_AUTH_SSL', - short_desc => 'Controls whether "ssl_passphrase_command" is called during server reload.', - variable => 'ssl_passphrase_command_supports_reload', - boot_val => 'false', + { name => 'backslash_quote', type => 'enum', context => 'PGC_USERSET', group => 'COMPAT_OPTIONS_PREVIOUS', + short_desc => 'Sets whether "\\\\\'" is allowed in string literals.', + variable => 'backslash_quote', + boot_val => 'BACKSLASH_QUOTE_SAFE_ENCODING', + options => 'backslash_quote_options', }, - { name => 'ssl_prefer_server_ciphers', type => 'bool', context => 'PGC_SIGHUP', group => 'CONN_AUTH_SSL', - short_desc => 'Give priority to server ciphersuite order.', - variable => 'SSLPreferServerCiphers', - boot_val => 'true', + { name => 'backtrace_functions', type => 'string', context => 'PGC_SUSET', group => 'DEVELOPER_OPTIONS', + short_desc => 'Log backtrace for errors in these functions.', + flags => 'GUC_NOT_IN_SAMPLE', + variable => 'backtrace_functions', + boot_val => '""', + check_hook => 'check_backtrace_functions', + assign_hook => 'assign_backtrace_functions', }, - { name => 'fsync', type => 'bool', context => 'PGC_SIGHUP', group => 'WAL_SETTINGS', - short_desc => 'Forces synchronization of updates to disk.', - long_desc => 'The server will use the fsync() system call in several places to make sure that updates are physically written to disk. This ensures that a database cluster will recover to a consistent state after an operating system or hardware crash.', - variable => 'enableFsync', - boot_val => 'true', + { name => 'bgwriter_delay', type => 'int', context => 'PGC_SIGHUP', group => 'RESOURCES_BGWRITER', + short_desc => 'Background writer sleep time between rounds.', + flags => 'GUC_UNIT_MS', + variable => 'BgWriterDelay', + boot_val => '200', + min => '10', + max => '10000', }, - { name => 'ignore_checksum_failure', type => 'bool', context => 'PGC_SUSET', group => 'DEVELOPER_OPTIONS', - short_desc => 'Continues processing after a checksum failure.', - long_desc => 'Detection of a checksum failure normally causes PostgreSQL to report an error, aborting the current transaction. Setting ignore_checksum_failure to true causes the system to ignore the failure (but still report a warning), and continue processing. This behavior could cause crashes or other serious problems. Only has an effect if checksums are enabled.', - flags => 'GUC_NOT_IN_SAMPLE', - variable => 'ignore_checksum_failure', - boot_val => 'false', + { name => 'bgwriter_flush_after', type => 'int', context => 'PGC_SIGHUP', group => 'RESOURCES_BGWRITER', + short_desc => 'Number of pages after which previously performed writes are flushed to disk.', + long_desc => '0 disables forced writeback.', + flags => 'GUC_UNIT_BLOCKS', + variable => 'bgwriter_flush_after', + boot_val => 'DEFAULT_BGWRITER_FLUSH_AFTER', + min => '0', + max => 'WRITEBACK_MAX_PENDING_FLUSHES', }, - { name => 'zero_damaged_pages', type => 'bool', context => 'PGC_SUSET', group => 'DEVELOPER_OPTIONS', - short_desc => 'Continues processing past damaged page headers.', - long_desc => 'Detection of a damaged page header normally causes PostgreSQL to report an error, aborting the current transaction. Setting "zero_damaged_pages" to true causes the system to instead report a warning, zero out the damaged page, and continue processing. This behavior will destroy data, namely all the rows on the damaged page.', - flags => 'GUC_NOT_IN_SAMPLE', - variable => 'zero_damaged_pages', - boot_val => 'false', + # Same upper limit as shared_buffers + { name => 'bgwriter_lru_maxpages', type => 'int', context => 'PGC_SIGHUP', group => 'RESOURCES_BGWRITER', + short_desc => 'Background writer maximum number of LRU pages to flush per round.', + long_desc => '0 disables background writing.', + variable => 'bgwriter_lru_maxpages', + boot_val => '100', + min => '0', + max => 'INT_MAX / 2', }, - { name => 'ignore_invalid_pages', type => 'bool', context => 'PGC_POSTMASTER', group => 'DEVELOPER_OPTIONS', - short_desc => 'Continues recovery after an invalid pages failure.', - long_desc => 'Detection of WAL records having references to invalid pages during recovery causes PostgreSQL to raise a PANIC-level error, aborting the recovery. Setting "ignore_invalid_pages" to true causes the system to ignore invalid page references in WAL records (but still report a warning), and continue recovery. This behavior may cause crashes, data loss, propagate or hide corruption, or other serious problems. Only has an effect during recovery or in standby mode.', - flags => 'GUC_NOT_IN_SAMPLE', - variable => 'ignore_invalid_pages', - boot_val => 'false', + { name => 'bgwriter_lru_multiplier', type => 'real', context => 'PGC_SIGHUP', group => 'RESOURCES_BGWRITER', + short_desc => 'Multiple of the average buffer usage to free per round.', + variable => 'bgwriter_lru_multiplier', + boot_val => '2.0', + min => '0.0', + max => '10.0', }, - { name => 'full_page_writes', type => 'bool', context => 'PGC_SIGHUP', group => 'WAL_SETTINGS', - short_desc => 'Writes full pages to WAL when first modified after a checkpoint.', - long_desc => 'A page write in process during an operating system crash might be only partially written to disk. During recovery, the row changes stored in WAL are not enough to recover. This option writes pages when first modified after a checkpoint to WAL so full recovery is possible.', - variable => 'fullPageWrites', - boot_val => 'true', + { name => 'block_size', type => 'int', context => 'PGC_INTERNAL', group => 'PRESET_OPTIONS', + short_desc => 'Shows the size of a disk block.', + flags => 'GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE', + variable => 'block_size', + boot_val => 'BLCKSZ', + min => 'BLCKSZ', + max => 'BLCKSZ', }, - { name => 'wal_log_hints', type => 'bool', context => 'PGC_POSTMASTER', group => 'WAL_SETTINGS', - short_desc => 'Writes full pages to WAL when first modified after a checkpoint, even for a non-critical modification.', - variable => 'wal_log_hints', + { name => 'bonjour', type => 'bool', context => 'PGC_POSTMASTER', group => 'CONN_AUTH_SETTINGS', + short_desc => 'Enables advertising the server via Bonjour.', + variable => 'enable_bonjour', boot_val => 'false', + check_hook => 'check_bonjour', }, - { name => 'wal_init_zero', type => 'bool', context => 'PGC_SUSET', group => 'WAL_SETTINGS', - short_desc => 'Writes zeroes to new WAL files before first use.', - variable => 'wal_init_zero', - boot_val => 'true', + { name => 'bonjour_name', type => 'string', context => 'PGC_POSTMASTER', group => 'CONN_AUTH_SETTINGS', + short_desc => 'Sets the Bonjour service name.', + long_desc => 'An empty string means use the computer name.', + variable => 'bonjour_name', + boot_val => '""', }, - { name => 'wal_recycle', type => 'bool', context => 'PGC_SUSET', group => 'WAL_SETTINGS', - short_desc => 'Recycles WAL files by renaming them.', - variable => 'wal_recycle', - boot_val => 'true', + { name => 'bytea_output', type => 'enum', context => 'PGC_USERSET', group => 'CLIENT_CONN_STATEMENT', + short_desc => 'Sets the output format for bytea.', + variable => 'bytea_output', + boot_val => 'BYTEA_OUTPUT_HEX', + options => 'bytea_output_options', }, - { name => 'log_checkpoints', type => 'bool', context => 'PGC_SIGHUP', group => 'LOGGING_WHAT', - short_desc => 'Logs each checkpoint.', - variable => 'log_checkpoints', + { name => 'check_function_bodies', type => 'bool', context => 'PGC_USERSET', group => 'CLIENT_CONN_STATEMENT', + short_desc => 'Check routine bodies during CREATE FUNCTION and CREATE PROCEDURE.', + variable => 'check_function_bodies', boot_val => 'true', }, @@@ -2359,97 -2273,97 +2288,116 @@@ max => 'DBL_MAX', }, - { name => 'cpu_tuple_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Sets the planner\'s estimate of the cost of processing each tuple (row).', - flags => 'GUC_EXPLAIN', - variable => 'cpu_tuple_cost', - boot_val => 'DEFAULT_CPU_TUPLE_COST', - min => '0', - max => 'DBL_MAX', + { name => 'recovery_end_command', type => 'string', context => 'PGC_SIGHUP', group => 'WAL_ARCHIVE_RECOVERY', + short_desc => 'Sets the shell command that will be executed once at the end of recovery.', + variable => 'recoveryEndCommand', + boot_val => '""', }, - { name => 'cpu_index_tuple_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Sets the planner\'s estimate of the cost of processing each index entry during an index scan.', - flags => 'GUC_EXPLAIN', - variable => 'cpu_index_tuple_cost', - boot_val => 'DEFAULT_CPU_INDEX_TUPLE_COST', - min => '0', - max => 'DBL_MAX', + { name => 'recovery_init_sync_method', type => 'enum', context => 'PGC_SIGHUP', group => 'ERROR_HANDLING_OPTIONS', + short_desc => 'Sets the method for synchronizing the data directory before crash recovery.', + variable => 'recovery_init_sync_method', + boot_val => 'DATA_DIR_SYNC_METHOD_FSYNC', + options => 'recovery_init_sync_method_options', }, - { name => 'cpu_operator_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Sets the planner\'s estimate of the cost of processing each operator or function call.', - flags => 'GUC_EXPLAIN', - variable => 'cpu_operator_cost', - boot_val => 'DEFAULT_CPU_OPERATOR_COST', + { name => 'recovery_min_apply_delay', type => 'int', context => 'PGC_SIGHUP', group => 'REPLICATION_STANDBY', + short_desc => 'Sets the minimum delay for applying changes during recovery.', + flags => 'GUC_UNIT_MS', + variable => 'recovery_min_apply_delay', + boot_val => '0', min => '0', - max => 'DBL_MAX', + max => 'INT_MAX', }, - { name => 'parallel_tuple_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Sets the planner\'s estimate of the cost of passing each tuple (row) from worker to leader backend.', - flags => 'GUC_EXPLAIN', - variable => 'parallel_tuple_cost', - boot_val => 'DEFAULT_PARALLEL_TUPLE_COST', - min => '0', - max => 'DBL_MAX', + { name => 'recovery_prefetch', type => 'enum', context => 'PGC_SIGHUP', group => 'WAL_RECOVERY', + short_desc => 'Prefetch referenced blocks during recovery.', + long_desc => 'Look ahead in the WAL to find references to uncached data.', + variable => 'recovery_prefetch', + boot_val => 'RECOVERY_PREFETCH_TRY', + options => 'recovery_prefetch_options', + check_hook => 'check_recovery_prefetch', + assign_hook => 'assign_recovery_prefetch', }, - { name => 'parallel_setup_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Sets the planner\'s estimate of the cost of starting up worker processes for parallel query.', - flags => 'GUC_EXPLAIN', - variable => 'parallel_setup_cost', - boot_val => 'DEFAULT_PARALLEL_SETUP_COST', - min => '0', - max => 'DBL_MAX', + { name => 'recovery_target', type => 'string', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Set to "immediate" to end recovery as soon as a consistent state is reached.', + variable => 'recovery_target_string', + boot_val => '""', + check_hook => 'check_recovery_target', + assign_hook => 'assign_recovery_target', }, - { name => 'jit_above_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Perform JIT compilation if query is more expensive.', - long_desc => '-1 disables JIT compilation.', - flags => 'GUC_EXPLAIN', - variable => 'jit_above_cost', - boot_val => '100000', - min => '-1', - max => 'DBL_MAX', + { name => 'recovery_target_action', type => 'enum', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Sets the action to perform upon reaching the recovery target.', + variable => 'recoveryTargetAction', + boot_val => 'RECOVERY_TARGET_ACTION_PAUSE', + options => 'recovery_target_action_options', }, - { name => 'jit_optimize_above_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Optimize JIT-compiled functions if query is more expensive.', - long_desc => '-1 disables optimization.', - flags => 'GUC_EXPLAIN', - variable => 'jit_optimize_above_cost', - boot_val => '500000', - min => '-1', - max => 'DBL_MAX', + { name => 'recovery_target_inclusive', type => 'bool', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Sets whether to include or exclude transaction with recovery target.', + variable => 'recoveryTargetInclusive', + boot_val => 'true', }, - { name => 'jit_inline_above_cost', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', - short_desc => 'Perform JIT inlining if query is more expensive.', - long_desc => '-1 disables inlining.', - flags => 'GUC_EXPLAIN', - variable => 'jit_inline_above_cost', - boot_val => '500000', - min => '-1', - max => 'DBL_MAX', + { name => 'recovery_target_lsn', type => 'string', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Sets the LSN of the write-ahead log location up to which recovery will proceed.', + variable => 'recovery_target_lsn_string', + boot_val => '""', + check_hook => 'check_recovery_target_lsn', + assign_hook => 'assign_recovery_target_lsn', }, ++<<<<<<< ours +{ name => 'min_eager_agg_group_size', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_COST', + short_desc => 'Sets the minimum average group size required to consider applying eager aggregation.', + flags => 'GUC_EXPLAIN', + variable => 'min_eager_agg_group_size', + boot_val => '8.0', + min => '0.0', + max => 'DBL_MAX', +}, + +{ name => 'cursor_tuple_fraction', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_OTHER', + short_desc => 'Sets the planner\'s estimate of the fraction of a cursor\'s rows that will be retrieved.', + flags => 'GUC_EXPLAIN', + variable => 'cursor_tuple_fraction', + boot_val => 'DEFAULT_CURSOR_TUPLE_FRACTION', + min => '0.0', + max => '1.0', ++======= + { name => 'recovery_target_name', type => 'string', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Sets the named restore point up to which recovery will proceed.', + variable => 'recovery_target_name_string', + boot_val => '""', + check_hook => 'check_recovery_target_name', + assign_hook => 'assign_recovery_target_name', + }, + + { name => 'recovery_target_time', type => 'string', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Sets the time stamp up to which recovery will proceed.', + variable => 'recovery_target_time_string', + boot_val => '""', + check_hook => 'check_recovery_target_time', + assign_hook => 'assign_recovery_target_time', + }, + + { name => 'recovery_target_timeline', type => 'string', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Specifies the timeline to recover into.', + variable => 'recovery_target_timeline_string', + boot_val => '"latest"', + check_hook => 'check_recovery_target_timeline', + assign_hook => 'assign_recovery_target_timeline', + }, + + { name => 'recovery_target_xid', type => 'string', context => 'PGC_POSTMASTER', group => 'WAL_RECOVERY_TARGET', + short_desc => 'Sets the transaction ID up to which recovery will proceed.', + variable => 'recovery_target_xid_string', + boot_val => '""', + check_hook => 'check_recovery_target_xid', + assign_hook => 'assign_recovery_target_xid', ++>>>>>>> theirs }, { name => 'recursive_worktable_factor', type => 'real', context => 'PGC_USERSET', group => 'QUERY_TUNING_OTHER',