variables.c File Reference

#include "postgres_fe.h"
#include <math.h>
#include "common.h"
#include "common/logging.h"
#include "variables.h"

Include dependency graph for variables.c:

Go to the source code of this file.

Functions
static bool	valid_variable_name (const char *name)
VariableSpace	CreateVariableSpace (void)
const char *	GetVariable (VariableSpace space, const char *name)
bool	ParseVariableBool (const char *value, const char *name, bool *result)
bool	ParseVariableNum (const char *value, const char *name, int *result)
bool	ParseVariableDouble (const char *value, const char *name, double *result, double min, double max)
void	PrintVariables (VariableSpace space)
bool	SetVariable (VariableSpace space, const char *name, const char *value)
void	SetVariableHooks (VariableSpace space, const char *name, VariableSubstituteHook shook, VariableAssignHook ahook)
bool	VariableHasHook (VariableSpace space, const char *name)
bool	SetVariableBool (VariableSpace space, const char *name)
bool	DeleteVariable (VariableSpace space, const char *name)
void	PsqlVarEnumError (const char *name, const char *value, const char *suggestions)

Function Documentation

CreateVariableSpace()

VariableSpace CreateVariableSpace

(

void

)

Definition at line 53 of file variables.c.

{
    struct _variable *ptr;
 
    ptr = pg_malloc(sizeof *ptr);
    ptr->name = NULL;
    ptr->value = NULL;
    ptr->substitute_hook = NULL;
    ptr->assign_hook = NULL;
    ptr->next = NULL;
 
    return ptr;
}

References _variable::assign_hook, _variable::name, _variable::next, pg_malloc(), _variable::substitute_hook, and _variable::value.

Referenced by EstablishVariableSpace().

DeleteVariable()

bool DeleteVariable	(	VariableSpace	space,
		const char *	name
	)

Definition at line 474 of file variables.c.

{
    return SetVariable(space, name, NULL);
}

References name, and SetVariable().

Referenced by parse_psql_options().

GetVariable()

const char * GetVariable	(	VariableSpace	space,
		const char *	name
	)

Definition at line 73 of file variables.c.

{
    struct _variable *current;
 
    if (!space)
        return NULL;
 
    for (current = space->next; current; current = current->next)
    {
        int         cmp = strcmp(current->name, name);
 
        if (cmp == 0)
        {
            /* this is correct answer when value is NULL, too */
            return current->value;
        }
        if (cmp > 0)
            break;              /* it's not there */
    }
 
    return NULL;
}

References cmp(), name, _variable::name, _variable::next, and _variable::value.

Referenced by get_prompt(), initializeInput(), and psql_get_variable().

ParseVariableBool()

bool ParseVariableBool	(	const char *	value,
		const char *	name,
		bool *	result
	)

Definition at line 109 of file variables.c.

{
    size_t      len;
    bool        valid = true;
 
    /* Treat "unset" as an empty string, which will lead to error below */
    if (value == NULL)
        value = "";
 
    len = strlen(value);
 
    if (len > 0 && pg_strncasecmp(value, "true", len) == 0)
        *result = true;
    else if (len > 0 && pg_strncasecmp(value, "false", len) == 0)
        *result = false;
    else if (len > 0 && pg_strncasecmp(value, "yes", len) == 0)
        *result = true;
    else if (len > 0 && pg_strncasecmp(value, "no", len) == 0)
        *result = false;
    /* 'o' is not unique enough */
    else if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
        *result = true;
    else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
        *result = false;
    else if (pg_strcasecmp(value, "1") == 0)
        *result = true;
    else if (pg_strcasecmp(value, "0") == 0)
        *result = false;
    else
    {
        /* string is not recognized; don't clobber *result */
        if (name)
            pg_log_error("unrecognized value \"%s\" for \"%s\": Boolean expected",
                         value, name);
        valid = false;
    }
    return valid;
}

References len, name, pg_log_error, pg_strcasecmp(), pg_strncasecmp(), and value.

Referenced by autocommit_hook(), do_pset(), echo_hidden_hook(), exec_command_connect(), exec_command_timing(), hide_compression_hook(), hide_tableam_hook(), is_true_boolean_expression(), on_error_rollback_hook(), on_error_stop_hook(), quiet_hook(), show_all_results_hook(), singleline_hook(), and singlestep_hook().

ParseVariableDouble()

bool ParseVariableDouble	(	const char *	value,
		const char *	name,
		double *	result,
		double	min,
		double	max
	)

Definition at line 195 of file variables.c.

