#include "utils/guc.h"

Include dependency graph for guc_hooks.h:

This graph shows which files directly or indirectly include this file:

Functions
bool	check_application_name (char newval, void extra, GucSource source)

void	assign_application_name (const char newval, void extra)

const char *	show_archive_command (void)

bool	check_autovacuum_work_mem (int newval, void *extra, GucSource source)

bool	check_vacuum_buffer_usage_limit (int newval, void *extra, GucSource source)

bool	check_backtrace_functions (char newval, void extra, GucSource source)

void	assign_backtrace_functions (const char newval, void extra)

bool	check_bonjour (bool newval, void *extra, GucSource source)

bool	check_canonical_path (char newval, void extra, GucSource source)

void	assign_checkpoint_completion_target (double newval, void *extra)

bool	check_client_connection_check_interval (int newval, void *extra, GucSource source)

bool	check_client_encoding (char newval, void extra, GucSource source)

void	assign_client_encoding (const char newval, void extra)

bool	check_cluster_name (char newval, void extra, GucSource source)

bool	check_commit_ts_buffers (int newval, void *extra, GucSource source)

const char *	show_data_directory_mode (void)

bool	check_datestyle (char newval, void extra, GucSource source)

void	assign_datestyle (const char newval, void extra)

bool	check_debug_io_direct (char newval, void extra, GucSource source)

void	assign_debug_io_direct (const char newval, void extra)

bool	check_log_connections (char newval, void extra, GucSource source)

void	assign_log_connections (const char newval, void extra)

bool	check_default_table_access_method (char newval, void extra, GucSource source)

bool	check_default_tablespace (char newval, void extra, GucSource source)

bool	check_default_text_search_config (char newval, void extra, GucSource source)

void	assign_default_text_search_config (const char newval, void extra)

bool	check_default_with_oids (bool newval, void *extra, GucSource source)

const char *	show_effective_wal_level (void)

bool	check_huge_page_size (int newval, void *extra, GucSource source)

void	assign_io_method (int newval, void *extra)

bool	check_io_max_concurrency (int newval, void *extra, GucSource source)

const char *	show_in_hot_standby (void)

bool	check_locale_messages (char newval, void extra, GucSource source)

void	assign_locale_messages (const char newval, void extra)

bool	check_locale_monetary (char newval, void extra, GucSource source)

void	assign_locale_monetary (const char newval, void extra)

bool	check_locale_numeric (char newval, void extra, GucSource source)

void	assign_locale_numeric (const char newval, void extra)

bool	check_locale_time (char newval, void extra, GucSource source)

void	assign_locale_time (const char newval, void extra)

bool	check_log_destination (char newval, void extra, GucSource source)

void	assign_log_destination (const char newval, void extra)

const char *	show_log_file_mode (void)

bool	check_log_stats (bool newval, void *extra, GucSource source)

bool	check_log_timezone (char newval, void extra, GucSource source)

void	assign_log_timezone (const char newval, void extra)

const char *	show_log_timezone (void)

void	assign_maintenance_io_concurrency (int newval, void *extra)

void	assign_io_max_combine_limit (int newval, void *extra)

void	assign_io_combine_limit (int newval, void *extra)

void	assign_max_wal_size (int newval, void *extra)

bool	check_max_stack_depth (int newval, void *extra, GucSource source)

void	assign_max_stack_depth (int newval, void *extra)

bool	check_multixact_member_buffers (int newval, void *extra, GucSource source)

bool	check_multixact_offset_buffers (int newval, void *extra, GucSource source)

bool	check_notify_buffers (int newval, void *extra, GucSource source)

bool	check_primary_slot_name (char newval, void extra, GucSource source)

bool	check_random_seed (double newval, void *extra, GucSource source)

void	assign_random_seed (double newval, void *extra)

const char *	show_random_seed (void)

bool	check_recovery_prefetch (int new_value, void *extra, GucSource source)

void	assign_recovery_prefetch (int new_value, void *extra)

bool	check_recovery_target (char newval, void extra, GucSource source)

void	assign_recovery_target (const char newval, void extra)

bool	check_recovery_target_lsn (char newval, void extra, GucSource source)

void	assign_recovery_target_lsn (const char newval, void extra)

bool	check_recovery_target_name (char newval, void extra, GucSource source)

void	assign_recovery_target_name (const char newval, void extra)

bool	check_recovery_target_time (char newval, void extra, GucSource source)

void	assign_recovery_target_time (const char newval, void extra)

bool	check_recovery_target_timeline (char newval, void extra, GucSource source)

void	assign_recovery_target_timeline (const char newval, void extra)

bool	check_recovery_target_xid (char newval, void extra, GucSource source)

void	assign_recovery_target_xid (const char newval, void extra)

bool	check_role (char newval, void extra, GucSource source)

void	assign_role (const char newval, void extra)

const char *	show_role (void)

bool	check_restrict_nonsystem_relation_kind (char newval, void extra, GucSource source)

void	assign_restrict_nonsystem_relation_kind (const char newval, void extra)

bool	check_search_path (char newval, void extra, GucSource source)

void	assign_search_path (const char newval, void extra)

bool	check_serial_buffers (int newval, void *extra, GucSource source)

bool	check_session_authorization (char newval, void extra, GucSource source)

void	assign_session_authorization (const char newval, void extra)

void	assign_session_replication_role (int newval, void *extra)

void	assign_stats_fetch_consistency (int newval, void *extra)

bool	check_ssl (bool newval, void *extra, GucSource source)

bool	check_ssl_sni (bool newval, void *extra, GucSource source)

bool	check_stage_log_stats (bool newval, void *extra, GucSource source)

bool	check_standard_conforming_strings (bool newval, void *extra, GucSource source)

bool	check_subtrans_buffers (int newval, void *extra, GucSource source)

bool	check_synchronous_standby_names (char newval, void extra, GucSource source)

void	assign_synchronous_standby_names (const char newval, void extra)

void	assign_synchronous_commit (int newval, void *extra)

void	assign_syslog_facility (int newval, void *extra)

void	assign_syslog_ident (const char newval, void extra)

void	assign_tcp_keepalives_count (int newval, void *extra)

const char *	show_tcp_keepalives_count (void)

void	assign_tcp_keepalives_idle (int newval, void *extra)

const char *	show_tcp_keepalives_idle (void)

void	assign_tcp_keepalives_interval (int newval, void *extra)

const char *	show_tcp_keepalives_interval (void)

void	assign_tcp_user_timeout (int newval, void *extra)

const char *	show_tcp_user_timeout (void)

bool	check_temp_buffers (int newval, void *extra, GucSource source)

bool	check_temp_tablespaces (char newval, void extra, GucSource source)

void	assign_temp_tablespaces (const char newval, void extra)

bool	check_timezone (char newval, void extra, GucSource source)

void	assign_timezone (const char newval, void extra)

const char *	show_timezone (void)

bool	check_timezone_abbreviations (char newval, void extra, GucSource source)

void	assign_timezone_abbreviations (const char newval, void extra)

bool	check_transaction_buffers (int newval, void *extra, GucSource source)

bool	check_transaction_deferrable (bool newval, void *extra, GucSource source)

bool	check_transaction_isolation (int newval, void *extra, GucSource source)

bool	check_transaction_read_only (bool newval, void *extra, GucSource source)

void	assign_transaction_timeout (int newval, void *extra)

const char *	show_unix_socket_permissions (void)

bool	check_wal_buffers (int newval, void *extra, GucSource source)

bool	check_wal_consistency_checking (char newval, void extra, GucSource source)

void	assign_wal_consistency_checking (const char newval, void extra)

bool	check_wal_segment_size (int newval, void *extra, GucSource source)

void	assign_wal_sync_method (int new_wal_sync_method, void *extra)

bool	check_synchronized_standby_slots (char newval, void extra, GucSource source)

void	assign_synchronized_standby_slots (const char newval, void extra)

bool	check_log_min_messages (char newval, void extra, GucSource source)

void	assign_log_min_messages (const char newval, void extra)

Function Documentation

◆ assign_application_name()

void assign_application_name	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 1108 of file variable.c.

{
    /* Update the pg_stat_activity view */
    pgstat_report_appname(newval);
}

References newval, and pgstat_report_appname().

◆ assign_backtrace_functions()

void assign_backtrace_functions	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 2668 of file elog.c.

{
    backtrace_function_list = (char *) extra;
}

References backtrace_function_list.

◆ assign_checkpoint_completion_target()

void assign_checkpoint_completion_target	(	double	newval,
		void *	extra
	)

extern

Definition at line 2194 of file xlog.c.

{
    CheckPointCompletionTarget = newval;
    CalculateCheckpointSegments();
}

References CalculateCheckpointSegments(), CheckPointCompletionTarget, and newval.

◆ assign_client_encoding()

void assign_client_encoding	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 786 of file variable.c.

{
    int         encoding = *((int *) extra);
 
    /*
     * In a parallel worker, we never override the client encoding that was
     * set by ParallelWorkerMain().
     */
    if (IsParallelWorker())
        return;
 
    /* We do not expect an error if PrepareClientEncoding succeeded */
    if (SetClientEncoding(encoding) < 0)
        elog(LOG, "SetClientEncoding(%d) failed", encoding);
}

References elog, encoding, IsParallelWorker, LOG, and SetClientEncoding().

◆ assign_datestyle()

void assign_datestyle	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 244 of file variable.c.

{
    int        *myextra = (int *) extra;
 
    DateStyle = myextra[0];
    DateOrder = myextra[1];
}

References DateOrder, DateStyle, and fb().

◆ assign_debug_io_direct()

void assign_debug_io_direct	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 4079 of file fd.c.

{
    int        *flags = (int *) extra;
 
    io_direct_flags = *flags;
}

References io_direct_flags.

◆ assign_default_text_search_config()

void assign_default_text_search_config	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 672 of file ts_cache.c.

{
    /* Just reset the cache to force a lookup on first use */
    TSCurrentConfigCache = InvalidOid;
}

References InvalidOid, and TSCurrentConfigCache.

◆ assign_io_combine_limit()

void assign_io_combine_limit	(	int	newval,
		void *	extra
	)

extern

Definition at line 1169 of file variable.c.

{
    io_combine_limit = Min(io_max_combine_limit, newval);
}

References io_combine_limit, io_max_combine_limit, Min, and newval.

◆ assign_io_max_combine_limit()

void assign_io_max_combine_limit	(	int	newval,
		void *	extra
	)

extern

Definition at line 1164 of file variable.c.

{
    io_combine_limit = Min(newval, io_combine_limit_guc);
}

References io_combine_limit, io_combine_limit_guc, Min, and newval.

◆ assign_io_method()

void assign_io_method	(	int	newval,
		void *	extra
	)

extern

Definition at line 1322 of file aio.c.

{
    Assert(newval < lengthof(pgaio_method_ops_table));
    Assert(pgaio_method_ops_table[newval] != NULL);
 
    pgaio_method_ops = pgaio_method_ops_table[newval];
}

References Assert, fb(), lengthof, newval, pgaio_method_ops, and pgaio_method_ops_table.

◆ assign_locale_messages()

void assign_locale_messages	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 409 of file pg_locale.c.

{
    /*
     * LC_MESSAGES category does not exist everywhere, but accept it anyway.
     * We ignore failure, as per comment above.
     */
#ifdef LC_MESSAGES
    (void) pg_perm_setlocale(LC_MESSAGES, newval);
#endif
}

References fb(), newval, and pg_perm_setlocale().

◆ assign_locale_monetary()

void assign_locale_monetary	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 346 of file pg_locale.c.

{
    CurrentLocaleConvValid = false;
}

References CurrentLocaleConvValid.

◆ assign_locale_numeric()

void assign_locale_numeric	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 358 of file pg_locale.c.

{
    CurrentLocaleConvValid = false;
}

References CurrentLocaleConvValid.

◆ assign_locale_time()

void assign_locale_time	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 370 of file pg_locale.c.

{
    CurrentLCTimeValid = false;
}

References CurrentLCTimeValid.

◆ assign_log_connections()

void assign_log_connections	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 1126 of file backend_startup.c.

{
    log_connections = *((int *) extra);
}

References log_connections.

◆ assign_log_destination()

void assign_log_destination	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 2741 of file elog.c.

{
    Log_destination = *((int *) extra);
}

References Log_destination.

◆ assign_log_min_messages()

void assign_log_min_messages	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 2590 of file elog.c.

{
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
        log_min_messages[i] = ((int *) extra)[i];
}

References BACKEND_NUM_TYPES, i, and log_min_messages.

◆ assign_log_timezone()

void assign_log_timezone	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 456 of file variable.c.

{
    log_timezone = *((pg_tz **) extra);
}

References log_timezone.

◆ assign_maintenance_io_concurrency()

void assign_maintenance_io_concurrency	(	int	newval,
		void *	extra
	)

extern

Definition at line 1146 of file variable.c.

{
    /*
     * Reconfigure recovery prefetching, because a setting it depends on
     * changed.
     */
    maintenance_io_concurrency = newval;
    if (AmStartupProcess())
        XLogPrefetchReconfigure();
}

References AmStartupProcess, maintenance_io_concurrency, newval, and XLogPrefetchReconfigure().

◆ assign_max_stack_depth()

void assign_max_stack_depth	(	int	newval,
		void *	extra
	)

extern

Definition at line 159 of file stack_depth.c.

{
    ssize_t     newval_bytes = newval * (ssize_t) 1024;
 
    max_stack_depth_bytes = newval_bytes;
}

References fb(), max_stack_depth_bytes, and newval.

◆ assign_max_wal_size()

void assign_max_wal_size	(	int	newval,
		void *	extra
	)

extern

Definition at line 2187 of file xlog.c.

{
    max_wal_size_mb = newval;
    CalculateCheckpointSegments();
}

References CalculateCheckpointSegments(), max_wal_size_mb, and newval.

◆ assign_random_seed()

void assign_random_seed	(	double	newval,
		void *	extra
	)

extern

Definition at line 668 of file variable.c.

{
    /* We'll do this at most once for any setting of the GUC variable */
    if (*((int *) extra))
        DirectFunctionCall1(setseed, Float8GetDatum(newval));
    *((int *) extra) = 0;
}

