command.h File Reference

#include "fe_utils/conditional.h"
#include "fe_utils/print.h"
#include "fe_utils/psqlscan.h"

Include dependency graph for command.h:

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

Go to the source code of this file.

Typedefs
typedef enum _backslashResult	backslashResult

Enumerations
enum	_backslashResult {   PSQL_CMD_UNKNOWN = 0 , PSQL_CMD_SEND , PSQL_CMD_SKIP_LINE , PSQL_CMD_TERMINATE ,   PSQL_CMD_NEWEDIT , PSQL_CMD_ERROR }

Functions
backslashResult	HandleSlashCmds (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf, PQExpBuffer previous_buf)
int	process_file (char *filename, bool use_relative_path)
bool	do_pset (const char *param, const char *value, printQueryOpt *popt, bool quiet)
printQueryOpt *	savePsetInfo (const printQueryOpt *popt)
void	restorePsetInfo (printQueryOpt *popt, printQueryOpt *save)
void	connection_warnings (bool in_startup)
void	SyncVariables (void)
void	UnsyncVariables (void)

Typedef Documentation

backslashResult

typedef enum _backslashResult backslashResult

Enumeration Type Documentation

_backslashResult

enum _backslashResult

Enumerator
PSQL_CMD_UNKNOWN
PSQL_CMD_SEND
PSQL_CMD_SKIP_LINE
PSQL_CMD_TERMINATE
PSQL_CMD_NEWEDIT
PSQL_CMD_ERROR

Definition at line 15 of file command.h.

{
    PSQL_CMD_UNKNOWN = 0,       /* not done parsing yet (internal only) */
    PSQL_CMD_SEND,              /* query complete; send off */
    PSQL_CMD_SKIP_LINE,         /* keep building query */
    PSQL_CMD_TERMINATE,         /* quit program */
    PSQL_CMD_NEWEDIT,           /* query buffer was changed (e.g., via \e) */
    PSQL_CMD_ERROR,             /* the execution of the backslash command
                                 * resulted in an error */
} backslashResult;

Function Documentation

connection_warnings()

void connection_warnings

(

bool

in_startup

)

Definition at line 4348 of file command.c.

{
    if (!pset.quiet && !pset.notty)
    {
        int         client_ver = PG_VERSION_NUM;
        char        cverbuf[32];
        char        sverbuf[32];
 
        if (pset.sversion != client_ver)
        {
            const char *server_version;
 
            /* Try to get full text form, might include "devel" etc */
            server_version = PQparameterStatus(pset.db, "server_version");
            /* Otherwise fall back on pset.sversion */
            if (!server_version)
            {
                formatPGVersionNumber(pset.sversion, true,
                                      sverbuf, sizeof(sverbuf));
                server_version = sverbuf;
            }
 
            printf(_("%s (%s, server %s)\n"),
                   pset.progname, PG_VERSION, server_version);
        }
        /* For version match, only print psql banner on startup. */
        else if (in_startup)
            printf("%s (%s)\n", pset.progname, PG_VERSION);
 
        /*
         * Warn if server's major version is newer than ours, or if server
         * predates our support cutoff (currently 9.2).
         */
        if (pset.sversion / 100 > client_ver / 100 ||
            pset.sversion < 90200)
            printf(_("WARNING: %s major version %s, server major version %s.\n"
                     "         Some psql features might not work.\n"),
                   pset.progname,
                   formatPGVersionNumber(client_ver, false,
                                         cverbuf, sizeof(cverbuf)),
                   formatPGVersionNumber(pset.sversion, false,
                                         sverbuf, sizeof(sverbuf)));
 
#ifdef WIN32
        if (in_startup)
            checkWin32Codepage();
#endif
        printSSLInfo();
        printGSSInfo();
    }
}