{
    char       *end;
    double      dblval;
 
    /*
     * Empty-string input has historically been treated differently by strtod
     * on various platforms, so handle that by specifically checking for it.
     */
    if ((value == NULL) || (*value == '\0'))
    {
        if (name)
            pg_log_error("invalid input syntax for \"%s\"", name);
        return false;
    }
 
    errno = 0;
    dblval = strtod(value, &end);
    if (errno == 0 && *end == '\0' && end != value)
    {
        if (dblval < min)
        {
            if (name)
                pg_log_error("invalid value \"%s\" for \"%s\": must be greater than %.2f",
                             value, name, min);
            return false;
        }
        else if (dblval > max)
        {
            if (name)
                pg_log_error("invalid value \"%s\" for \"%s\": must be less than %.2f",
                             value, name, max);
        }
        *result = dblval;
        return true;
    }
 
    /*
     * Cater for platforms which treat values which aren't zero, but that are
     * too close to zero to have full precision, by checking for zero or real
     * out-of-range values.
     */
    else if ((errno == ERANGE) &&
             (dblval == 0.0 || dblval >= HUGE_VAL || dblval <= -HUGE_VAL))
    {
        if (name)
            pg_log_error("\"%s\" is out of range for \"%s\"", value, name);
        return false;
    }
    else
    {
        if (name)
            pg_log_error("invalid value \"%s\" for \"%s\"", value, name);
        return false;
    }
}

References name, pg_log_error, and value.

Referenced by watch_interval_hook().

ParseVariableNum()

bool ParseVariableNum	(	const char *	value,
		const char *	name,
		int *	result
	)

Definition at line 158 of file variables.c.

{
    char       *end;
    long        numval;
 
    /* Treat "unset" as an empty string, which will lead to error below */
    if (value == NULL)
        value = "";
 
    errno = 0;
    numval = strtol(value, &end, 0);
    if (errno == 0 && *end == '\0' && end != value && numval == (int) numval)
    {
        *result = (int) numval;
        return true;
    }
    else
    {
        /* string is not recognized; don't clobber *result */
        if (name)
            pg_log_error("invalid value \"%s\" for \"%s\": integer expected",
                         value, name);
        return false;
    }
}

References name, pg_log_error, and value.

Referenced by do_pset(), fetch_count_hook(), histsize_hook(), ignoreeof_hook(), and ignoreeof_substitute_hook().

PrintVariables()

void PrintVariables

(

VariableSpace

space

)

Definition at line 256 of file variables.c.

{
    struct _variable *ptr;
 
    if (!space)
        return;
 
    for (ptr = space->next; ptr; ptr = ptr->next)
    {
        if (ptr->value)
            printf("%s = '%s'\n", ptr->name, ptr->value);
        if (cancel_pressed)
            break;
    }
}

References cancel_pressed, _variable::name, _variable::next, printf, and _variable::value.

Referenced by exec_command_set().

PsqlVarEnumError()

void PsqlVarEnumError	(	const char *	name,
		const char *	value,
		const char *	suggestions
	)

Definition at line 486 of file variables.c.

{
    pg_log_error("unrecognized value \"%s\" for \"%s\"\n"
                 "Available values are: %s.",
                 value, name, suggestions);
}

References name, pg_log_error, and value.

Referenced by comp_keyword_case_hook(), do_pset(), echo_hidden_hook(), echo_hook(), histcontrol_hook(), on_error_rollback_hook(), show_context_hook(), and verbosity_hook().

SetVariable()

bool SetVariable	(	VariableSpace	space,
		const char *	name,
		const char *	value
	)

Definition at line 281 of file variables.c.

{
    struct _variable *current,
               *previous;
 
    if (!space || !name)
        return false;
 
    if (!valid_variable_name(name))
    {
        /* Deletion of non-existent variable is not an error */
        if (!value)
            return true;
        pg_log_error("invalid variable name: \"%s\"", name);
        return false;
    }
 
    for (previous = space, current = space->next;
         current;
         previous = current, current = current->next)
    {
        int         cmp = strcmp(current->name, name);
 
        if (cmp == 0)
        {
            /*
             * Found entry, so update, unless assign hook returns false.
             *
             * We must duplicate the passed value to start with.  This
             * simplifies the API for substitute hooks.  Moreover, some assign
             * hooks assume that the passed value has the same lifespan as the
             * variable.  Having to free the string again on failure is a
             * small price to pay for keeping these APIs simple.
             */
            char       *new_value = value ? pg_strdup(value) : NULL;
            bool        confirmed;
 
            if (current->substitute_hook)
                new_value = current->substitute_hook(new_value);
 
            if (current->assign_hook)
                confirmed = current->assign_hook(new_value);
            else
                confirmed = true;
 
            if (confirmed)
            {
                pg_free(current->value);
                current->value = new_value;
 
                /*
                 * If we deleted the value, and there are no hooks to
                 * remember, we can discard the variable altogether.
                 */
                if (new_value == NULL &&
                    current->substitute_hook == NULL &&
                    current->assign_hook == NULL)
                {
                    previous->next = current->next;
                    free(current->name);
                    free(current);
                }
            }
            else
                pg_free(new_value); /* current->value is left unchanged */
 
            return confirmed;
        }
        if (cmp > 0)
            break;              /* it's not there */
    }
 
    /* not present, make new entry ... unless we were asked to delete */
    if (value)
    {
        current = pg_malloc(sizeof *current);
        current->name = pg_strdup(name);
        current->value = pg_strdup(value);
        current->substitute_hook = NULL;
        current->assign_hook = NULL;
        current->next = previous->next;
        previous->next = current;
    }
    return true;
}