References DirectFunctionCall1, Float8GetDatum(), newval, and setseed().

◆ assign_recovery_prefetch()

void assign_recovery_prefetch	(	int	new_value,
		void *	extra
	)

extern

Definition at line 1097 of file xlogprefetcher.c.

{
    /* Reconfigure prefetching, because a setting it depends on changed. */
    recovery_prefetch = new_value;
    if (AmStartupProcess())
        XLogPrefetchReconfigure();
}

References AmStartupProcess, fb(), recovery_prefetch, and XLogPrefetchReconfigure().

◆ assign_recovery_target()

void assign_recovery_target	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 4810 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_IMMEDIATE)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
        recoveryTarget = RECOVERY_TARGET_IMMEDIATE;
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References error_multiple_recovery_targets(), fb(), newval, RECOVERY_TARGET_IMMEDIATE, RECOVERY_TARGET_UNSET, and recoveryTarget.

◆ assign_recovery_target_lsn()

void assign_recovery_target_lsn	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 4851 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_LSN)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_LSN;
        recoveryTargetLSN = *((XLogRecPtr *) extra);
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References error_multiple_recovery_targets(), fb(), newval, RECOVERY_TARGET_LSN, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetLSN.

◆ assign_recovery_target_name()

void assign_recovery_target_name	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 4886 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_NAME)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_NAME;
        recoveryTargetName = newval;
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References error_multiple_recovery_targets(), fb(), newval, RECOVERY_TARGET_NAME, RECOVERY_TARGET_UNSET, recoveryTarget, and recoveryTargetName.

◆ assign_recovery_target_time()

void assign_recovery_target_time	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 4966 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_TIME)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
        recoveryTarget = RECOVERY_TARGET_TIME;
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References error_multiple_recovery_targets(), fb(), newval, RECOVERY_TARGET_TIME, RECOVERY_TARGET_UNSET, and recoveryTarget.

◆ assign_recovery_target_timeline()

void assign_recovery_target_timeline	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 5029 of file xlogrecovery.c.

{
    recoveryTargetTimeLineGoal = *((RecoveryTargetTimeLineGoal *) extra);
    if (recoveryTargetTimeLineGoal == RECOVERY_TARGET_TIMELINE_NUMERIC)
        recoveryTargetTLIRequested = (TimeLineID) strtoul(newval, NULL, 0);
    else
        recoveryTargetTLIRequested = 0;
}

References fb(), newval, RECOVERY_TARGET_TIMELINE_NUMERIC, recoveryTargetTimeLineGoal, and recoveryTargetTLIRequested.

◆ assign_recovery_target_xid()

void assign_recovery_target_xid	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 5094 of file xlogrecovery.c.

{
    if (recoveryTarget != RECOVERY_TARGET_UNSET &&
        recoveryTarget != RECOVERY_TARGET_XID)
        error_multiple_recovery_targets();
 
    if (newval && strcmp(newval, "") != 0)
    {
        recoveryTarget = RECOVERY_TARGET_XID;
        recoveryTargetXid = *((TransactionId *) extra);
    }
    else
        recoveryTarget = RECOVERY_TARGET_UNSET;
}

References error_multiple_recovery_targets(), fb(), newval, RECOVERY_TARGET_UNSET, RECOVERY_TARGET_XID, recoveryTarget, and recoveryTargetXid.

◆ assign_restrict_nonsystem_relation_kind()

void assign_restrict_nonsystem_relation_kind	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 3706 of file postgres.c.

{
    int        *flags = (int *) extra;
 
    restrict_nonsystem_relation_kind = *flags;
}

References restrict_nonsystem_relation_kind.

◆ assign_role()

void assign_role	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 1026 of file variable.c.

{
    role_auth_extra *myextra = (role_auth_extra *) extra;
 
    SetCurrentRoleId(myextra->roleid, myextra->is_superuser);
}

References fb(), and SetCurrentRoleId().

◆ assign_search_path()

void assign_search_path	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 4785 of file namespace.c.

{
    /* don't access search_path during bootstrap */
    Assert(!IsBootstrapProcessingMode());
 
    /*
     * We mark the path as needing recomputation, but don't do anything until
     * it's needed.  This avoids trying to do database access during GUC
     * initialization, or outside a transaction.
     *
     * This does not invalidate the search path cache, so if this value had
     * been previously set and no syscache invalidations happened,
     * recomputation may not be necessary.
     */
    baseSearchPathValid = false;
}

References Assert, baseSearchPathValid, and IsBootstrapProcessingMode.

◆ assign_session_authorization()

void assign_session_authorization	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 912 of file variable.c.

{
    role_auth_extra *myextra = (role_auth_extra *) extra;
 
    /* Do nothing for the boot_val default of NULL */
    if (!myextra)
        return;
 
    SetSessionAuthorization(myextra->roleid, myextra->is_superuser);
}

References fb(), and SetSessionAuthorization().

◆ assign_session_replication_role()

void assign_session_replication_role	(	int	newval,
		void *	extra
	)

extern

Definition at line 6706 of file trigger.c.

{
    /*
     * Must flush the plan cache when changing replication role; but don't
     * flush unnecessarily.
     */
    if (SessionReplicationRole != newval)
        ResetPlanCache();
}

References newval, ResetPlanCache(), and SessionReplicationRole.

◆ assign_stats_fetch_consistency()

void assign_stats_fetch_consistency	(	int	newval,
		void *	extra
	)

extern

Definition at line 2111 of file pgstat.c.

{
    /*
     * Changing this value in a transaction may cause snapshot state
     * inconsistencies, so force a clear of the current snapshot on the next
     * snapshot build attempt.
     */
    if (pgstat_fetch_consistency != newval)
        force_stats_snapshot_clear = true;

References force_stats_snapshot_clear, newval, and pgstat_fetch_consistency.

◆ assign_synchronized_standby_slots()

void assign_synchronized_standby_slots	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 3045 of file slot.c.

{
    /*
     * The standby slots may have changed, so we must recompute the oldest
     * LSN.
     */
    ss_oldest_flush_lsn = InvalidXLogRecPtr;
 
    synchronized_standby_slots_config = (SyncStandbySlotsConfigData *) extra;
}

References InvalidXLogRecPtr, ss_oldest_flush_lsn, and synchronized_standby_slots_config.

◆ assign_synchronous_commit()

void assign_synchronous_commit	(	int	newval,
		void *	extra
	)

extern

Definition at line 1124 of file syncrep.c.

{
    switch (newval)
    {
        case SYNCHRONOUS_COMMIT_REMOTE_WRITE:
            SyncRepWaitMode = SYNC_REP_WAIT_WRITE;
            break;
        case SYNCHRONOUS_COMMIT_REMOTE_FLUSH:
            SyncRepWaitMode = SYNC_REP_WAIT_FLUSH;
            break;
        case SYNCHRONOUS_COMMIT_REMOTE_APPLY:
            SyncRepWaitMode = SYNC_REP_WAIT_APPLY;
            break;
        default:
            SyncRepWaitMode = SYNC_REP_NO_WAIT;
            break;
    }
}

References newval, SYNC_REP_NO_WAIT, SYNC_REP_WAIT_APPLY, SYNC_REP_WAIT_FLUSH, SYNC_REP_WAIT_WRITE, SYNCHRONOUS_COMMIT_REMOTE_APPLY, SYNCHRONOUS_COMMIT_REMOTE_FLUSH, SYNCHRONOUS_COMMIT_REMOTE_WRITE, and SyncRepWaitMode.

◆ assign_synchronous_standby_names()

void assign_synchronous_standby_names	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 1118 of file syncrep.c.

{
    SyncRepConfig = (SyncRepConfigData *) extra;
}

References SyncRepConfig.

◆ assign_syslog_facility()

void assign_syslog_facility	(	int	newval,
		void *	extra
	)

extern

Definition at line 2782 of file elog.c.

{
#ifdef HAVE_SYSLOG
    /*
     * As above, don't thrash the syslog connection unnecessarily.
     */
    if (syslog_facility != newval)
    {
        if (openlog_done)
        {
            closelog();
            openlog_done = false;
        }
        syslog_facility = newval;
    }
#endif
    /* Without syslog support, just ignore it */
}

References fb(), newval, and syslog_facility.

◆ assign_syslog_ident()

void assign_syslog_ident	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 2750 of file elog.c.

{
#ifdef HAVE_SYSLOG
    /*
     * guc.c is likely to call us repeatedly with same parameters, so don't
     * thrash the syslog connection unnecessarily.  Also, we do not re-open
     * the connection until needed, since this routine will get called whether
     * or not Log_destination actually mentions syslog.
     *
     * Note that we make our own copy of the ident string rather than relying
     * on guc.c's.  This may be overly paranoid, but it ensures that we cannot
     * accidentally free a string that syslog is still using.
     */
    if (syslog_ident == NULL || strcmp(syslog_ident, newval) != 0)
    {
        if (openlog_done)
        {
            closelog();
            openlog_done = false;
        }
        free(syslog_ident);
        syslog_ident = strdup(newval);
        /* if the strdup fails, we will cope in write_syslog() */
    }
#endif
    /* Without syslog support, just ignore it */
}

References fb(), free, and newval.

◆ assign_tcp_keepalives_count()

void assign_tcp_keepalives_count	(	int	newval,
		void *	extra
	)

extern

Definition at line 2011 of file pqcomm.c.

{
    /* See comments in assign_tcp_keepalives_idle */
    (void) pq_setkeepalivescount(newval, MyProcPort);
}

References fb(), MyProcPort, newval, and pq_setkeepalivescount().

◆ assign_tcp_keepalives_idle()

void assign_tcp_keepalives_idle	(	int	newval,
		void *	extra
	)

extern

Definition at line 1955 of file pqcomm.c.

{
    /*
     * The kernel API provides no way to test a value without setting it; and
     * once we set it we might fail to unset it.  So there seems little point
     * in fully implementing the check-then-assign GUC API for these
     * variables.  Instead we just do the assignment on demand.
     * pq_setkeepalivesidle reports any problems via ereport(LOG).
     *
     * This approach means that the GUC value might have little to do with the
     * actual kernel value, so we use a show_hook that retrieves the kernel
     * value rather than trusting GUC's copy.
     */
    (void) pq_setkeepalivesidle(newval, MyProcPort);
}

References fb(), MyProcPort, newval, and pq_setkeepalivesidle().

◆ assign_tcp_keepalives_interval()

void assign_tcp_keepalives_interval	(	int	newval,
		void *	extra
	)

extern

Definition at line 1988 of file pqcomm.c.

{
    /* See comments in assign_tcp_keepalives_idle */
    (void) pq_setkeepalivesinterval(newval, MyProcPort);
}

References fb(), MyProcPort, newval, and pq_setkeepalivesinterval().

◆ assign_tcp_user_timeout()

void assign_tcp_user_timeout	(	int	newval,
		void *	extra
	)

extern

Definition at line 2034 of file pqcomm.c.

{
    /* See comments in assign_tcp_keepalives_idle */
    (void) pq_settcpusertimeout(newval, MyProcPort);
}

References fb(), MyProcPort, newval, and pq_settcpusertimeout().

◆ assign_temp_tablespaces()

void assign_temp_tablespaces	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 1319 of file tablespace.c.

{
    temp_tablespaces_extra *myextra = (temp_tablespaces_extra *) extra;
 
    /*
     * If check_temp_tablespaces was executed inside a transaction, then pass
     * the list it made to fd.c.  Otherwise, clear fd.c's list; we must be
     * still outside a transaction, or else restoring during transaction exit,
     * and in either case we can just let the next PrepareTempTablespaces call
     * make things sane.
     */
    if (myextra)
        SetTempTablespaces(myextra->tblSpcs, myextra->numSpcs);
    else
        SetTempTablespaces(NULL, 0);
}

References fb(), and SetTempTablespaces().

◆ assign_timezone()

void assign_timezone	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 381 of file variable.c.

{
    session_timezone = *((pg_tz **) extra);
    /* datetime.c's cache of timezone abbrevs may now be obsolete */
    ClearTimeZoneAbbrevCache();
}

References ClearTimeZoneAbbrevCache(), and session_timezone.

◆ assign_timezone_abbreviations()

void assign_timezone_abbreviations	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 519 of file variable.c.

{
    /* Do nothing for the boot_val default of NULL */
    if (!extra)
        return;
 
    InstallTimeZoneAbbrevs((TimeZoneAbbrevTable *) extra);
}

References InstallTimeZoneAbbrevs().

◆ assign_transaction_timeout()

void assign_transaction_timeout	(	int	newval,
		void *	extra
	)

extern

Definition at line 3635 of file postgres.c.

{
    if (IsTransactionState())
    {
        /*
         * If transaction_timeout GUC has changed within the transaction block
         * enable or disable the timer correspondingly.
         */
        if (newval > 0 && !get_timeout_active(TRANSACTION_TIMEOUT))
            enable_timeout_after(TRANSACTION_TIMEOUT, newval);
        else if (newval <= 0 && get_timeout_active(TRANSACTION_TIMEOUT))
            disable_timeout(TRANSACTION_TIMEOUT, false);
    }
}

References disable_timeout(), enable_timeout_after(), get_timeout_active(), IsTransactionState(), newval, and TRANSACTION_TIMEOUT.

◆ assign_wal_consistency_checking()

void assign_wal_consistency_checking	(	const char *	newval,
		void *	extra
	)

extern

Definition at line 4815 of file xlog.c.

{
    /*
     * If some checks were deferred, it's possible that the checks will fail
     * later during InitializeWalConsistencyChecking(). But in that case, the
     * postmaster will exit anyway, so it's safe to proceed with the
     * assignment.
     *
     * Any built-in resource managers specified are assigned immediately,
     * which affects WAL created before shared_preload_libraries are
     * processed. Any custom resource managers specified won't be assigned
     * until after shared_preload_libraries are processed, but that's OK
     * because WAL for a custom resource manager can't be written before the
     * module is loaded anyway.
     */
    wal_consistency_checking = extra;
}

References wal_consistency_checking.

◆ assign_wal_sync_method()

void assign_wal_sync_method	(	int	new_wal_sync_method,
		void *	extra
	)

extern

Definition at line 8838 of file xlog.c.

{
    if (wal_sync_method != new_wal_sync_method)
    {
        /*
         * To ensure that no blocks escape unsynced, force an fsync on the
         * currently open log segment (if any).  Also, if the open flag is
         * changing, close the log file so it will be reopened (with new flag
         * bit) at next use.
         */
        if (openLogFile >= 0)
        {
            pgstat_report_wait_start(WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN);
            if (pg_fsync(openLogFile) != 0)
            {
                char        xlogfname[MAXFNAMELEN];
                int         save_errno;
 
                save_errno = errno;
                XLogFileName(xlogfname, openLogTLI, openLogSegNo,
                             wal_segment_size);
                errno = save_errno;
                ereport(PANIC,
                        (errcode_for_file_access(),
                         errmsg("could not fsync file \"%s\": %m", xlogfname)));
            }
 
            pgstat_report_wait_end();
            if (get_sync_bit(wal_sync_method) != get_sync_bit(new_wal_sync_method))
                XLogFileClose();
        }
    }
}

References ereport, errcode_for_file_access(), errmsg, fb(), get_sync_bit(), MAXFNAMELEN, openLogFile, openLogSegNo, openLogTLI, PANIC, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), wal_segment_size, wal_sync_method, XLogFileClose(), and XLogFileName().