References _, _psqlSettings::db, formatPGVersionNumber(), _psqlSettings::notty, PQparameterStatus(), printf, printGSSInfo(), printSSLInfo(), _psqlSettings::progname, pset, _psqlSettings::quiet, server_version, and _psqlSettings::sversion.

Referenced by CheckConnection(), do_connect(), and main().

do_pset()

bool do_pset	(	const char *	param,
		const char *	value,
		printQueryOpt *	popt,
		bool	quiet
	)

Definition at line 4971 of file command.c.

{
    size_t      vallen = 0;
 
    Assert(param != NULL);
 
    if (value)
        vallen = strlen(value);
 
    /* set format */
    if (strcmp(param, "format") == 0)
    {
        static const struct fmt
        {
            const char *name;
            enum printFormat number;
        }           formats[] =
        {
            /* remember to update error message below when adding more */
            {"aligned", PRINT_ALIGNED},
            {"asciidoc", PRINT_ASCIIDOC},
            {"csv", PRINT_CSV},
            {"html", PRINT_HTML},
            {"latex", PRINT_LATEX},
            {"troff-ms", PRINT_TROFF_MS},
            {"unaligned", PRINT_UNALIGNED},
            {"wrapped", PRINT_WRAPPED}
        };
 
        if (!value)
            ;
        else
        {
            int         match_pos = -1;
 
            for (int i = 0; i < lengthof(formats); i++)
            {
                if (pg_strncasecmp(formats[i].name, value, vallen) == 0)
                {
                    if (match_pos < 0)
                        match_pos = i;
                    else
                    {
                        pg_log_error("\\pset: ambiguous abbreviation \"%s\" matches both \"%s\" and \"%s\"",
                                     value,
                                     formats[match_pos].name, formats[i].name);
                        return false;
                    }
                }
            }
            if (match_pos >= 0)
                popt->topt.format = formats[match_pos].number;
            else if (pg_strncasecmp("latex-longtable", value, vallen) == 0)
            {
                /*
                 * We must treat latex-longtable specially because latex is a
                 * prefix of it; if both were in the table above, we'd think
                 * "latex" is ambiguous.
                 */
                popt->topt.format = PRINT_LATEX_LONGTABLE;
            }
            else
            {
                pg_log_error("\\pset: allowed formats are aligned, asciidoc, csv, html, latex, latex-longtable, troff-ms, unaligned, wrapped");
                return false;
            }
        }
    }
 
    /* set table line style */
    else if (strcmp(param, "linestyle") == 0)
    {
        if (!value)
            ;
        else if (pg_strncasecmp("ascii", value, vallen) == 0)
            popt->topt.line_style = &pg_asciiformat;
        else if (pg_strncasecmp("old-ascii", value, vallen) == 0)
            popt->topt.line_style = &pg_asciiformat_old;
        else if (pg_strncasecmp("unicode", value, vallen) == 0)
            popt->topt.line_style = &pg_utf8format;
        else
        {
            pg_log_error("\\pset: allowed line styles are ascii, old-ascii, unicode");
            return false;
        }
    }
 
    /* set unicode border line style */
    else if (strcmp(param, "unicode_border_linestyle") == 0)
    {
        if (!value)
            ;
        else if (set_unicode_line_style(value, vallen,
                                        &popt->topt.unicode_border_linestyle))
            refresh_utf8format(&(popt->topt));
        else
        {
            pg_log_error("\\pset: allowed Unicode border line styles are single, double");
            return false;
        }
    }
 
    /* set unicode column line style */
    else if (strcmp(param, "unicode_column_linestyle") == 0)
    {
        if (!value)
            ;
        else if (set_unicode_line_style(value, vallen,
                                        &popt->topt.unicode_column_linestyle))
            refresh_utf8format(&(popt->topt));
        else
        {
            pg_log_error("\\pset: allowed Unicode column line styles are single, double");
            return false;
        }
    }
 
    /* set unicode header line style */
    else if (strcmp(param, "unicode_header_linestyle") == 0)
    {
        if (!value)
            ;
        else if (set_unicode_line_style(value, vallen,
                                        &popt->topt.unicode_header_linestyle))
            refresh_utf8format(&(popt->topt));
        else
        {
            pg_log_error("\\pset: allowed Unicode header line styles are single, double");
            return false;
        }
    }
 
    /* set border style/width */
    else if (strcmp(param, "border") == 0)
    {
        if (value)
            popt->topt.border = atoi(value);
    }
 
    /* set expanded/vertical mode */
    else if (strcmp(param, "x") == 0 ||
             strcmp(param, "expanded") == 0 ||
             strcmp(param, "vertical") == 0)
    {
        if (value && pg_strcasecmp(value, "auto") == 0)
            popt->topt.expanded = 2;
        else if (value)
        {
            bool        on_off;
 
            if (ParseVariableBool(value, NULL, &on_off))
                popt->topt.expanded = on_off ? 1 : 0;
            else
            {
                PsqlVarEnumError(param, value, "on, off, auto");
                return false;
            }
        }
        else
            popt->topt.expanded = !popt->topt.expanded;
    }
 
    /* header line width in expanded mode */
    else if (strcmp(param, "xheader_width") == 0)
    {
        if (!value)
            ;
        else if (pg_strcasecmp(value, "full") == 0)
            popt->topt.expanded_header_width_type = PRINT_XHEADER_FULL;
        else if (pg_strcasecmp(value, "column") == 0)
            popt->topt.expanded_header_width_type = PRINT_XHEADER_COLUMN;
        else if (pg_strcasecmp(value, "page") == 0)
            popt->topt.expanded_header_width_type = PRINT_XHEADER_PAGE;
        else
        {
            int         intval = atoi(value);
 
            if (intval == 0)
            {
                pg_log_error("\\pset: allowed xheader_width values are \"%s\" (default), \"%s\", \"%s\", or a number specifying the exact width", "full", "column", "page");
                return false;
            }
 
            popt->topt.expanded_header_width_type = PRINT_XHEADER_EXACT_WIDTH;
            popt->topt.expanded_header_exact_width = intval;
        }
    }
 
    /* field separator for CSV format */
    else if (strcmp(param, "csv_fieldsep") == 0)
    {
        if (value)
        {
            /* CSV separator has to be a one-byte character */
            if (strlen(value) != 1)
            {
                pg_log_error("\\pset: csv_fieldsep must be a single one-byte character");
                return false;
            }
            if (value[0] == '"' || value[0] == '\n' || value[0] == '\r')
            {
                pg_log_error("\\pset: csv_fieldsep cannot be a double quote, a newline, or a carriage return");
                return false;
            }
            popt->topt.csvFieldSep[0] = value[0];
        }
    }
 
    /* locale-aware numeric output */
    else if (strcmp(param, "numericlocale") == 0)
    {
        if (value)
            return ParseVariableBool(value, param, &popt->topt.numericLocale);
        else
            popt->topt.numericLocale = !popt->topt.numericLocale;
    }
 
    /* null display */
    else if (strcmp(param, "null") == 0)
    {
        if (value)
        {
            free(popt->nullPrint);
            popt->nullPrint = pg_strdup(value);
        }
    }
 
    /* field separator for unaligned text */
    else if (strcmp(param, "fieldsep") == 0)
    {
        if (value)
        {
            free(popt->topt.fieldSep.separator);
            popt->topt.fieldSep.separator = pg_strdup(value);
            popt->topt.fieldSep.separator_zero = false;
        }
    }
 
    else if (strcmp(param, "fieldsep_zero") == 0)
    {
        free(popt->topt.fieldSep.separator);
        popt->topt.fieldSep.separator = NULL;
        popt->topt.fieldSep.separator_zero = true;
    }
 
    /* record separator for unaligned text */
    else if (strcmp(param, "recordsep") == 0)
    {
        if (value)
        {
            free(popt->topt.recordSep.separator);
            popt->topt.recordSep.separator = pg_strdup(value);
            popt->topt.recordSep.separator_zero = false;
        }
    }
 
    else if (strcmp(param, "recordsep_zero") == 0)
    {
        free(popt->topt.recordSep.separator);
        popt->topt.recordSep.separator = NULL;
        popt->topt.recordSep.separator_zero = true;
    }
 
    /* toggle between full and tuples-only format */
    else if (strcmp(param, "t") == 0 || strcmp(param, "tuples_only") == 0)
    {
        if (value)
            return ParseVariableBool(value, param, &popt->topt.tuples_only);
        else
            popt->topt.tuples_only = !popt->topt.tuples_only;
    }
 
    /* set title override */
    else if (strcmp(param, "C") == 0 || strcmp(param, "title") == 0)
    {
        free(popt->title);
        if (!value)
            popt->title = NULL;
        else
            popt->title = pg_strdup(value);
    }
 
    /* set HTML table tag options */
    else if (strcmp(param, "T") == 0 || strcmp(param, "tableattr") == 0)
    {
        free(popt->topt.tableAttr);
        if (!value)
            popt->topt.tableAttr = NULL;
        else
            popt->topt.tableAttr = pg_strdup(value);
    }
 
    /* toggle use of pager */
    else if (strcmp(param, "pager") == 0)
    {
        if (value && pg_strcasecmp(value, "always") == 0)
            popt->topt.pager = 2;
        else if (value)
        {
            bool        on_off;
 
            if (!ParseVariableBool(value, NULL, &on_off))
            {
                PsqlVarEnumError(param, value, "on, off, always");
                return false;
            }
            popt->topt.pager = on_off ? 1 : 0;
        }
        else if (popt->topt.pager == 1)
            popt->topt.pager = 0;
        else
            popt->topt.pager = 1;
    }
 
    /* set minimum lines for pager use */
    else if (strcmp(param, "pager_min_lines") == 0)
    {
        if (value &&
            !ParseVariableNum(value, "pager_min_lines", &popt->topt.pager_min_lines))
            return false;
    }
 
    /* disable "(x rows)" footer */
    else if (strcmp(param, "footer") == 0)
    {
        if (value)
            return ParseVariableBool(value, param, &popt->topt.default_footer);
        else
            popt->topt.default_footer = !popt->topt.default_footer;
    }
 
    /* set border style/width */
    else if (strcmp(param, "columns") == 0)
    {
        if (value)
            popt->topt.columns = atoi(value);
    }
    else
    {
        pg_log_error("\\pset: unknown option: %s", param);
        return false;
    }
 
    if (!quiet)
        printPsetInfo(param, &pset.popt);
 
    return true;
}