References _variable::assign_hook, cmp(), free, name, _variable::name, _variable::next, pg_free(), pg_log_error, pg_malloc(), pg_strdup(), _variable::substitute_hook, valid_variable_name(), _variable::value, and value.

Referenced by DeleteVariable(), do_lo_import(), exec_command_encoding(), exec_command_getenv(), exec_command_prompt(), exec_command_set(), exec_command_unset(), ExecQueryAndProcessResults(), main(), parse_psql_options(), PrintQueryStatus(), SendQuery(), SetPipelineVariables(), SetResultVariables(), SetShellResultVariables(), SetVariableBool(), StoreQueryTuple(), SyncVariables(), and UnsyncVariables().

SetVariableBool()

bool SetVariableBool	(	VariableSpace	space,
		const char *	name
	)

Definition at line 462 of file variables.c.

{
    return SetVariable(space, name, "on");
}

References name, and SetVariable().

Referenced by main(), and parse_psql_options().

SetVariableHooks()

void SetVariableHooks	(	VariableSpace	space,
		const char *	name,
		VariableSubstituteHook	shook,
		VariableAssignHook	ahook
	)

Definition at line 384 of file variables.c.

{
    struct _variable *current,
               *previous;
 
    if (!space || !name)
        return;
 
    if (!valid_variable_name(name))
        return;
 
    for (previous = space, current = space->next;
         current;
         previous = current, current = current->next)
    {
        int         cmp = strcmp(current->name, name);
 
        if (cmp == 0)
        {
            /* found entry, so update */
            current->substitute_hook = shook;
            current->assign_hook = ahook;
            if (shook)
                current->value = (*shook) (current->value);
            if (ahook)
                (void) (*ahook) (current->value);
            return;
        }
        if (cmp > 0)
            break;              /* it's not there */
    }
 
    /* not present, make new entry */
    current = pg_malloc(sizeof *current);
    current->name = pg_strdup(name);
    current->value = NULL;
    current->substitute_hook = shook;
    current->assign_hook = ahook;
    current->next = previous->next;
    previous->next = current;
    if (shook)
        current->value = (*shook) (current->value);
    if (ahook)
        (void) (*ahook) (current->value);
}

References _variable::assign_hook, cmp(), name, _variable::name, _variable::next, pg_malloc(), pg_strdup(), _variable::substitute_hook, valid_variable_name(), and _variable::value.

Referenced by EstablishVariableSpace().

valid_variable_name()

static bool valid_variable_name ( const char *  name )

static

Definition at line 24 of file variables.c.

{
    const unsigned char *ptr = (const unsigned char *) name;
 
    /* Mustn't be zero-length */
    if (*ptr == '\0')
        return false;
 
    while (*ptr)
    {
        if (IS_HIGHBIT_SET(*ptr) ||
            strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz"
                   "_0123456789", *ptr) != NULL)
            ptr++;
        else
            return false;
    }
 
    return true;
}

References IS_HIGHBIT_SET, and name.

Referenced by SetVariable(), and SetVariableHooks().

VariableHasHook()

bool VariableHasHook	(	VariableSpace	space,
		const char *	name
	)

Definition at line 437 of file variables.c.

{
    struct _variable *current;
 
    Assert(space);
    Assert(name);
 
    for (current = space->next; current; current = current->next)
    {
        int         cmp = strcmp(current->name, name);
 
        if (cmp == 0)
            return (current->substitute_hook != NULL ||
                    current->assign_hook != NULL);
        if (cmp > 0)
            break;              /* it's not there */
    }
 
    return false;
}

References Assert(), _variable::assign_hook, cmp(), name, _variable::name, _variable::next, and _variable::substitute_hook.

Referenced by StoreQueryTuple().