◆ check_application_name()

bool check_application_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1080 of file variable.c.

{
    char       *clean;
    char       *ret;
 
    /* Only allow clean ASCII chars in the application name */
    clean = pg_clean_ascii(*newval, MCXT_ALLOC_NO_OOM);
    if (!clean)
        return false;
 
    ret = guc_strdup(LOG, clean);
    if (!ret)
    {
        pfree(clean);
        return false;
    }
 
    guc_free(*newval);
 
    pfree(clean);
    *newval = ret;
    return true;
}

References fb(), guc_free(), guc_strdup(), LOG, MCXT_ALLOC_NO_OOM, newval, pfree(), and pg_clean_ascii().

◆ check_autovacuum_work_mem()

bool check_autovacuum_work_mem	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 3427 of file autovacuum.c.

{
    /*
     * -1 indicates fallback.
     *
     * If we haven't yet changed the boot_val default of -1, just let it be.
     * Autovacuum will look to maintenance_work_mem instead.
     */
    if (*newval == -1)
        return true;
 
    /*
     * We clamp manually-set values to at least 64kB.  Since
     * maintenance_work_mem is always set to at least this value, do the same
     * here.
     */
    if (*newval < 64)
        *newval = 64;
 
    return true;
}

References newval.

◆ check_backtrace_functions()

bool check_backtrace_functions	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 2607 of file elog.c.

{
    int         newvallen = strlen(*newval);
    char       *someval;
    int         validlen;
    int         i;
    int         j;
 
    /*
     * Allow characters that can be C identifiers and commas as separators, as
     * well as some whitespace for readability.
     */
    validlen = strspn(*newval,
                      "0123456789_"
                      "abcdefghijklmnopqrstuvwxyz"
                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                      ", \n\t");
    if (validlen != newvallen)
    {
        GUC_check_errdetail("Invalid character.");
        return false;
    }
 
    if (*newval[0] == '\0')
    {
        *extra = NULL;
        return true;
    }
 
    /*
     * Allocate space for the output and create the copy.  We could discount
     * whitespace chars to save some memory, but it doesn't seem worth the
     * trouble.
     */
    someval = guc_malloc(LOG, newvallen + 1 + 1);
    if (!someval)
        return false;
    for (i = 0, j = 0; i < newvallen; i++)
    {
        if ((*newval)[i] == ',')
            someval[j++] = '\0';    /* next item */
        else if ((*newval)[i] == ' ' ||
                 (*newval)[i] == '\n' ||
                 (*newval)[i] == '\t')
            ;                   /* ignore these */
        else
            someval[j++] = (*newval)[i];    /* copy anything else */
    }
 
    /* two \0s end the setting */
    someval[j] = '\0';
    someval[j + 1] = '\0';
 
    *extra = someval;
    return true;
}

References fb(), GUC_check_errdetail, guc_malloc(), i, j, LOG, and newval.

◆ check_bonjour()

bool check_bonjour	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1221 of file variable.c.

{
#ifndef USE_BONJOUR
    if (*newval)
    {
        GUC_check_errmsg("Bonjour is not supported by this build");
        return false;
    }
#endif
    return true;
}

References GUC_check_errmsg, and newval.

◆ check_canonical_path()

bool check_canonical_path	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1059 of file variable.c.

{
    /*
     * Since canonicalize_path never enlarges the string, we can just modify
     * newval in-place.  But watch out for NULL, which is the default value
     * for external_pid_file.
     */
    if (*newval)
        canonicalize_path(*newval);
    return true;
}

References canonicalize_path(), and newval.

◆ check_client_connection_check_interval()

bool check_client_connection_check_interval	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 3585 of file postgres.c.

{
    if (!WaitEventSetCanReportClosed() && *newval != 0)
    {
        GUC_check_errdetail("\"client_connection_check_interval\" must be set to 0 on this platform.");
        return false;
    }
    return true;
}

References GUC_check_errdetail, newval, and WaitEventSetCanReportClosed().

◆ check_client_encoding()

bool check_client_encoding	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 688 of file variable.c.

{
    int         encoding;
    const char *canonical_name;
 
    /* Look up the encoding by name */
    encoding = pg_valid_client_encoding(*newval);
    if (encoding < 0)
        return false;
 
    /* Get the canonical name (no aliases, uniform case) */
    canonical_name = pg_encoding_to_char(encoding);
 
    /*
     * Parallel workers send data to the leader, not the client.  They always
     * send data using the database encoding; therefore, we should never
     * actually change the client encoding in a parallel worker.  However,
     * during parallel worker startup, we want to accept the leader's
     * client_encoding setting so that anyone who looks at the value in the
     * worker sees the same value that they would see in the leader.  A change
     * other than during startup, for example due to a SET clause attached to
     * a function definition, should be rejected, as there is nothing we can
     * do inside the worker to make it take effect.
     */
    if (IsParallelWorker() && !InitializingParallelWorker)
    {
        GUC_check_errcode(ERRCODE_INVALID_TRANSACTION_STATE);
        GUC_check_errdetail("Cannot change \"client_encoding\" during a parallel operation.");
        return false;
    }
 
    /*
     * If we are not within a transaction then PrepareClientEncoding will not
     * be able to look up the necessary conversion procs.  If we are still
     * starting up, it will return "OK" anyway, and InitializeClientEncoding
     * will fix things once initialization is far enough along.  After
     * startup, we'll fail.  This would only happen if someone tries to change
     * client_encoding in postgresql.conf and then SIGHUP existing sessions.
     * It seems like a bad idea for client_encoding to change that way anyhow,
     * so we don't go out of our way to support it.
     *
     * In a parallel worker, we might as well skip PrepareClientEncoding since
     * we're not going to use its results.
     *
     * Note: in the postmaster, or any other process that never calls
     * InitializeClientEncoding, PrepareClientEncoding will always succeed,
     * and so will SetClientEncoding; but they won't do anything, which is OK.
     */
    if (!IsParallelWorker() &&
        PrepareClientEncoding(encoding) < 0)
    {
        if (IsTransactionState())
        {
            /* Must be a genuine no-such-conversion problem */
            GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
            GUC_check_errdetail("Conversion between %s and %s is not supported.",
                                canonical_name,
                                GetDatabaseEncodingName());
        }
        else
        {
            /* Provide a useful complaint */
            GUC_check_errdetail("Cannot change \"client_encoding\" now.");
        }
        return false;
    }
 
    /*
     * Replace the user-supplied string with the encoding's canonical name.
     * This gets rid of aliases and case-folding variations.
     *
     * XXX Although canonicalizing seems like a good idea in the abstract, it
     * breaks pre-9.1 JDBC drivers, which expect that if they send "UNICODE"
     * as the client_encoding setting then it will read back the same way. As
     * a workaround, don't replace the string if it's "UNICODE".  Remove that
     * hack when pre-9.1 JDBC drivers are no longer in use.
     */
    if (strcmp(*newval, canonical_name) != 0 &&
        strcmp(*newval, "UNICODE") != 0)
    {
        guc_free(*newval);
        *newval = guc_strdup(LOG, canonical_name);
        if (!*newval)
            return false;
    }
 
    /*
     * Save the encoding's ID in *extra, for use by assign_client_encoding.
     */
    *extra = guc_malloc(LOG, sizeof(int));
    if (!*extra)
        return false;
    *((int *) *extra) = encoding;
 
    return true;
}

References encoding, fb(), GetDatabaseEncodingName(), GUC_check_errcode(), GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), InitializingParallelWorker, IsParallelWorker, IsTransactionState(), LOG, newval, pg_encoding_to_char, pg_valid_client_encoding(), and PrepareClientEncoding().

◆ check_cluster_name()

bool check_cluster_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1118 of file variable.c.

{
    char       *clean;
    char       *ret;
 
    /* Only allow clean ASCII chars in the cluster name */
    clean = pg_clean_ascii(*newval, MCXT_ALLOC_NO_OOM);
    if (!clean)
        return false;
 
    ret = guc_strdup(LOG, clean);
    if (!ret)
    {
        pfree(clean);
        return false;
    }
 
    guc_free(*newval);
 
    pfree(clean);
    *newval = ret;
    return true;
}

References fb(), guc_free(), guc_strdup(), LOG, MCXT_ALLOC_NO_OOM, newval, pfree(), and pg_clean_ascii().

◆ check_commit_ts_buffers()

bool check_commit_ts_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 584 of file commit_ts.c.

{
    return check_slru_buffers("commit_timestamp_buffers", newval);
}

References check_slru_buffers(), and newval.

◆ check_datestyle()

bool check_datestyle	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 52 of file variable.c.

{
    int         newDateStyle = DateStyle;
    int         newDateOrder = DateOrder;
    bool        have_style = false;
    bool        have_order = false;
    bool        ok = true;
    char       *rawstring;
    int        *myextra;
    char       *result;
    List       *elemlist;
    ListCell   *l;
 
    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }
 
    foreach(l, elemlist)
    {
        char       *tok = (char *) lfirst(l);
 
        /* Ugh. Somebody ought to write a table driven version -- mjl */
 
        if (pg_strcasecmp(tok, "ISO") == 0)
        {
            if (have_style && newDateStyle != USE_ISO_DATES)
                ok = false;     /* conflicting styles */
            newDateStyle = USE_ISO_DATES;
            have_style = true;
        }
        else if (pg_strcasecmp(tok, "SQL") == 0)
        {
            if (have_style && newDateStyle != USE_SQL_DATES)
                ok = false;     /* conflicting styles */
            newDateStyle = USE_SQL_DATES;
            have_style = true;
        }
        else if (pg_strncasecmp(tok, "POSTGRES", 8) == 0)
        {
            if (have_style && newDateStyle != USE_POSTGRES_DATES)
                ok = false;     /* conflicting styles */
            newDateStyle = USE_POSTGRES_DATES;
            have_style = true;
        }
        else if (pg_strcasecmp(tok, "GERMAN") == 0)
        {
            if (have_style && newDateStyle != USE_GERMAN_DATES)
                ok = false;     /* conflicting styles */
            newDateStyle = USE_GERMAN_DATES;
            have_style = true;
            /* GERMAN also sets DMY, unless explicitly overridden */
            if (!have_order)
                newDateOrder = DATEORDER_DMY;
        }
        else if (pg_strcasecmp(tok, "YMD") == 0)
        {
            if (have_order && newDateOrder != DATEORDER_YMD)
                ok = false;     /* conflicting orders */
            newDateOrder = DATEORDER_YMD;
            have_order = true;
        }
        else if (pg_strcasecmp(tok, "DMY") == 0 ||
                 pg_strncasecmp(tok, "EURO", 4) == 0)
        {
            if (have_order && newDateOrder != DATEORDER_DMY)
                ok = false;     /* conflicting orders */
            newDateOrder = DATEORDER_DMY;
            have_order = true;
        }
        else if (pg_strcasecmp(tok, "MDY") == 0 ||
                 pg_strcasecmp(tok, "US") == 0 ||
                 pg_strncasecmp(tok, "NONEURO", 7) == 0)
        {
            if (have_order && newDateOrder != DATEORDER_MDY)
                ok = false;     /* conflicting orders */
            newDateOrder = DATEORDER_MDY;
            have_order = true;
        }
        else if (pg_strcasecmp(tok, "DEFAULT") == 0)
        {
            /*
             * Easiest way to get the current DEFAULT state is to fetch the
             * DEFAULT string from guc.c and recursively parse it.
             *
             * We can't simply "return check_datestyle(...)" because we need
             * to handle constructs like "DEFAULT, ISO".
             */
            char       *subval;
            void       *subextra = NULL;
 
            subval = guc_strdup(LOG, GetConfigOptionResetString("datestyle"));
            if (!subval)
            {
                ok = false;
                break;
            }
            if (!check_datestyle(&subval, &subextra, source))
            {
                guc_free(subval);
                ok = false;
                break;
            }
            myextra = (int *) subextra;
            if (!have_style)
                newDateStyle = myextra[0];
            if (!have_order)
                newDateOrder = myextra[1];
            guc_free(subval);
            guc_free(subextra);
        }
        else
        {
            GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
            pfree(rawstring);
            list_free(elemlist);
            return false;
        }
    }
 
    pfree(rawstring);
    list_free(elemlist);
 
    if (!ok)
    {
        GUC_check_errdetail("Conflicting \"DateStyle\" specifications.");
        return false;
    }
 
    /*
     * Prepare the canonical string to return.  GUC wants it guc_malloc'd.
     */
    result = (char *) guc_malloc(LOG, 32);
    if (!result)
        return false;
 
    switch (newDateStyle)
    {
        case USE_ISO_DATES:
            strcpy(result, "ISO");
            break;
        case USE_SQL_DATES:
            strcpy(result, "SQL");
            break;
        case USE_GERMAN_DATES:
            strcpy(result, "German");
            break;
        default:
            strcpy(result, "Postgres");
            break;
    }
    switch (newDateOrder)
    {
        case DATEORDER_YMD:
            strcat(result, ", YMD");
            break;
        case DATEORDER_DMY:
            strcat(result, ", DMY");
            break;
        default:
            strcat(result, ", MDY");
            break;
    }
 
    guc_free(*newval);
    *newval = result;
 
    /*
     * Set up the "extra" struct actually used by assign_datestyle.
     */
    myextra = (int *) guc_malloc(LOG, 2 * sizeof(int));
    if (!myextra)
        return false;
    myextra[0] = newDateStyle;
    myextra[1] = newDateOrder;
    *extra = myextra;
 
    return true;
}