References Assert(), printTableOpt::border, printTableOpt::columns, printTableOpt::csvFieldSep, printTableOpt::default_footer, printTableOpt::expanded, printTableOpt::expanded_header_exact_width, printTableOpt::expanded_header_width_type, printTableOpt::fieldSep, printTableOpt::format, free, i, lengthof, printTableOpt::line_style, name, printQueryOpt::nullPrint, printTableOpt::numericLocale, printTableOpt::pager, printTableOpt::pager_min_lines, ParseVariableBool(), ParseVariableNum(), pg_asciiformat, pg_asciiformat_old, pg_log_error, pg_strcasecmp(), pg_strdup(), pg_strncasecmp(), pg_utf8format, _psqlSettings::popt, PRINT_ALIGNED, PRINT_ASCIIDOC, PRINT_CSV, PRINT_HTML, PRINT_LATEX, PRINT_LATEX_LONGTABLE, PRINT_TROFF_MS, PRINT_UNALIGNED, PRINT_WRAPPED, PRINT_XHEADER_COLUMN, PRINT_XHEADER_EXACT_WIDTH, PRINT_XHEADER_FULL, PRINT_XHEADER_PAGE, printPsetInfo(), pset, PsqlVarEnumError(), printTableOpt::recordSep, refresh_utf8format(), separator::separator, separator::separator_zero, set_unicode_line_style(), printTableOpt::tableAttr, printQueryOpt::title, printQueryOpt::topt, printTableOpt::tuples_only, printTableOpt::unicode_border_linestyle, printTableOpt::unicode_column_linestyle, printTableOpt::unicode_header_linestyle, and value.

Referenced by exec_command_a(), exec_command_C(), exec_command_f(), exec_command_html(), exec_command_pset(), exec_command_t(), exec_command_T(), exec_command_x(), parse_psql_options(), and process_command_g_options().

HandleSlashCmds()

backslashResult HandleSlashCmds	(	PsqlScanState	scan_state,
		ConditionalStack	cstack,
		PQExpBuffer	query_buf,
		PQExpBuffer	previous_buf
	)

Definition at line 225 of file command.c.

{
    backslashResult status;
    char       *cmd;
    char       *arg;
 
    Assert(scan_state != NULL);
    Assert(cstack != NULL);
 
    /* Parse off the command name */
    cmd = psql_scan_slash_command(scan_state);
 
    /* And try to execute it */
    status = exec_command(cmd, scan_state, cstack, query_buf, previous_buf);
 
    if (status == PSQL_CMD_UNKNOWN)
    {
        pg_log_error("invalid command \\%s", cmd);
        if (pset.cur_cmd_interactive)
            pg_log_error_hint("Try \\? for help.");
        status = PSQL_CMD_ERROR;
    }
 
    if (status != PSQL_CMD_ERROR)
    {
        /*
         * Eat any remaining arguments after a valid command.  We want to
         * suppress evaluation of backticks in this situation, so transiently
         * push an inactive conditional-stack entry.
         */
        bool        active_branch = conditional_active(cstack);
 
        conditional_stack_push(cstack, IFSTATE_IGNORED);
        while ((arg = psql_scan_slash_option(scan_state,
                                             OT_NORMAL, NULL, false)))
        {
            if (active_branch)
                pg_log_warning("\\%s: extra argument \"%s\" ignored", cmd, arg);
            free(arg);
        }
        conditional_stack_pop(cstack);
    }
    else
    {
        /* silently throw away rest of line after an erroneous command */
        while ((arg = psql_scan_slash_option(scan_state,
                                             OT_WHOLE_LINE, NULL, false)))
            free(arg);
    }
 
    /* if there is a trailing \\, swallow it */
    psql_scan_slash_command_end(scan_state);
 
    free(cmd);
 
    /* some commands write to queryFout, so make sure output is sent */
    fflush(pset.queryFout);
 
    return status;
}