References check_datestyle(), DateOrder, DATEORDER_DMY, DATEORDER_MDY, DATEORDER_YMD, DateStyle, fb(), GetConfigOptionResetString(), GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), lfirst, list_free(), LOG, newval, pfree(), pg_strcasecmp(), pg_strncasecmp(), pstrdup(), source, SplitIdentifierString(), USE_GERMAN_DATES, USE_ISO_DATES, USE_POSTGRES_DATES, and USE_SQL_DATES.

Referenced by check_datestyle().

◆ check_debug_io_direct()

bool check_debug_io_direct	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 3992 of file fd.c.

{
    bool        result = true;
    int         flags;
 
#if PG_O_DIRECT == 0
    if (strcmp(*newval, "") != 0)
    {
        GUC_check_errdetail("\"%s\" is not supported on this platform.",
                            "debug_io_direct");
        result = false;
    }
    flags = 0;
#else
    List       *elemlist;
    ListCell   *l;
    char       *rawstring;
 
    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);
 
    if (!SplitGUCList(rawstring, ',', &elemlist))
    {
        GUC_check_errdetail("Invalid list syntax in parameter \"%s\".",
                            "debug_io_direct");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }
 
    flags = 0;
    foreach(l, elemlist)
    {
        char       *item = (char *) lfirst(l);
 
        if (pg_strcasecmp(item, "data") == 0)
            flags |= IO_DIRECT_DATA;
        else if (pg_strcasecmp(item, "wal") == 0)
            flags |= IO_DIRECT_WAL;
        else if (pg_strcasecmp(item, "wal_init") == 0)
            flags |= IO_DIRECT_WAL_INIT;
        else
        {
            GUC_check_errdetail("Invalid option \"%s\".", item);
            result = false;
            break;
        }
    }
 
    /*
     * It's possible to configure block sizes smaller than our assumed I/O
     * alignment size, which could result in invalid I/O requests.
     */
#if XLOG_BLCKSZ < PG_IO_ALIGN_SIZE
    if (result && (flags & (IO_DIRECT_WAL | IO_DIRECT_WAL_INIT)))
    {
        GUC_check_errdetail("\"%s\" is not supported for WAL because %s is too small.",
                            "debug_io_direct", "XLOG_BLCKSZ");
        result = false;
    }
#endif
#if BLCKSZ < PG_IO_ALIGN_SIZE
    if (result && (flags & IO_DIRECT_DATA))
    {
        GUC_check_errdetail("\"%s\" is not supported for data because %s is too small.",
                            "debug_io_direct", "BLCKSZ");
        result = false;
    }
#endif
 
    pfree(rawstring);
    list_free(elemlist);
#endif
 
    if (!result)
        return result;
 
    /* Save the flags in *extra, for use by assign_debug_io_direct */
    *extra = guc_malloc(LOG, sizeof(int));
    if (!*extra)
        return false;
    *((int *) *extra) = flags;
 
    return result;
}

References fb(), GUC_check_errdetail, guc_malloc(), IO_DIRECT_DATA, IO_DIRECT_WAL, IO_DIRECT_WAL_INIT, lfirst, list_free(), LOG, newval, pfree(), pg_strcasecmp(), pstrdup(), and SplitGUCList().

◆ check_default_table_access_method()

bool check_default_table_access_method	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 101 of file tableamapi.c.

{
    if (**newval == '\0')
    {
        GUC_check_errdetail("\"%s\" cannot be empty.",
                            "default_table_access_method");
        return false;
    }
 
    if (strlen(*newval) >= NAMEDATALEN)
    {
        GUC_check_errdetail("\"%s\" is too long (maximum %d characters).",
                            "default_table_access_method", NAMEDATALEN - 1);
        return false;
    }
 
    /*
     * If we aren't inside a transaction, or not connected to a database, we
     * cannot do the catalog access necessary to verify the method.  Must
     * accept the value on faith.
     */
    if (IsTransactionState() && MyDatabaseId != InvalidOid)
    {
        if (!OidIsValid(get_table_am_oid(*newval, true)))
        {
            /*
             * When source == PGC_S_TEST, don't throw a hard error for a
             * nonexistent table access method, only a NOTICE. See comments in
             * guc.h.
             */
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("table access method \"%s\" does not exist",
                                *newval)));
            }
            else
            {
                GUC_check_errdetail("Table access method \"%s\" does not exist.",
                                    *newval);
                return false;
            }
        }
    }
 
    return true;
}

References ereport, errcode(), errmsg, fb(), get_table_am_oid(), GUC_check_errdetail, InvalidOid, IsTransactionState(), MyDatabaseId, NAMEDATALEN, newval, NOTICE, OidIsValid, PGC_S_TEST, and source.

◆ check_default_tablespace()

bool check_default_tablespace	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1104 of file tablespace.c.

{
    /*
     * If we aren't inside a transaction, or connected to a database, we
     * cannot do the catalog accesses necessary to verify the name.  Must
     * accept the value on faith.
     */
    if (IsTransactionState() && MyDatabaseId != InvalidOid)
    {
        if (**newval != '\0' &&
            !OidIsValid(get_tablespace_oid(*newval, true)))
        {
            /*
             * When source == PGC_S_TEST, don't throw a hard error for a
             * nonexistent tablespace, only a NOTICE.  See comments in guc.h.
             */
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("tablespace \"%s\" does not exist",
                                *newval)));
            }
            else
            {
                GUC_check_errdetail("Tablespace \"%s\" does not exist.",
                                    *newval);
                return false;
            }
        }
    }
 
    return true;
}

References ereport, errcode(), errmsg, fb(), get_tablespace_oid(), GUC_check_errdetail, InvalidOid, IsTransactionState(), MyDatabaseId, newval, NOTICE, OidIsValid, PGC_S_TEST, and source.

◆ check_default_text_search_config()

bool check_default_text_search_config	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 604 of file ts_cache.c.

{
    /*
     * If we aren't inside a transaction, or connected to a database, we
     * cannot do the catalog accesses necessary to verify the config name.
     * Must accept it on faith.
     */
    if (IsTransactionState() && MyDatabaseId != InvalidOid)
    {
        ErrorSaveContext escontext = {T_ErrorSaveContext};
        List       *namelist;
        Oid         cfgId;
        HeapTuple   tuple;
        Form_pg_ts_config cfg;
        char       *buf;
 
        namelist = stringToQualifiedNameList(*newval,
                                             (Node *) &escontext);
        if (namelist != NIL)
            cfgId = get_ts_config_oid(namelist, true);
        else
            cfgId = InvalidOid; /* bad name list syntax */
 
        /*
         * When source == PGC_S_TEST, don't throw a hard error for a
         * nonexistent configuration, only a NOTICE.  See comments in guc.h.
         */
        if (!OidIsValid(cfgId))
        {
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("text search configuration \"%s\" does not exist", *newval)));
                return true;
            }
            else
                return false;
        }
 
        /*
         * Modify the actually stored value to be fully qualified, to ensure
         * later changes of search_path don't affect it.
         */
        tuple = SearchSysCache1(TSCONFIGOID, ObjectIdGetDatum(cfgId));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for text search configuration %u",
                 cfgId);
        cfg = (Form_pg_ts_config) GETSTRUCT(tuple);
 
        buf = quote_qualified_identifier(get_namespace_name(cfg->cfgnamespace),
                                         NameStr(cfg->cfgname));
 
        ReleaseSysCache(tuple);
 
        /* GUC wants it guc_malloc'd not palloc'd */
        guc_free(*newval);
        *newval = guc_strdup(LOG, buf);
        pfree(buf);
        if (!*newval)
            return false;
    }
 
    return true;
}

References buf, elog, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_ts_config, get_namespace_name(), get_ts_config_oid(), GETSTRUCT(), guc_free(), guc_strdup(), HeapTupleIsValid, InvalidOid, IsTransactionState(), LOG, MyDatabaseId, NameStr, newval, NIL, NOTICE, ObjectIdGetDatum(), OidIsValid, pfree(), PGC_S_TEST, quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), source, and stringToQualifiedNameList().

◆ check_default_with_oids()

bool check_default_with_oids	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1234 of file variable.c.

{
    if (*newval)
    {
        /* check the GUC's definition for an explanation */
        GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
        GUC_check_errmsg("tables declared WITH OIDS are not supported");
 
        return false;
    }
 
    return true;
}

References fb(), GUC_check_errcode(), GUC_check_errmsg, and newval.

◆ check_huge_page_size()

bool check_huge_page_size	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 579 of file sysv_shmem.c.

{
#if !(defined(MAP_HUGE_MASK) && defined(MAP_HUGE_SHIFT))
    /* Recent enough Linux only, for now.  See GetHugePageSize(). */
    if (*newval != 0)
    {
        GUC_check_errdetail("\"huge_page_size\" must be 0 on this platform.");
        return false;
    }
#endif
    return true;
}

References GUC_check_errdetail, and newval.

◆ check_io_max_concurrency()

bool check_io_max_concurrency	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1331 of file aio.c.

{
    if (*newval == -1)
    {
        /*
         * Auto-tuning will be applied later during startup, as auto-tuning
         * depends on the value of various GUCs.
         */
        return true;
    }
    else if (*newval == 0)
    {
        GUC_check_errdetail("Only -1 or values bigger than 0 are valid.");
        return false;
    }
 
    return true;
}

References GUC_check_errdetail, and newval.

◆ check_locale_messages()

bool check_locale_messages	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 386 of file pg_locale.c.

{
    if (**newval == '\0')
    {
        if (source == PGC_S_DEFAULT)
            return true;
        else
            return false;
    }
 
    /*
     * LC_MESSAGES category does not exist everywhere, but accept it anyway
     *
     * On Windows, we can't even check the value, so accept blindly
     */
#if defined(LC_MESSAGES) && !defined(WIN32)
    return check_locale(LC_MESSAGES, *newval, NULL);
#else
    return true;
#endif
}

References check_locale(), fb(), newval, PGC_S_DEFAULT, and source.

◆ check_locale_monetary()

bool check_locale_monetary	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 340 of file pg_locale.c.

{
    return check_locale(LC_MONETARY, *newval, NULL);
}

References check_locale(), fb(), and newval.

◆ check_locale_numeric()

bool check_locale_numeric	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 352 of file pg_locale.c.

{
    return check_locale(LC_NUMERIC, *newval, NULL);
}

References check_locale(), fb(), and newval.

◆ check_locale_time()

bool check_locale_time	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 364 of file pg_locale.c.

{
    return check_locale(LC_TIME, *newval, NULL);
}

References check_locale(), fb(), and newval.

◆ check_log_connections()

bool check_log_connections	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1082 of file backend_startup.c.

{
    uint32      flags;
    char       *rawstring;
    List       *elemlist;
    bool        success;
 
    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);
 
    if (!SplitIdentifierString(rawstring, ',', &elemlist))
    {
        GUC_check_errdetail("Invalid list syntax in parameter \"%s\".", "log_connections");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }
 
    /* Validation logic is all in the helper */
    success = validate_log_connections_options(elemlist, &flags);
 
    /* Time for cleanup */
    pfree(rawstring);
    list_free(elemlist);
 
    if (!success)
        return false;
 
    /*
     * We succeeded, so allocate `extra` and save the flags there for use by
     * assign_log_connections().
     */
    *extra = guc_malloc(LOG, sizeof(int));
    if (!*extra)
        return false;
    *((int *) *extra) = flags;
 
    return true;
}

References fb(), GUC_check_errdetail, guc_malloc(), list_free(), LOG, newval, pfree(), pstrdup(), SplitIdentifierString(), success, and validate_log_connections_options().

◆ check_log_destination()

bool check_log_destination	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 2677 of file elog.c.

{
    char       *rawstring;
    List       *elemlist;
    ListCell   *l;
    int         newlogdest = 0;
    int        *myextra;
 
    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }
 
    foreach(l, elemlist)
    {
        char       *tok = (char *) lfirst(l);
 
        if (pg_strcasecmp(tok, "stderr") == 0)
            newlogdest |= LOG_DESTINATION_STDERR;
        else if (pg_strcasecmp(tok, "csvlog") == 0)
            newlogdest |= LOG_DESTINATION_CSVLOG;
        else if (pg_strcasecmp(tok, "jsonlog") == 0)
            newlogdest |= LOG_DESTINATION_JSONLOG;
#ifdef HAVE_SYSLOG
        else if (pg_strcasecmp(tok, "syslog") == 0)
            newlogdest |= LOG_DESTINATION_SYSLOG;
#endif
#ifdef WIN32
        else if (pg_strcasecmp(tok, "eventlog") == 0)
            newlogdest |= LOG_DESTINATION_EVENTLOG;
#endif
        else
        {
            GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
            pfree(rawstring);
            list_free(elemlist);
            return false;
        }
    }
 
    pfree(rawstring);
    list_free(elemlist);
 
    myextra = (int *) guc_malloc(LOG, sizeof(int));
    if (!myextra)
        return false;
    *myextra = newlogdest;
    *extra = myextra;
 
    return true;
}

References fb(), GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG, LOG_DESTINATION_CSVLOG, LOG_DESTINATION_EVENTLOG, LOG_DESTINATION_JSONLOG, LOG_DESTINATION_STDERR, LOG_DESTINATION_SYSLOG, newval, pfree(), pg_strcasecmp(), pstrdup(), and SplitIdentifierString().

◆ check_log_min_messages()

bool check_log_min_messages	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 2362 of file elog.c.