References arg, Assert(), conditional_active(), conditional_stack_pop(), conditional_stack_push(), _psqlSettings::cur_cmd_interactive, exec_command(), free, IFSTATE_IGNORED, OT_NORMAL, OT_WHOLE_LINE, pg_log_error, pg_log_error_hint, pg_log_warning, pset, PSQL_CMD_ERROR, PSQL_CMD_UNKNOWN, psql_scan_slash_command(), psql_scan_slash_command_end(), psql_scan_slash_option(), and _psqlSettings::queryFout.

Referenced by main(), and MainLoop().

process_file()

int process_file	(	char *	filename,
		bool	use_relative_path
	)

Definition at line 4818 of file command.c.

{
    FILE       *fd;
    int         result;
    char       *oldfilename;
    char        relpath[MAXPGPATH];
 
    if (!filename)
    {
        fd = stdin;
        filename = NULL;
    }
    else if (strcmp(filename, "-") != 0)
    {
        canonicalize_path_enc(filename, pset.encoding);
 
        /*
         * If we were asked to resolve the pathname relative to the location
         * of the currently executing script, and there is one, and this is a
         * relative pathname, then prepend all but the last pathname component
         * of the current script to this pathname.
         */
        if (use_relative_path && pset.inputfile &&
            !is_absolute_path(filename) && !has_drive_prefix(filename))
        {
            strlcpy(relpath, pset.inputfile, sizeof(relpath));
            get_parent_directory(relpath);
            join_path_components(relpath, relpath, filename);
            canonicalize_path_enc(relpath, pset.encoding);
 
            filename = relpath;
        }
 
        fd = fopen(filename, PG_BINARY_R);
 
        if (!fd)
        {
            pg_log_error("%s: %m", filename);
            return EXIT_FAILURE;
        }
    }
    else
    {
        fd = stdin;
        filename = "<stdin>";   /* for future error messages */
    }
 
    oldfilename = pset.inputfile;
    pset.inputfile = filename;
 
    pg_logging_config(pset.inputfile ? 0 : PG_LOG_FLAG_TERSE);
 
    result = MainLoop(fd);
 
    if (fd != stdin)
        fclose(fd);
 
    pset.inputfile = oldfilename;
 
    pg_logging_config(pset.inputfile ? 0 : PG_LOG_FLAG_TERSE);
 
    return result;
}