{
    char       *rawstring;
    List       *elemlist;
    StringInfoData buf;
    char       *result;
    int         newlevel[BACKEND_NUM_TYPES];
    bool        assigned[BACKEND_NUM_TYPES] = {0};
    int         defaultlevel = -1;  /* -1 means not assigned */
 
    const char *const process_types[] = {
#define PG_PROCTYPE(bktype, bkcategory, description, main_func, shmem_attach) \
        [bktype] = bkcategory,
#include "postmaster/proctypelist.h"
#undef PG_PROCTYPE
    };
 
    /* Need a modifiable copy of string. */
    rawstring = guc_strdup(LOG, *newval);
    if (rawstring == NULL)
        return false;
 
    /* Parse the string into a list. */
    if (!SplitGUCList(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        list_free(elemlist);
        guc_free(rawstring);
        return false;
    }
 
    /* Validate and assign log level and process type. */
    foreach_ptr(char, elem, elemlist)
    {
        char       *sep = strchr(elem, ':');
 
        /*
         * If there's no ':' separator in the entry, this is the default log
         * level.  Otherwise it's a process type-specific entry.
         */
        if (sep == NULL)
        {
            const struct config_enum_entry *entry;
            bool        found;
 
            /* Reject duplicates for default log level. */
            if (defaultlevel != -1)
            {
                GUC_check_errdetail("Redundant specification of default log level.");
                goto lmm_fail;
            }
 
            /* Validate the log level */
            found = false;
            for (entry = server_message_level_options; entry && entry->name; entry++)
            {
                if (pg_strcasecmp(entry->name, elem) == 0)
                {
                    defaultlevel = entry->val;
                    found = true;
                    break;
                }
            }
 
            if (!found)
            {
                GUC_check_errdetail("Unrecognized log level: \"%s\".", elem);
                goto lmm_fail;
            }
        }
        else
        {
            char       *loglevel = sep + 1;
            char       *ptype = elem;
            bool        found;
            int         level;
            const struct config_enum_entry *entry;
 
            /*
             * Temporarily clobber the ':' with a string terminator, so that
             * we can validate it.  We restore this at the bottom.
             */
            *sep = '\0';
 
            /* Validate the log level */
            found = false;
            for (entry = server_message_level_options; entry && entry->name; entry++)
            {
                if (pg_strcasecmp(entry->name, loglevel) == 0)
                {
                    level = entry->val;
                    found = true;
                    break;
                }
            }
 
            if (!found)
            {
                GUC_check_errdetail("Unrecognized log level for process type \"%s\": \"%s\".",
                                    ptype, loglevel);
                goto lmm_fail;
            }
 
            /* Is the process type name valid and unique? */
            found = false;
            for (int i = 0; i < BACKEND_NUM_TYPES; i++)
            {
                if (pg_strcasecmp(process_types[i], ptype) == 0)
                {
                    /* Reject duplicates for a process type. */
                    if (assigned[i])
                    {
                        GUC_check_errdetail("Redundant log level specification for process type \"%s\".",
                                            ptype);
                        goto lmm_fail;
                    }
 
                    newlevel[i] = level;
                    assigned[i] = true;
                    found = true;
 
                    /*
                     * note: we must keep looking! some process types appear
                     * multiple times in proctypelist.h.
                     */
                }
            }
 
            if (!found)
            {
                GUC_check_errdetail("Unrecognized process type \"%s\".", ptype);
                goto lmm_fail;
            }
 
            /* Put the separator back in place */
            *sep = ':';
        }
 
        /* all good */
        continue;
 
lmm_fail:
        guc_free(rawstring);
        list_free(elemlist);
        return false;
    }
 
    /*
     * The default log level must be specified. It is the fallback value.
     */
    if (defaultlevel == -1)
    {
        GUC_check_errdetail("Default log level was not defined.");
        guc_free(rawstring);
        list_free(elemlist);
        return false;
    }
 
    /* Apply the default log level to all processes not listed. */
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
    {
        if (!assigned[i])
            newlevel[i] = defaultlevel;
    }
 
    /*
     * Save an ordered representation of the user-specified string, for the
     * show_hook.
     */
    list_sort(elemlist, log_min_messages_cmp);
 
    initStringInfoExt(&buf, strlen(rawstring) + 1);
    foreach_ptr(char, elem, elemlist)
    {
        if (foreach_current_index(elem) == 0)
            appendStringInfoString(&buf, elem);
        else
            appendStringInfo(&buf, ", %s", elem);
    }
 
    result = guc_strdup(LOG, buf.data);
    if (!result)
    {
        pfree(buf.data);
        return false;
    }
 
    guc_free(*newval);
    *newval = result;
 
    guc_free(rawstring);
    list_free(elemlist);
    pfree(buf.data);
 
    /*
     * Pass back data for assign_log_min_messages to use.
     */
    *extra = guc_malloc(LOG, BACKEND_NUM_TYPES * sizeof(int));
    if (!*extra)
        return false;
    memcpy(*extra, newlevel, BACKEND_NUM_TYPES * sizeof(int));
 
    return true;
}

References appendStringInfo(), appendStringInfoString(), BACKEND_NUM_TYPES, buf, fb(), foreach_current_index, foreach_ptr, GUC_check_errdetail, guc_free(), guc_malloc(), guc_strdup(), i, initStringInfoExt(), list_free(), list_sort(), LOG, log_min_messages_cmp(), config_enum_entry::name, newval, pfree(), pg_strcasecmp(), server_message_level_options, SplitGUCList(), and config_enum_entry::val.

◆ check_log_stats()

bool check_log_stats	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 3620 of file postgres.c.

{
    if (*newval &&
        (log_parser_stats || log_planner_stats || log_executor_stats))
    {
        GUC_check_errdetail("Cannot enable \"log_statement_stats\" when "
                            "\"log_parser_stats\", \"log_planner_stats\", "
                            "or \"log_executor_stats\" is true.");
        return false;
    }
    return true;
}

References GUC_check_errdetail, log_executor_stats, log_parser_stats, log_planner_stats, and newval.

◆ check_log_timezone()

bool check_log_timezone	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 418 of file variable.c.

{
    pg_tz      *new_tz;
 
    /*
     * Assume it is a timezone name, and try to load it.
     */
    new_tz = pg_tzset(*newval);
 
    if (!new_tz)
    {
        /* Doesn't seem to be any great value in errdetail here */
        return false;
    }
 
    if (!pg_tz_acceptable(new_tz))
    {
        GUC_check_errmsg("time zone \"%s\" appears to use leap seconds",
                         *newval);
        GUC_check_errdetail("PostgreSQL does not support leap seconds.");
        return false;
    }
 
    /*
     * Pass back data for assign_log_timezone to use
     */
    *extra = guc_malloc(LOG, sizeof(pg_tz *));
    if (!*extra)
        return false;
    *((pg_tz **) *extra) = new_tz;
 
    return true;
}

References fb(), GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), LOG, newval, pg_tz_acceptable(), and pg_tzset().

◆ check_max_stack_depth()

bool check_max_stack_depth	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 142 of file stack_depth.c.

{
    ssize_t     newval_bytes = *newval * (ssize_t) 1024;
    ssize_t     stack_rlimit = get_stack_depth_rlimit();
 
    if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP)
    {
        GUC_check_errdetail("\"max_stack_depth\" must not exceed %zdkB.",
                            (stack_rlimit - STACK_DEPTH_SLOP) / 1024);
        GUC_check_errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent.");
        return false;
    }
    return true;
}

References fb(), get_stack_depth_rlimit(), GUC_check_errdetail, GUC_check_errhint, newval, and STACK_DEPTH_SLOP.

◆ check_multixact_member_buffers()

bool check_multixact_member_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1840 of file multixact.c.

{
    return check_slru_buffers("multixact_member_buffers", newval);
}

References check_slru_buffers(), and newval.

◆ check_multixact_offset_buffers()

bool check_multixact_offset_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1831 of file multixact.c.

{
    return check_slru_buffers("multixact_offset_buffers", newval);
}

References check_slru_buffers(), and newval.

◆ check_notify_buffers()

bool check_notify_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 3298 of file async.c.

{
    return check_slru_buffers("notify_buffers", newval);
}

References check_slru_buffers(), and newval.

◆ check_primary_slot_name()

bool check_primary_slot_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4745 of file xlogrecovery.c.

{
    int         err_code;
    char       *err_msg = NULL;
    char       *err_hint = NULL;
 
    if (*newval && strcmp(*newval, "") != 0 &&
        !ReplicationSlotValidateNameInternal(*newval, false, &err_code,
                                             &err_msg, &err_hint))
    {
        GUC_check_errcode(err_code);
        GUC_check_errdetail("%s", err_msg);
        if (err_hint != NULL)
            GUC_check_errhint("%s", err_hint);
        return false;
    }
 
    return true;
}

References fb(), GUC_check_errcode(), GUC_check_errdetail, GUC_check_errhint, newval, and ReplicationSlotValidateNameInternal().

◆ check_random_seed()

bool check_random_seed	(	double *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 656 of file variable.c.

{
    *extra = guc_malloc(LOG, sizeof(int));
    if (!*extra)
        return false;
    /* Arm the assign only if source of value is an interactive SET */
    *((int *) *extra) = (source >= PGC_S_INTERACTIVE);
 
    return true;
}

References guc_malloc(), LOG, PGC_S_INTERACTIVE, and source.

◆ check_recovery_prefetch()

bool check_recovery_prefetch	(	int *	new_value,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1083 of file xlogprefetcher.c.

{
#ifndef USE_PREFETCH
    if (*new_value == RECOVERY_PREFETCH_ON)
    {
        GUC_check_errdetail("\"recovery_prefetch\" is not supported on platforms that lack support for issuing read-ahead advice.");
        return false;
    }
#endif
 
    return true;
}

References fb(), GUC_check_errdetail, and RECOVERY_PREFETCH_ON.

◆ check_recovery_target()

bool check_recovery_target	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4796 of file xlogrecovery.c.

{
    if (strcmp(*newval, "immediate") != 0 && strcmp(*newval, "") != 0)
    {
        GUC_check_errdetail("The only allowed value is \"immediate\".");
        return false;
    }
    return true;
}

References fb(), GUC_check_errdetail, and newval.

◆ check_recovery_target_lsn()

bool check_recovery_target_lsn	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4826 of file xlogrecovery.c.

{
    if (strcmp(*newval, "") != 0)
    {
        XLogRecPtr  lsn;
        XLogRecPtr *myextra;
        ErrorSaveContext escontext = {T_ErrorSaveContext};
 
        lsn = pg_lsn_in_safe(*newval, (Node *) &escontext);
        if (escontext.error_occurred)
            return false;
 
        myextra = (XLogRecPtr *) guc_malloc(LOG, sizeof(XLogRecPtr));
        if (!myextra)
            return false;
        *myextra = lsn;
        *extra = myextra;
    }
    return true;
}

References ErrorSaveContext::error_occurred, fb(), guc_malloc(), LOG, newval, and pg_lsn_in_safe().

◆ check_recovery_target_name()

bool check_recovery_target_name	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4870 of file xlogrecovery.c.

{
    /* Use the value of newval directly */
    if (strlen(*newval) >= MAXFNAMELEN)
    {
        GUC_check_errdetail("\"%s\" is too long (maximum %d characters).",
                            "recovery_target_name", MAXFNAMELEN - 1);
        return false;
    }
    return true;
}

References fb(), GUC_check_errdetail, MAXFNAMELEN, and newval.

◆ check_recovery_target_time()

bool check_recovery_target_time	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4911 of file xlogrecovery.c.

{
    if (strcmp(*newval, "") != 0)
    {
        /* reject some special values */
        if (strcmp(*newval, "now") == 0 ||
            strcmp(*newval, "today") == 0 ||
            strcmp(*newval, "tomorrow") == 0 ||
            strcmp(*newval, "yesterday") == 0)
        {
            return false;
        }
 
        /*
         * parse timestamp value (see also timestamptz_in())
         */
        {
            char       *str = *newval;
            fsec_t      fsec;
            struct pg_tm tt,
                       *tm = &tt;
            int         tz;
            int         dtype;
            int         nf;
            int         dterr;
            char       *field[MAXDATEFIELDS];
            int         ftype[MAXDATEFIELDS];
            char        workbuf[MAXDATELEN + MAXDATEFIELDS];
            DateTimeErrorExtra dtextra;
            TimestampTz timestamp;
 
            dterr = ParseDateTime(str, workbuf, sizeof(workbuf),
                                  field, ftype, MAXDATEFIELDS, &nf);
            if (dterr == 0)
                dterr = DecodeDateTime(field, ftype, nf,
                                       &dtype, tm, &fsec, &tz, &dtextra);
            if (dterr != 0)
                return false;
            if (dtype != DTK_DATE)
                return false;
 
            if (tm2timestamp(tm, fsec, &tz, &timestamp) != 0)
            {
                GUC_check_errdetail("Timestamp out of range: \"%s\".", str);
                return false;
            }
        }
    }
    return true;
}

References DecodeDateTime(), DTK_DATE, fb(), GUC_check_errdetail, MAXDATEFIELDS, MAXDATELEN, newval, ParseDateTime(), str, tm, and tm2timestamp().

◆ check_recovery_target_timeline()

bool check_recovery_target_timeline	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4982 of file xlogrecovery.c.

{
    RecoveryTargetTimeLineGoal rttg;
    RecoveryTargetTimeLineGoal *myextra;
 
    if (strcmp(*newval, "current") == 0)
        rttg = RECOVERY_TARGET_TIMELINE_CONTROLFILE;
    else if (strcmp(*newval, "latest") == 0)
        rttg = RECOVERY_TARGET_TIMELINE_LATEST;
    else
    {
        char       *endp;
        uint64      timeline;
 
        rttg = RECOVERY_TARGET_TIMELINE_NUMERIC;
 
        errno = 0;
        timeline = strtou64(*newval, &endp, 0);
 
        if (*endp != '\0' || errno == EINVAL || errno == ERANGE)
        {
            GUC_check_errdetail("\"%s\" is not a valid number.",
                                "recovery_target_timeline");
            return false;
        }
 
        if (timeline < 1 || timeline > PG_UINT32_MAX)
        {
            GUC_check_errdetail("\"%s\" must be between %u and %u.",
                                "recovery_target_timeline", 1, PG_UINT32_MAX);
            return false;
        }
    }
 
    myextra = (RecoveryTargetTimeLineGoal *) guc_malloc(LOG, sizeof(RecoveryTargetTimeLineGoal));
    if (!myextra)
        return false;
    *myextra = rttg;
    *extra = myextra;
 
    return true;
}

References fb(), GUC_check_errdetail, guc_malloc(), LOG, newval, PG_UINT32_MAX, RECOVERY_TARGET_TIMELINE_CONTROLFILE, RECOVERY_TARGET_TIMELINE_LATEST, and RECOVERY_TARGET_TIMELINE_NUMERIC.

◆ check_recovery_target_xid()

bool check_recovery_target_xid	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 5042 of file xlogrecovery.c.

{
    if (strcmp(*newval, "") != 0)
    {
        TransactionId xid;
        TransactionId *myextra;
        char       *endp;
        char       *val;
 
        errno = 0;
 
        /*
         * Consume leading whitespace to determine if number is negative
         */
        val = *newval;
 
        while (isspace((unsigned char) *val))
            val++;
 
        /*
         * This cast will remove the epoch, if any
         */
        xid = (TransactionId) strtou64(val, &endp, 0);
 
        if (*endp != '\0' || errno == EINVAL || errno == ERANGE || *val == '-')
        {
            GUC_check_errdetail("\"%s\" is not a valid number.",
                                "recovery_target_xid");
            return false;
        }
 
        if (xid < FirstNormalTransactionId)
        {
            GUC_check_errdetail("\"%s\" without epoch must be greater than or equal to %u.",
                                "recovery_target_xid",
                                FirstNormalTransactionId);
            return false;
        }
 
        myextra = (TransactionId *) guc_malloc(LOG, sizeof(TransactionId));
        if (!myextra)
            return false;
        *myextra = xid;
        *extra = myextra;
    }
    return true;
}

References fb(), FirstNormalTransactionId, GUC_check_errdetail, guc_malloc(), LOG, newval, and val.

◆ check_restrict_nonsystem_relation_kind()

bool check_restrict_nonsystem_relation_kind	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 3654 of file postgres.c.

{
    char       *rawstring;
    List       *elemlist;
    ListCell   *l;
    int         flags = 0;
 
    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);
 
    if (!SplitIdentifierString(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }
 
    foreach(l, elemlist)
    {
        char       *tok = (char *) lfirst(l);
 
        if (pg_strcasecmp(tok, "view") == 0)
            flags |= RESTRICT_RELKIND_VIEW;
        else if (pg_strcasecmp(tok, "foreign-table") == 0)
            flags |= RESTRICT_RELKIND_FOREIGN_TABLE;
        else
        {
            GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
            pfree(rawstring);
            list_free(elemlist);
            return false;
        }
    }
 
    pfree(rawstring);
    list_free(elemlist);
 
    /* Save the flags in *extra, for use by the assign function */
    *extra = guc_malloc(LOG, sizeof(int));
    if (!*extra)
        return false;
    *((int *) *extra) = flags;
 
    return true;
}

References fb(), GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG, newval, pfree(), pg_strcasecmp(), pstrdup(), RESTRICT_RELKIND_FOREIGN_TABLE, RESTRICT_RELKIND_VIEW, and SplitIdentifierString().

◆ check_role()

bool check_role	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 933 of file variable.c.

{
    HeapTuple   roleTup;
    Oid         roleid;
    bool        is_superuser;
    role_auth_extra *myextra;
    Form_pg_authid roleform;
 
    if (strcmp(*newval, "none") == 0)
    {
        /* hardwired translation */
        roleid = InvalidOid;
        is_superuser = false;
    }
    else if (InitializingParallelWorker)
    {
        /*
         * In parallel worker initialization, we want to copy the leader's
         * state even if it no longer matches the catalogs. ParallelWorkerMain
         * already installed the correct role OID and superuser state.
         */
        roleid = GetCurrentRoleId();
        is_superuser = current_role_is_superuser;
    }
    else
    {
        if (!IsTransactionState())
        {
            /*
             * Can't do catalog lookups, so fail.  The result of this is that
             * role cannot be set in postgresql.conf, which seems like a good
             * thing anyway, so we don't work hard to avoid it.
             */
            return false;
        }
 
        /*
         * When source == PGC_S_TEST, we don't throw a hard error for a
         * nonexistent user name or insufficient privileges, only a NOTICE.
         * See comments in guc.h.
         */
 
        /* Look up the username */
        roleTup = SearchSysCache1(AUTHNAME, PointerGetDatum(*newval));
        if (!HeapTupleIsValid(roleTup))
        {
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("role \"%s\" does not exist", *newval)));
                return true;
            }
            GUC_check_errmsg("role \"%s\" does not exist", *newval);
            return false;
        }
 
        roleform = (Form_pg_authid) GETSTRUCT(roleTup);
        roleid = roleform->oid;
        is_superuser = roleform->rolsuper;
 
        ReleaseSysCache(roleTup);
 
        /* Verify that session user is allowed to become this role */
        if (!member_can_set_role(GetSessionUserId(), roleid))
        {
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission will be denied to set role \"%s\"",
                                *newval)));
                return true;
            }
            GUC_check_errcode(ERRCODE_INSUFFICIENT_PRIVILEGE);
            GUC_check_errmsg("permission denied to set role \"%s\"",
                             *newval);
            return false;
        }
    }
 
    /* Set up "extra" struct for assign_role to use */
    myextra = (role_auth_extra *) guc_malloc(LOG, sizeof(role_auth_extra));
    if (!myextra)
        return false;
    myextra->roleid = roleid;
    myextra->is_superuser = is_superuser;
    *extra = myextra;
 
    return true;
}