References canonicalize_path_enc(), _psqlSettings::encoding, EXIT_FAILURE, fd(), filename, get_parent_directory(), has_drive_prefix(), _psqlSettings::inputfile, is_absolute_path, join_path_components(), MainLoop(), MAXPGPATH, PG_BINARY_R, pg_log_error, PG_LOG_FLAG_TERSE, pg_logging_config(), pset, relpath, and strlcpy().

Referenced by exec_command_include().

restorePsetInfo()

void restorePsetInfo	(	printQueryOpt *	popt,
		printQueryOpt *	save
	)

Definition at line 5560 of file command.c.

{
    /* Free all the old data we're about to overwrite the pointers to. */
 
    /* topt.line_style points to const data that need not be duplicated */
    free(popt->topt.fieldSep.separator);
    free(popt->topt.recordSep.separator);
    free(popt->topt.tableAttr);
    free(popt->nullPrint);
    free(popt->title);
 
    /*
     * footers and translate_columns are never set in psql's print settings,
     * so we needn't write code to duplicate them.
     */
    Assert(popt->footers == NULL);
    Assert(popt->translate_columns == NULL);
 
    /* Now we may flat-copy all the fields, including pointers. */
    memcpy(popt, save, sizeof(printQueryOpt));
 
    /* Lastly, free "save" ... but its sub-structures now belong to popt. */
    free(save);
}

References Assert(), printTableOpt::fieldSep, printQueryOpt::footers, free, printQueryOpt::nullPrint, printTableOpt::recordSep, separator::separator, printTableOpt::tableAttr, printQueryOpt::title, printQueryOpt::topt, and printQueryOpt::translate_columns.

Referenced by process_command_g_options(), and SendQuery().

savePsetInfo()

printQueryOpt * savePsetInfo

(

const printQueryOpt *

popt

)

Definition at line 5524 of file command.c.

{
    printQueryOpt *save;
 
    save = (printQueryOpt *) pg_malloc(sizeof(printQueryOpt));
 
    /* Flat-copy all the scalar fields, then duplicate sub-structures. */
    memcpy(save, popt, sizeof(printQueryOpt));
 
    /* topt.line_style points to const data that need not be duplicated */
    if (popt->topt.fieldSep.separator)
        save->topt.fieldSep.separator = pg_strdup(popt->topt.fieldSep.separator);
    if (popt->topt.recordSep.separator)
        save->topt.recordSep.separator = pg_strdup(popt->topt.recordSep.separator);
    if (popt->topt.tableAttr)
        save->topt.tableAttr = pg_strdup(popt->topt.tableAttr);
    if (popt->nullPrint)
        save->nullPrint = pg_strdup(popt->nullPrint);
    if (popt->title)
        save->title = pg_strdup(popt->title);
 
    /*
     * footers and translate_columns are never set in psql's print settings,
     * so we needn't write code to duplicate them.
     */
    Assert(popt->footers == NULL);
    Assert(popt->translate_columns == NULL);
 
    return save;
}