References current_role_is_superuser, ereport, errcode(), errmsg, fb(), Form_pg_authid, GetCurrentRoleId(), GetSessionUserId(), GETSTRUCT(), GUC_check_errcode(), GUC_check_errmsg, guc_malloc(), HeapTupleIsValid, InitializingParallelWorker, InvalidOid, is_superuser(), IsTransactionState(), LOG, member_can_set_role(), newval, NOTICE, PGC_S_TEST, PointerGetDatum(), ReleaseSysCache(), SearchSysCache1(), and source.

◆ check_search_path()

bool check_search_path	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4729 of file namespace.c.

{
    Oid         roleid = InvalidOid;
    const char *searchPath = *newval;
    char       *rawname;
    List       *namelist;
    bool        use_cache = (SearchPathCacheContext != NULL);
 
    /*
     * We used to try to check that the named schemas exist, but there are
     * many valid use-cases for having search_path settings that include
     * schemas that don't exist; and often, we are not inside a transaction
     * here and so can't consult the system catalogs anyway.  So now, the only
     * requirement is syntactic validity of the identifier list.
     *
     * Checking only the syntactic validity also allows us to use the search
     * path cache (if available) to avoid calling SplitIdentifierString() on
     * the same string repeatedly.
     */
    if (use_cache)
    {
        spcache_init();
 
        roleid = GetUserId();
 
        if (spcache_lookup(searchPath, roleid) != NULL)
            return true;
    }
 
    /*
     * Ensure validity check succeeds before creating cache entry.
     */
 
    rawname = pstrdup(searchPath);  /* need a modifiable copy */
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawname, ',', &namelist))
    {
        /* syntax error in name list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawname);
        list_free(namelist);
        return false;
    }
    pfree(rawname);
    list_free(namelist);
 
    /* OK to create empty cache entry */
    if (use_cache)
        (void) spcache_insert(searchPath, roleid);
 
    return true;
}

References fb(), GetUserId(), GUC_check_errdetail, InvalidOid, list_free(), newval, pfree(), pstrdup(), SearchPathCacheContext, spcache_init(), spcache_insert(), spcache_lookup(), and SplitIdentifierString().

◆ check_serial_buffers()

bool check_serial_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 858 of file predicate.c.

{
    return check_slru_buffers("serializable_buffers", newval);
}

References check_slru_buffers(), and newval.

◆ check_session_authorization()

bool check_session_authorization	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 815 of file variable.c.

{
    HeapTuple   roleTup;
    Form_pg_authid roleform;
    Oid         roleid;
    bool        is_superuser;
    role_auth_extra *myextra;
 
    /* Do nothing for the boot_val default of NULL */
    if (*newval == NULL)
        return true;
 
    if (InitializingParallelWorker)
    {
        /*
         * In parallel worker initialization, we want to copy the leader's
         * state even if it no longer matches the catalogs. ParallelWorkerMain
         * already installed the correct role OID and superuser state.
         */
        roleid = GetSessionUserId();
        is_superuser = GetSessionUserIsSuperuser();
    }
    else
    {
        if (!IsTransactionState())
        {
            /*
             * Can't do catalog lookups, so fail.  The result of this is that
             * session_authorization cannot be set in postgresql.conf, which
             * seems like a good thing anyway, so we don't work hard to avoid
             * it.
             */
            return false;
        }
 
        /*
         * When source == PGC_S_TEST, we don't throw a hard error for a
         * nonexistent user name or insufficient privileges, only a NOTICE.
         * See comments in guc.h.
         */
 
        /* Look up the username */
        roleTup = SearchSysCache1(AUTHNAME, PointerGetDatum(*newval));
        if (!HeapTupleIsValid(roleTup))
        {
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("role \"%s\" does not exist", *newval)));
                return true;
            }
            GUC_check_errmsg("role \"%s\" does not exist", *newval);
            return false;
        }
 
        roleform = (Form_pg_authid) GETSTRUCT(roleTup);
        roleid = roleform->oid;
        is_superuser = roleform->rolsuper;
 
        ReleaseSysCache(roleTup);
 
        /*
         * Only superusers may SET SESSION AUTHORIZATION a role other than
         * itself. Note that in case of multiple SETs in a single session, the
         * original authenticated user's superuserness is what matters.
         */
        if (roleid != GetAuthenticatedUserId() &&
            !superuser_arg(GetAuthenticatedUserId()))
        {
            if (source == PGC_S_TEST)
            {
                ereport(NOTICE,
                        (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                         errmsg("permission will be denied to set session authorization \"%s\"",
                                *newval)));
                return true;
            }
            GUC_check_errcode(ERRCODE_INSUFFICIENT_PRIVILEGE);
            GUC_check_errmsg("permission denied to set session authorization \"%s\"",
                             *newval);
            return false;
        }
    }
 
    /* Set up "extra" struct for assign_session_authorization to use */
    myextra = (role_auth_extra *) guc_malloc(LOG, sizeof(role_auth_extra));
    if (!myextra)
        return false;
    myextra->roleid = roleid;
    myextra->is_superuser = is_superuser;
    *extra = myextra;
 
    return true;
}

References ereport, errcode(), errmsg, fb(), Form_pg_authid, GetAuthenticatedUserId(), GetSessionUserId(), GetSessionUserIsSuperuser(), GETSTRUCT(), GUC_check_errcode(), GUC_check_errmsg, guc_malloc(), HeapTupleIsValid, InitializingParallelWorker, is_superuser(), IsTransactionState(), LOG, newval, NOTICE, PGC_S_TEST, PointerGetDatum(), ReleaseSysCache(), SearchSysCache1(), source, and superuser_arg().

◆ check_ssl()

bool check_ssl	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1249 of file variable.c.

{
#ifndef USE_SSL
    if (*newval)
    {
        GUC_check_errmsg("SSL is not supported by this build");
        return false;
    }
#endif
    return true;
}

References GUC_check_errmsg, and newval.

◆ check_ssl_sni()

bool check_ssl_sni	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1262 of file variable.c.

{
#ifndef USE_SSL
    if (*newval)
    {
        GUC_check_errmsg("SSL is not supported by this build");
        return false;
    }
#else
#ifndef HAVE_SSL_CTX_SET_CLIENT_HELLO_CB
    if (*newval)
    {
        GUC_check_errmsg("SNI requires OpenSSL 1.1.1 or later");
        return false;
    }
#endif
#endif
    return true;
}

References GUC_check_errmsg, and newval.

◆ check_stage_log_stats()

bool check_stage_log_stats	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 3606 of file postgres.c.

{
    if (*newval && log_statement_stats)
    {
        GUC_check_errdetail("Cannot enable parameter when \"log_statement_stats\" is true.");
        return false;
    }
    return true;
}

References GUC_check_errdetail, log_statement_stats, and newval.

◆ check_standard_conforming_strings()

bool check_standard_conforming_strings	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1283 of file variable.c.

{
    if (!*newval)
    {
        /* check the GUC's definition for an explanation */
        GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
        GUC_check_errmsg("non-standard string literals are not supported");
 
        return false;
    }
 
    return true;
}

References fb(), GUC_check_errcode(), GUC_check_errmsg, and newval.

◆ check_subtrans_buffers()

bool check_subtrans_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 255 of file subtrans.c.

{
    return check_slru_buffers("subtransaction_buffers", newval);
}

References check_slru_buffers(), and newval.

◆ check_synchronized_standby_slots()

bool check_synchronized_standby_slots	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 2989 of file slot.c.

{
    char       *rawname;
    char       *ptr;
    List       *elemlist;
    int         size;
    bool        ok;
    SyncStandbySlotsConfigData *config;
 
    if ((*newval)[0] == '\0')
        return true;
 
    /* Need a modifiable copy of the GUC string */
    rawname = pstrdup(*newval);
 
    /* Now verify if the specified slots exist and have correct type */
    ok = validate_sync_standby_slots(rawname, &elemlist);
 
    if (!ok || elemlist == NIL)
    {
        pfree(rawname);
        list_free(elemlist);
        return ok;
    }
 
    /* Compute the size required for the SyncStandbySlotsConfigData struct */
    size = offsetof(SyncStandbySlotsConfigData, slot_names);
    foreach_ptr(char, slot_name, elemlist)
        size += strlen(slot_name) + 1;
 
    /* GUC extra value must be guc_malloc'd, not palloc'd */
    config = (SyncStandbySlotsConfigData *) guc_malloc(LOG, size);
    if (!config)
        return false;
 
    /* Transform the data into SyncStandbySlotsConfigData */
    config->nslotnames = list_length(elemlist);
 
    ptr = config->slot_names;
    foreach_ptr(char, slot_name, elemlist)
    {
        strcpy(ptr, slot_name);
        ptr += strlen(slot_name) + 1;
    }
 
    *extra = config;
 
    pfree(rawname);
    list_free(elemlist);
    return true;
}

References fb(), foreach_ptr, guc_malloc(), list_free(), list_length(), LOG, newval, NIL, SyncStandbySlotsConfigData::nslotnames, pfree(), pstrdup(), SyncStandbySlotsConfigData::slot_names, and validate_sync_standby_slots().

◆ check_synchronous_standby_names()

bool check_synchronous_standby_names	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1058 of file syncrep.c.

{
    if (*newval != NULL && (*newval)[0] != '\0')
    {
        yyscan_t    scanner;
        int         parse_rc;
        SyncRepConfigData *pconf;
 
        /* Result of parsing is returned in one of these two variables */
        SyncRepConfigData *syncrep_parse_result = NULL;
        char       *syncrep_parse_error_msg = NULL;
 
        /* Parse the synchronous_standby_names string */
        syncrep_scanner_init(*newval, &scanner);
        parse_rc = syncrep_yyparse(&syncrep_parse_result, &syncrep_parse_error_msg, scanner);
        syncrep_scanner_finish(scanner);
 
        if (parse_rc != 0 || syncrep_parse_result == NULL)
        {
            GUC_check_errcode(ERRCODE_SYNTAX_ERROR);
            if (syncrep_parse_error_msg)
                GUC_check_errdetail("%s", syncrep_parse_error_msg);
            else
                /* translator: %s is a GUC name */
                GUC_check_errdetail("\"%s\" parser failed.",
                                    "synchronous_standby_names");
            return false;
        }
 
        if (syncrep_parse_result->num_sync <= 0)
        {
            GUC_check_errmsg("number of synchronous standbys (%d) must be greater than zero",
                             syncrep_parse_result->num_sync);
            return false;
        }
 
        /* GUC extra value must be guc_malloc'd, not palloc'd */
        pconf = (SyncRepConfigData *)
            guc_malloc(LOG, syncrep_parse_result->config_size);
        if (pconf == NULL)
            return false;
        memcpy(pconf, syncrep_parse_result, syncrep_parse_result->config_size);
 
        *extra = pconf;
 
        /*
         * We need not explicitly clean up syncrep_parse_result.  It, and any
         * other cruft generated during parsing, will be freed when the
         * current memory context is deleted.  (This code is generally run in
         * a short-lived context used for config file processing, so that will
         * not be very long.)
         */
    }
    else
        *extra = NULL;
 
    return true;
}

References fb(), GUC_check_errcode(), GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), LOG, newval, syncrep_scanner_finish(), syncrep_scanner_init(), and syncrep_yyparse().

◆ check_temp_buffers()

bool check_temp_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 877 of file localbuf.c.

{
    /*
     * Once local buffers have been initialized, it's too late to change this.
     * However, if this is only a test call, allow it.
     */
    if (source != PGC_S_TEST && NLocBuffer && NLocBuffer != *newval)
    {
        GUC_check_errdetail("\"temp_buffers\" cannot be changed after any temporary tables have been accessed in the session.");
        return false;
    }
    return true;
}

References GUC_check_errdetail, newval, NLocBuffer, PGC_S_TEST, and source.

◆ check_temp_tablespaces()

bool check_temp_tablespaces	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 1211 of file tablespace.c.

{
    char       *rawname;
    List       *namelist;
 
    /* Need a modifiable copy of string */
    rawname = pstrdup(*newval);
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawname, ',', &namelist))
    {
        /* syntax error in name list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawname);
        list_free(namelist);
        return false;
    }
 
    /*
     * If we aren't inside a transaction, or connected to a database, we
     * cannot do the catalog accesses necessary to verify the name.  Must
     * accept the value on faith. Fortunately, there's then also no need to
     * pass the data to fd.c.
     */
    if (IsTransactionState() && MyDatabaseId != InvalidOid)
    {
        temp_tablespaces_extra *myextra;
        Oid        *tblSpcs;
        int         numSpcs;
        ListCell   *l;
 
        /* temporary workspace until we are done verifying the list */
        tblSpcs = (Oid *) palloc(list_length(namelist) * sizeof(Oid));
        numSpcs = 0;
        foreach(l, namelist)
        {
            char       *curname = (char *) lfirst(l);
            Oid         curoid;
            AclResult   aclresult;
 
            /* Allow an empty string (signifying database default) */
            if (curname[0] == '\0')
            {
                /* InvalidOid signifies database's default tablespace */
                tblSpcs[numSpcs++] = InvalidOid;
                continue;
            }
 
            /*
             * In an interactive SET command, we ereport for bad info.  When
             * source == PGC_S_TEST, don't throw a hard error for a
             * nonexistent tablespace, only a NOTICE.  See comments in guc.h.
             */
            curoid = get_tablespace_oid(curname, source <= PGC_S_TEST);
            if (curoid == InvalidOid)
            {
                if (source == PGC_S_TEST)
                    ereport(NOTICE,
                            (errcode(ERRCODE_UNDEFINED_OBJECT),
                             errmsg("tablespace \"%s\" does not exist",
                                    curname)));
                continue;
            }
 
            /*
             * Allow explicit specification of database's default tablespace
             * in temp_tablespaces without triggering permissions checks.
             */
            if (curoid == MyDatabaseTableSpace)
            {
                /* InvalidOid signifies database's default tablespace */
                tblSpcs[numSpcs++] = InvalidOid;
                continue;
            }
 
            /* Check permissions, similarly complaining only if interactive */
            aclresult = object_aclcheck(TableSpaceRelationId, curoid, GetUserId(),
                                        ACL_CREATE);
            if (aclresult != ACLCHECK_OK)
            {
                if (source >= PGC_S_INTERACTIVE)
                    aclcheck_error(aclresult, OBJECT_TABLESPACE, curname);
                continue;
            }
 
            tblSpcs[numSpcs++] = curoid;
        }
 
        /* Now prepare an "extra" struct for assign_temp_tablespaces */
        myextra = guc_malloc(LOG, offsetof(temp_tablespaces_extra, tblSpcs) +
                             numSpcs * sizeof(Oid));
        if (!myextra)
            return false;
        myextra->numSpcs = numSpcs;
        memcpy(myextra->tblSpcs, tblSpcs, numSpcs * sizeof(Oid));
        *extra = myextra;
 
        pfree(tblSpcs);
    }
 
    pfree(rawname);
    list_free(namelist);
 
    return true;
}

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, ereport, errcode(), errmsg, fb(), get_tablespace_oid(), GetUserId(), GUC_check_errdetail, guc_malloc(), InvalidOid, IsTransactionState(), lfirst, list_free(), list_length(), LOG, MyDatabaseId, MyDatabaseTableSpace, newval, NOTICE, object_aclcheck(), OBJECT_TABLESPACE, palloc(), pfree(), PGC_S_INTERACTIVE, PGC_S_TEST, pstrdup(), source, and SplitIdentifierString().

◆ check_timezone()

bool check_timezone	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 261 of file variable.c.

{
    pg_tz      *new_tz;
    long        gmtoffset;
    char       *endptr;
    double      hours;
 
    if (pg_strncasecmp(*newval, "interval", 8) == 0)
    {
        /*
         * Support INTERVAL 'foo'.  This is for SQL spec compliance, not
         * because it has any actual real-world usefulness.
         */
        const char *valueptr = *newval;
        char       *val;
        Interval   *interval;
 
        valueptr += 8;
        while (isspace((unsigned char) *valueptr))
            valueptr++;
        if (*valueptr++ != '\'')
            return false;
        val = pstrdup(valueptr);
        /* Check and remove trailing quote */
        endptr = strchr(val, '\'');
        if (!endptr || endptr[1] != '\0')
        {
            pfree(val);
            return false;
        }
        *endptr = '\0';
 
        /*
         * Try to parse it.  XXX an invalid interval format will result in
         * ereport(ERROR), which is not desirable for GUC.  We did what we
         * could to guard against this in flatten_set_variable_args, but a
         * string coming in from postgresql.conf might contain anything.
         */
        interval = DatumGetIntervalP(DirectFunctionCall3(interval_in,
                                                         CStringGetDatum(val),
                                                         ObjectIdGetDatum(InvalidOid),
                                                         Int32GetDatum(-1)));
 
        pfree(val);
        if (interval->month != 0)
        {
            GUC_check_errdetail("Cannot specify months in time zone interval.");
            pfree(interval);
            return false;
        }
        if (interval->day != 0)
        {
            GUC_check_errdetail("Cannot specify days in time zone interval.");
            pfree(interval);
            return false;
        }
 
        /* Here we change from SQL to Unix sign convention */
        gmtoffset = -(interval->time / USECS_PER_SEC);
        new_tz = pg_tzset_offset(gmtoffset);
 
        pfree(interval);
    }
    else
    {
        /*
         * Try it as a numeric number of hours (possibly fractional).
         */
        hours = strtod(*newval, &endptr);
        if (endptr != *newval && *endptr == '\0')
        {
            /* Here we change from SQL to Unix sign convention */
            gmtoffset = -hours * SECS_PER_HOUR;
            new_tz = pg_tzset_offset(gmtoffset);
        }
        else
        {
            /*
             * Otherwise assume it is a timezone name, and try to load it.
             */
            new_tz = pg_tzset(*newval);
 
            if (!new_tz)
            {
                /* Doesn't seem to be any great value in errdetail here */
                return false;
            }
 
            if (!pg_tz_acceptable(new_tz))
            {
                GUC_check_errmsg("time zone \"%s\" appears to use leap seconds",
                                 *newval);
                GUC_check_errdetail("PostgreSQL does not support leap seconds.");
                return false;
            }
        }
    }
 
    /* Test for failure in pg_tzset_offset, which we assume is out-of-range */
    if (!new_tz)
    {
        GUC_check_errdetail("UTC timezone offset is out of range.");
        return false;
    }
 
    /*
     * Pass back data for assign_timezone to use
     */
    *extra = guc_malloc(LOG, sizeof(pg_tz *));
    if (!*extra)
        return false;
    *((pg_tz **) *extra) = new_tz;
 
    return true;
}

References CStringGetDatum(), DatumGetIntervalP(), DirectFunctionCall3, fb(), GUC_check_errdetail, GUC_check_errmsg, guc_malloc(), Int32GetDatum(), interval_in(), InvalidOid, LOG, interval::month, newval, ObjectIdGetDatum(), pfree(), pg_strncasecmp(), pg_tz_acceptable(), pg_tzset(), pg_tzset_offset(), pstrdup(), SECS_PER_HOUR, interval::time, USECS_PER_SEC, and val.

◆ check_timezone_abbreviations()

bool check_timezone_abbreviations	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 487 of file variable.c.

{
    /*
     * The boot_val for timezone_abbreviations is NULL.  When we see that we
     * just do nothing.  If the value isn't overridden from the config file
     * then pg_timezone_abbrev_initialize() will eventually replace it with
     * "Default".  This hack has two purposes: to avoid wasting cycles loading
     * values that might soon be overridden from the config file, and to avoid
     * trying to read the timezone abbrev files during InitializeGUCOptions().
     * The latter doesn't work in an EXEC_BACKEND subprocess because
     * my_exec_path hasn't been set yet and so we can't locate PGSHAREDIR.
     */
    if (*newval == NULL)
    {
        Assert(source == PGC_S_DEFAULT);
        return true;
    }
 
    /* OK, load the file and produce a guc_malloc'd TimeZoneAbbrevTable */
    *extra = load_tzoffsets(*newval);
 
    /* tzparser.c returns NULL on failure, reporting via GUC_check_errmsg */
    if (!*extra)
        return false;
 
    return true;
}

References Assert, fb(), load_tzoffsets(), newval, PGC_S_DEFAULT, and source.

◆ check_transaction_buffers()

bool check_transaction_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 822 of file clog.c.

{
    return check_slru_buffers("transaction_buffers", newval);
}

References check_slru_buffers(), and newval.

◆ check_transaction_deferrable()

bool check_transaction_deferrable	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 624 of file variable.c.

{
    /* Just accept the value when restoring state in a parallel worker */
    if (InitializingParallelWorker)
        return true;
 
    if (IsSubTransaction())
    {
        GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
        GUC_check_errmsg("SET TRANSACTION [NOT] DEFERRABLE cannot be called within a subtransaction");
        return false;
    }
    if (FirstSnapshotSet)
    {
        GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
        GUC_check_errmsg("SET TRANSACTION [NOT] DEFERRABLE must be called before any query");
        return false;
    }
 
    return true;
}

References fb(), FirstSnapshotSet, GUC_check_errcode(), GUC_check_errmsg, InitializingParallelWorker, and IsSubTransaction().

◆ check_transaction_isolation()

bool check_transaction_isolation	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 586 of file variable.c.

{
    int         newXactIsoLevel = *newval;
 
    if (newXactIsoLevel != XactIsoLevel &&
        IsTransactionState() && !InitializingParallelWorker)
    {
        if (FirstSnapshotSet)
        {
            GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
            GUC_check_errmsg("SET TRANSACTION ISOLATION LEVEL must be called before any query");
            return false;
        }
        /* We ignore a subtransaction setting it to the existing value. */
        if (IsSubTransaction())
        {
            GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
            GUC_check_errmsg("SET TRANSACTION ISOLATION LEVEL must not be called in a subtransaction");
            return false;
        }
        /* Can't go to serializable mode while recovery is still active */
        if (newXactIsoLevel == XACT_SERIALIZABLE && RecoveryInProgress())
        {
            GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
            GUC_check_errmsg("cannot use serializable mode in a hot standby");
            GUC_check_errhint("You can use REPEATABLE READ instead.");
            return false;
        }
    }
 
    return true;
}

References fb(), FirstSnapshotSet, GUC_check_errcode(), GUC_check_errhint, GUC_check_errmsg, InitializingParallelWorker, IsSubTransaction(), IsTransactionState(), newval, RecoveryInProgress(), XACT_SERIALIZABLE, and XactIsoLevel.

◆ check_transaction_read_only()