References Assert(), printTableOpt::fieldSep, printQueryOpt::footers, printQueryOpt::nullPrint, pg_malloc(), pg_strdup(), printTableOpt::recordSep, separator::separator, printTableOpt::tableAttr, printQueryOpt::title, printQueryOpt::topt, and printQueryOpt::translate_columns.

Referenced by exec_command_g(), and process_command_g_options().

SyncVariables()

void SyncVariables

(

void

)

Definition at line 4476 of file command.c.

{
    char        vbuf[32];
    const char *server_version;
 
    /* get stuff from connection */
    pset.encoding = PQclientEncoding(pset.db);
    pset.popt.topt.encoding = pset.encoding;
    pset.sversion = PQserverVersion(pset.db);
 
    setFmtEncoding(pset.encoding);
 
    SetVariable(pset.vars, "DBNAME", PQdb(pset.db));
    SetVariable(pset.vars, "SERVICE", PQservice(pset.db));
    SetVariable(pset.vars, "USER", PQuser(pset.db));
    SetVariable(pset.vars, "HOST", PQhost(pset.db));
    SetVariable(pset.vars, "PORT", PQport(pset.db));
    SetVariable(pset.vars, "ENCODING", pg_encoding_to_char(pset.encoding));
 
    /* this bit should match connection_warnings(): */
    /* Try to get full text form of version, might include "devel" etc */
    server_version = PQparameterStatus(pset.db, "server_version");
    /* Otherwise fall back on pset.sversion */
    if (!server_version)
    {
        formatPGVersionNumber(pset.sversion, true, vbuf, sizeof(vbuf));
        server_version = vbuf;
    }
    SetVariable(pset.vars, "SERVER_VERSION_NAME", server_version);
 
    snprintf(vbuf, sizeof(vbuf), "%d", pset.sversion);
    SetVariable(pset.vars, "SERVER_VERSION_NUM", vbuf);
 
    /* send stuff to it, too */
    PQsetErrorVerbosity(pset.db, pset.verbosity);
    PQsetErrorContextVisibility(pset.db, pset.show_context);
}

References _psqlSettings::db, _psqlSettings::encoding, printTableOpt::encoding, formatPGVersionNumber(), pg_encoding_to_char, _psqlSettings::popt, PQclientEncoding(), PQdb(), PQhost(), PQparameterStatus(), PQport(), PQserverVersion(), PQservice(), PQsetErrorContextVisibility(), PQsetErrorVerbosity(), PQuser(), pset, server_version, setFmtEncoding(), SetVariable(), _psqlSettings::show_context, snprintf, _psqlSettings::sversion, printQueryOpt::topt, _psqlSettings::vars, and _psqlSettings::verbosity.

Referenced by CheckConnection(), do_connect(), and main().

UnsyncVariables()

void UnsyncVariables

(

void

)

Definition at line 4520 of file command.c.

{
    SetVariable(pset.vars, "DBNAME", NULL);
    SetVariable(pset.vars, "SERVICE", NULL);
    SetVariable(pset.vars, "USER", NULL);
    SetVariable(pset.vars, "HOST", NULL);
    SetVariable(pset.vars, "PORT", NULL);
    SetVariable(pset.vars, "ENCODING", NULL);
    SetVariable(pset.vars, "SERVER_VERSION_NAME", NULL);
    SetVariable(pset.vars, "SERVER_VERSION_NUM", NULL);
}

References pset, SetVariable(), and _psqlSettings::vars.

Referenced by CheckConnection(), and do_connect().