bool check_transaction_read_only	(	bool *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 546 of file variable.c.

{
    if (*newval == false && XactReadOnly && IsTransactionState() && !InitializingParallelWorker)
    {
        /* Can't go to r/w mode inside a r/o transaction */
        if (IsSubTransaction())
        {
            GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
            GUC_check_errmsg("cannot set transaction read-write mode inside a read-only transaction");
            return false;
        }
        /* Top level transaction can't change to r/w after first snapshot. */
        if (FirstSnapshotSet)
        {
            GUC_check_errcode(ERRCODE_ACTIVE_SQL_TRANSACTION);
            GUC_check_errmsg("transaction read-write mode must be set before any query");
            return false;
        }
        /* Can't go to r/w mode while recovery is still active */
        if (RecoveryInProgress())
        {
            GUC_check_errcode(ERRCODE_FEATURE_NOT_SUPPORTED);
            GUC_check_errmsg("cannot set transaction read-write mode during recovery");
            return false;
        }
    }
 
    return true;
}

References fb(), FirstSnapshotSet, GUC_check_errcode(), GUC_check_errmsg, InitializingParallelWorker, IsSubTransaction(), IsTransactionState(), newval, RecoveryInProgress(), and XactReadOnly.

◆ check_vacuum_buffer_usage_limit()

bool check_vacuum_buffer_usage_limit	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 140 of file vacuum.c.

{
    /* Value upper and lower hard limits are inclusive */
    if (*newval == 0 || (*newval >= MIN_BAS_VAC_RING_SIZE_KB &&
                         *newval <= MAX_BAS_VAC_RING_SIZE_KB))
        return true;
 
    /* Value does not fall within any allowable range */
    GUC_check_errdetail("\"%s\" must be 0 or between %d kB and %d kB.",
                        "vacuum_buffer_usage_limit",
                        MIN_BAS_VAC_RING_SIZE_KB, MAX_BAS_VAC_RING_SIZE_KB);
 
    return false;
}

References GUC_check_errdetail, MAX_BAS_VAC_RING_SIZE_KB, MIN_BAS_VAC_RING_SIZE_KB, and newval.

◆ check_wal_buffers()

bool check_wal_buffers	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4693 of file xlog.c.

{
    /*
     * -1 indicates a request for auto-tune.
     */
    if (*newval == -1)
    {
        /*
         * If we haven't yet changed the boot_val default of -1, just let it
         * be.  We'll fix it when XLOGShmemSize is called.
         */
        if (XLOGbuffers == -1)
            return true;
 
        /* Otherwise, substitute the auto-tune value */
        *newval = XLOGChooseNumBuffers();
    }
 
    /*
     * We clamp manually-set values to at least 4 blocks.  Prior to PostgreSQL
     * 9.1, a minimum of 4 was enforced by guc.c, but since that is no longer
     * the case, we just silently treat such values as a request for the
     * minimum.  (We could throw an error instead, but that doesn't seem very
     * helpful.)
     */
    if (*newval < 4)
        *newval = 4;
 
    return true;
}

References newval, XLOGbuffers, and XLOGChooseNumBuffers().

◆ check_wal_consistency_checking()

bool check_wal_consistency_checking	(	char **	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 4728 of file xlog.c.

{
    char       *rawstring;
    List       *elemlist;
    ListCell   *l;
    bool        newwalconsistency[RM_MAX_ID + 1];
 
    /* Initialize the array */
    MemSet(newwalconsistency, 0, (RM_MAX_ID + 1) * sizeof(bool));
 
    /* Need a modifiable copy of string */
    rawstring = pstrdup(*newval);
 
    /* Parse string into list of identifiers */
    if (!SplitIdentifierString(rawstring, ',', &elemlist))
    {
        /* syntax error in list */
        GUC_check_errdetail("List syntax is invalid.");
        pfree(rawstring);
        list_free(elemlist);
        return false;
    }
 
    foreach(l, elemlist)
    {
        char       *tok = (char *) lfirst(l);
        int         rmid;
 
        /* Check for 'all'. */
        if (pg_strcasecmp(tok, "all") == 0)
        {
            for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
                if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL)
                    newwalconsistency[rmid] = true;
        }
        else
        {
            /* Check if the token matches any known resource manager. */
            bool        found = false;
 
            for (rmid = 0; rmid <= RM_MAX_ID; rmid++)
            {
                if (RmgrIdExists(rmid) && GetRmgr(rmid).rm_mask != NULL &&
                    pg_strcasecmp(tok, GetRmgr(rmid).rm_name) == 0)
                {
                    newwalconsistency[rmid] = true;
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                /*
                 * During startup, it might be a not-yet-loaded custom
                 * resource manager.  Defer checking until
                 * InitializeWalConsistencyChecking().
                 */
                if (!process_shared_preload_libraries_done)
                {
                    check_wal_consistency_checking_deferred = true;
                }
                else
                {
                    GUC_check_errdetail("Unrecognized key word: \"%s\".", tok);
                    pfree(rawstring);
                    list_free(elemlist);
                    return false;
                }
            }
        }
    }
 
    pfree(rawstring);
    list_free(elemlist);
 
    /* assign new value */
    *extra = guc_malloc(LOG, (RM_MAX_ID + 1) * sizeof(bool));
    if (!*extra)
        return false;
    memcpy(*extra, newwalconsistency, (RM_MAX_ID + 1) * sizeof(bool));
    return true;
}

References check_wal_consistency_checking_deferred, fb(), GetRmgr(), GUC_check_errdetail, guc_malloc(), lfirst, list_free(), LOG, MemSet, newval, pfree(), pg_strcasecmp(), process_shared_preload_libraries_done, pstrdup(), RmgrData::rm_mask, RM_MAX_ID, RmgrIdExists(), and SplitIdentifierString().

◆ check_wal_segment_size()

bool check_wal_segment_size	(	int *	newval,
		void **	extra,
		GucSource	source
	)

extern

Definition at line 2201 of file xlog.c.

{
    if (!IsValidWalSegSize(*newval))
    {
        GUC_check_errdetail("The WAL segment size must be a power of two between 1 MB and 1 GB.");
        return false;
    }
 
    return true;
}

References GUC_check_errdetail, IsValidWalSegSize, and newval.

◆ show_archive_command()

const char * show_archive_command ( void )

extern

Definition at line 4868 of file xlog.c.

{
    if (XLogArchivingActive())
        return XLogArchiveCommand;
    else
        return "(disabled)";
}

References XLogArchiveCommand, and XLogArchivingActive.

◆ show_data_directory_mode()

const char * show_data_directory_mode ( void )

extern

Definition at line 1182 of file variable.c.

{
    static char buf[12];
 
    snprintf(buf, sizeof(buf), "%04o", data_directory_mode);
    return buf;
}

References buf, data_directory_mode, and snprintf.

◆ show_effective_wal_level()

const char * show_effective_wal_level ( void )

extern

Definition at line 4895 of file xlog.c.

{
    if (wal_level == WAL_LEVEL_MINIMAL)
        return "minimal";
 
    /*
     * During recovery, effective_wal_level reflects the primary's
     * configuration rather than the local wal_level value.
     */
    if (RecoveryInProgress())
        return IsXLogLogicalInfoEnabled() ? "logical" : "replica";
 
    return XLogLogicalInfoActive() ? "logical" : "replica";
}

References IsXLogLogicalInfoEnabled(), RecoveryInProgress(), wal_level, WAL_LEVEL_MINIMAL, and XLogLogicalInfoActive.

◆ show_in_hot_standby()

const char * show_in_hot_standby ( void )

extern

Definition at line 4880 of file xlog.c.

{
    /*
     * We display the actual state based on shared memory, so that this GUC
     * reports up-to-date state if examined intra-query.  The underlying
     * variable (in_hot_standby_guc) changes only when we transmit a new value
     * to the client.
     */
    return RecoveryInProgress() ? "on" : "off";
}

References RecoveryInProgress().

◆ show_log_file_mode()

const char * show_log_file_mode ( void )

extern

Definition at line 1194 of file variable.c.

{
    static char buf[12];
 
    snprintf(buf, sizeof(buf), "%04o", Log_file_mode);
    return buf;
}

References buf, Log_file_mode, and snprintf.

◆ show_log_timezone()

const char * show_log_timezone ( void )

extern

Definition at line 465 of file variable.c.

{
    const char *tzn;
 
    /* Always show the zone's canonical name */
    tzn = pg_get_timezone_name(log_timezone);
 
    if (tzn != NULL)
        return tzn;
 
    return "unknown";
}

References fb(), log_timezone, and pg_get_timezone_name().

◆ show_random_seed()

const char * show_random_seed ( void )

extern

Definition at line 677 of file variable.c.

{
    return "unavailable";
}

◆ show_role()

const char * show_role ( void )

extern

Definition at line 1034 of file variable.c.

{
    /*
     * Check whether SET ROLE is active; if not return "none".  This is a
     * kluge to deal with the fact that SET SESSION AUTHORIZATION logically
     * resets SET ROLE to NONE, but we cannot set the GUC role variable from
     * assign_session_authorization (because we haven't got enough info to
     * call set_config_option).
     */
    if (!OidIsValid(GetCurrentRoleId()))
        return "none";
 
    /* Otherwise we can just use the GUC string */
    return role_string ? role_string : "none";
}

References GetCurrentRoleId(), OidIsValid, and role_string.

◆ show_tcp_keepalives_count()

const char * show_tcp_keepalives_count ( void )

extern

Definition at line 2021 of file pqcomm.c.

{
    /* See comments in assign_tcp_keepalives_idle */
    static char nbuf[16];
 
    snprintf(nbuf, sizeof(nbuf), "%d", pq_getkeepalivescount(MyProcPort));
    return nbuf;
}

References fb(), MyProcPort, pq_getkeepalivescount(), and snprintf.

◆ show_tcp_keepalives_idle()

const char * show_tcp_keepalives_idle ( void )

extern

Definition at line 1975 of file pqcomm.c.

{
    /* See comments in assign_tcp_keepalives_idle */
    static char nbuf[16];
 
    snprintf(nbuf, sizeof(nbuf), "%d", pq_getkeepalivesidle(MyProcPort));
    return nbuf;
}

References fb(), MyProcPort, pq_getkeepalivesidle(), and snprintf.

◆ show_tcp_keepalives_interval()

const char * show_tcp_keepalives_interval ( void )

extern

Definition at line 1998 of file pqcomm.c.

{
    /* See comments in assign_tcp_keepalives_idle */
    static char nbuf[16];
 
    snprintf(nbuf, sizeof(nbuf), "%d", pq_getkeepalivesinterval(MyProcPort));
    return nbuf;
}

References fb(), MyProcPort, pq_getkeepalivesinterval(), and snprintf.

◆ show_tcp_user_timeout()

const char * show_tcp_user_timeout ( void )

extern

Definition at line 2044 of file pqcomm.c.

{
    /* See comments in assign_tcp_keepalives_idle */
    static char nbuf[16];
 
    snprintf(nbuf, sizeof(nbuf), "%d", pq_gettcpusertimeout(MyProcPort));
    return nbuf;
}

References fb(), MyProcPort, pq_gettcpusertimeout(), and snprintf.

◆ show_timezone()

const char * show_timezone ( void )

extern

Definition at line 392 of file variable.c.

{
    const char *tzn;
 
    /* Always show the zone's canonical name */
    tzn = pg_get_timezone_name(session_timezone);
 
    if (tzn != NULL)
        return tzn;
 
    return "unknown";
}

References fb(), pg_get_timezone_name(), and session_timezone.

◆ show_unix_socket_permissions()

const char * show_unix_socket_permissions ( void )

extern

Definition at line 1206 of file variable.c.

{
    static char buf[12];
 
    snprintf(buf, sizeof(buf), "%04o", Unix_socket_permissions);
    return buf;
}

References buf, snprintf, and Unix_socket_permissions.

Functions

Function Documentation

◆ assign_application_name()

◆ assign_backtrace_functions()

◆ assign_checkpoint_completion_target()

◆ assign_client_encoding()

◆ assign_datestyle()

◆ assign_debug_io_direct()

◆ assign_default_text_search_config()

◆ assign_io_combine_limit()

◆ assign_io_max_combine_limit()

◆ assign_io_method()

◆ assign_locale_messages()

◆ assign_locale_monetary()

◆ assign_locale_numeric()

◆ assign_locale_time()

◆ assign_log_connections()

◆ assign_log_destination()

◆ assign_log_min_messages()

◆ assign_log_timezone()

◆ assign_maintenance_io_concurrency()

◆ assign_max_stack_depth()

◆ assign_max_wal_size()

◆ assign_random_seed()

◆ assign_recovery_prefetch()

◆ assign_recovery_target()

◆ assign_recovery_target_lsn()

◆ assign_recovery_target_name()

◆ assign_recovery_target_time()

◆ assign_recovery_target_timeline()

◆ assign_recovery_target_xid()

◆ assign_restrict_nonsystem_relation_kind()

◆ assign_role()

◆ assign_search_path()

◆ assign_session_authorization()

◆ assign_session_replication_role()

◆ assign_stats_fetch_consistency()

◆ assign_synchronized_standby_slots()

◆ assign_synchronous_commit()

◆ assign_synchronous_standby_names()

◆ assign_syslog_facility()

◆ assign_syslog_ident()

◆ assign_tcp_keepalives_count()

◆ assign_tcp_keepalives_idle()

◆ assign_tcp_keepalives_interval()

◆ assign_tcp_user_timeout()

◆ assign_temp_tablespaces()

◆ assign_timezone()

◆ assign_timezone_abbreviations()

◆ assign_transaction_timeout()

◆ assign_wal_consistency_checking()

◆ assign_wal_sync_method()

◆ check_application_name()

◆ check_autovacuum_work_mem()

◆ check_backtrace_functions()

◆ check_bonjour()

◆ check_canonical_path()

◆ check_client_connection_check_interval()

◆ check_client_encoding()

◆ check_cluster_name()

◆ check_commit_ts_buffers()

◆ check_datestyle()

◆ check_debug_io_direct()

◆ check_default_table_access_method()

◆ check_default_tablespace()

◆ check_default_text_search_config()

◆ check_default_with_oids()

◆ check_huge_page_size()

◆ check_io_max_concurrency()

◆ check_locale_messages()

◆ check_locale_monetary()

◆ check_locale_numeric()

◆ check_locale_time()

◆ check_log_connections()

◆ check_log_destination()

◆ check_log_min_messages()

◆ check_log_stats()

◆ check_log_timezone()

◆ check_max_stack_depth()

◆ check_multixact_member_buffers()