command.c File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include <time.h>
#include <pwd.h>
#include <utime.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "catalog/pg_class_d.h"
#include "command.h"
#include "common.h"
#include "common/logging.h"
#include "common/string.h"
#include "copy.h"
#include "describe.h"
#include "fe_utils/cancel.h"
#include "fe_utils/print.h"
#include "fe_utils/string_utils.h"
#include "help.h"
#include "input.h"
#include "large_obj.h"
#include "libpq/pqcomm.h"
#include "mainloop.h"
#include "pqexpbuffer.h"
#include "psqlscanslash.h"
#include "settings.h"
#include "variables.h"

Include dependency graph for command.c:

Go to the source code of this file.

Macros
#define	DEFAULT_SHELL   "/bin/sh"

Typedefs
typedef enum EditableObjectType	EditableObjectType

Enumerations
enum	EditableObjectType { EditableFunction , EditableView }

Functions
static backslashResult	exec_command (const char *cmd, PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf, PQExpBuffer previous_buf)
static backslashResult	exec_command_a (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_bind (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_bind_named (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_C (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_connect (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_cd (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_close (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_conninfo (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_copy (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_copyright (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_crosstabview (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_d (PsqlScanState scan_state, bool active_branch, const char *cmd)
static bool	exec_command_dfo (PsqlScanState scan_state, const char *cmd, const char *pattern, bool show_verbose, bool show_system)
static backslashResult	exec_command_edit (PsqlScanState scan_state, bool active_branch, PQExpBuffer query_buf, PQExpBuffer previous_buf)
static backslashResult	exec_command_ef_ev (PsqlScanState scan_state, bool active_branch, PQExpBuffer query_buf, bool is_func)
static backslashResult	exec_command_echo (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_elif (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf)
static backslashResult	exec_command_else (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf)
static backslashResult	exec_command_endif (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf)
static backslashResult	exec_command_endpipeline (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_encoding (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_errverbose (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_f (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_flush (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_flushrequest (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_g (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	process_command_g_options (char *first_option, PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_gdesc (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_getenv (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_gexec (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_getresults (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_gset (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_help (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_html (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_include (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_if (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf)
static backslashResult	exec_command_list (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_lo (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_out (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_print (PsqlScanState scan_state, bool active_branch, PQExpBuffer query_buf, PQExpBuffer previous_buf)
static backslashResult	exec_command_parse (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_password (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_prompt (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_pset (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_quit (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_reset (PsqlScanState scan_state, bool active_branch, PQExpBuffer query_buf)
static backslashResult	exec_command_s (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_sendpipeline (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_set (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_setenv (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_sf_sv (PsqlScanState scan_state, bool active_branch, const char *cmd, bool is_func)
static backslashResult	exec_command_startpipeline (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_syncpipeline (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_t (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_T (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_timing (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_unset (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_write (PsqlScanState scan_state, bool active_branch, const char *cmd, PQExpBuffer query_buf, PQExpBuffer previous_buf)
static backslashResult	exec_command_watch (PsqlScanState scan_state, bool active_branch, PQExpBuffer query_buf, PQExpBuffer previous_buf)
static backslashResult	exec_command_x (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_z (PsqlScanState scan_state, bool active_branch, const char *cmd)
static backslashResult	exec_command_shell_escape (PsqlScanState scan_state, bool active_branch)
static backslashResult	exec_command_slash_command_help (PsqlScanState scan_state, bool active_branch)
static char *	read_connect_arg (PsqlScanState scan_state)
static PQExpBuffer	gather_boolean_expression (PsqlScanState scan_state)
static bool	is_true_boolean_expression (PsqlScanState scan_state, const char *name)
static void	ignore_boolean_expression (PsqlScanState scan_state)
static void	ignore_slash_options (PsqlScanState scan_state)
static void	ignore_slash_filepipe (PsqlScanState scan_state)
static void	ignore_slash_whole_line (PsqlScanState scan_state)
static bool	is_branching_command (const char *cmd)
static void	save_query_text_state (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf)
static void	discard_query_text (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf)
static bool	copy_previous_query (PQExpBuffer query_buf, PQExpBuffer previous_buf)
static bool	do_connect (enum trivalue reuse_previous_specification, char *dbname, char *user, char *host, char *port)
static void	wait_until_connected (PGconn *conn)
static bool	do_edit (const char *filename_arg, PQExpBuffer query_buf, int lineno, bool discard_on_quit, bool *edited)
static bool	do_shell (const char *command)
static bool	do_watch (PQExpBuffer query_buf, double sleep, int iter, int min_rows)
static bool	lookup_object_oid (EditableObjectType obj_type, const char *desc, Oid *obj_oid)
static bool	get_create_object_cmd (EditableObjectType obj_type, Oid oid, PQExpBuffer buf)
static int	strip_lineno_from_objdesc (char *obj)
static int	count_lines_in_buf (PQExpBuffer buf)
static void	print_with_linenumbers (FILE *output, char *lines, bool is_func)
static void	minimal_error_message (PGresult *res)
static void	printSSLInfo (void)
static void	printGSSInfo (void)
static bool	printPsetInfo (const char *param, printQueryOpt *popt)
static char *	pset_value_string (const char *param, printQueryOpt *popt)
backslashResult	HandleSlashCmds (PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf, PQExpBuffer previous_buf)
static char *	prompt_for_password (const char *username, bool *canceled)
static bool	param_is_newly_set (const char *old_val, const char *new_val)
void	connection_warnings (bool in_startup)
void	SyncVariables (void)
void	UnsyncVariables (void)
static bool	editFile (const char *fname, int lineno)
int	process_file (char *filename, bool use_relative_path)
static const char *	_align2string (enum printFormat in)
static bool	set_unicode_line_style (const char *value, size_t vallen, unicode_linestyle *linestyle)
static const char *	_unicode_linestyle2string (int linestyle)
bool	do_pset (const char *param, const char *value, printQueryOpt *popt, bool quiet)
printQueryOpt *	savePsetInfo (const printQueryOpt *popt)
void	restorePsetInfo (printQueryOpt *popt, printQueryOpt *save)
static const char *	pset_bool_string (bool val)
static char *	pset_quoted_string (const char *str)
static bool	echo_hidden_command (const char *query)

Macro Definition Documentation

DEFAULT_SHELL

#define DEFAULT_SHELL   "/bin/sh"

Definition at line 5710 of file command.c.

Typedef Documentation

EditableObjectType

typedef enum EditableObjectType EditableObjectType

Enumeration Type Documentation

EditableObjectType

enum EditableObjectType

Enumerator
EditableFunction
EditableView

Definition at line 50 of file command.c.

{
    EditableFunction,
    EditableView,
} EditableObjectType;

Function Documentation

_align2string()

static const char * _align2string ( enum printFormat  in )

static

Definition at line 4885 of file command.c.

{
    switch (in)
    {
        case PRINT_NOTHING:
            return "nothing";
            break;
        case PRINT_ALIGNED:
            return "aligned";
            break;
        case PRINT_ASCIIDOC:
            return "asciidoc";
            break;
        case PRINT_CSV:
            return "csv";
            break;
        case PRINT_HTML:
            return "html";
            break;
        case PRINT_LATEX:
            return "latex";
            break;
        case PRINT_LATEX_LONGTABLE:
            return "latex-longtable";
            break;
        case PRINT_TROFF_MS:
            return "troff-ms";
            break;
        case PRINT_UNALIGNED:
            return "unaligned";
            break;
        case PRINT_WRAPPED:
            return "wrapped";
            break;
    }
    return "unknown";
}

References PRINT_ALIGNED, PRINT_ASCIIDOC, PRINT_CSV, PRINT_HTML, PRINT_LATEX, PRINT_LATEX_LONGTABLE, PRINT_NOTHING, PRINT_TROFF_MS, PRINT_UNALIGNED, and PRINT_WRAPPED.

Referenced by printPsetInfo(), and pset_value_string().

_unicode_linestyle2string()

static const char * _unicode_linestyle2string ( int  linestyle )

static

Definition at line 4941 of file command.c.

{
    switch (linestyle)
    {
        case UNICODE_LINESTYLE_SINGLE:
            return "single";
            break;
        case UNICODE_LINESTYLE_DOUBLE:
            return "double";
            break;
    }
    return "unknown";
}

References UNICODE_LINESTYLE_DOUBLE, and UNICODE_LINESTYLE_SINGLE.

Referenced by printPsetInfo(), and pset_value_string().

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().

copy_previous_query()

static bool copy_previous_query ( PQExpBuffer  query_buf, PQExpBuffer  previous_buf  )

static

Definition at line 3753 of file command.c.

{
    if (query_buf && query_buf->len == 0)
    {
        appendPQExpBufferStr(query_buf, previous_buf->data);
        return true;
    }
    return false;
}

References appendPQExpBufferStr(), PQExpBufferData::data, and PQExpBufferData::len.

Referenced by exec_command(), exec_command_edit(), and exec_command_watch().

count_lines_in_buf()

static int count_lines_in_buf ( PQExpBuffer  buf )

static

Definition at line 6322 of file command.c.

{
    int         lineno = 0;
    const char *lines = buf->data;
 
    while (*lines != '\0')
    {
        lineno++;
        /* find start of next line */
        lines = strchr(lines, '\n');
        if (!lines)
            break;
        lines++;
    }
 
    return lineno;
}

References buf.

Referenced by exec_command_sf_sv().

discard_query_text()

static void discard_query_text ( PsqlScanState  scan_state, ConditionalStack  cstack, PQExpBuffer  query_buf  )

static

Definition at line 3727 of file command.c.

{
    if (query_buf)
    {
        int         new_len = conditional_stack_get_query_len(cstack);
 
        Assert(new_len >= 0 && new_len <= query_buf->len);
        query_buf->len = new_len;
        query_buf->data[new_len] = '\0';
    }
    psql_scan_set_paren_depth(scan_state,
                              conditional_stack_get_paren_depth(cstack));
}

References Assert(), conditional_stack_get_paren_depth(), conditional_stack_get_query_len(), PQExpBufferData::data, PQExpBufferData::len, len, and psql_scan_set_paren_depth().

Referenced by exec_command_elif(), exec_command_else(), and exec_command_endif().

do_connect()

static bool do_connect ( enum trivalue  reuse_previous_specification, char *  dbname, char *  user, char *  host, char *  port  )

static

Definition at line 3822 of file command.c.

{
    PGconn     *o_conn = pset.db,
               *n_conn = NULL;
    PQconninfoOption *cinfo;
    int         nconnopts = 0;
    bool        same_host = false;
    char       *password = NULL;
    char       *client_encoding;
    bool        success = true;
    bool        keep_password = true;
    bool        has_connection_string;
    bool        reuse_previous;
 
    has_connection_string = dbname ?
        recognized_connection_string(dbname) : false;
 
    /* Complain if we have additional arguments after a connection string. */
    if (has_connection_string && (user || host || port))
    {
        pg_log_error("Do not give user, host, or port separately when using a connection string");
        return false;
    }
 
    switch (reuse_previous_specification)
    {
        case TRI_YES:
            reuse_previous = true;
            break;
        case TRI_NO:
            reuse_previous = false;
            break;
        default:
            reuse_previous = !has_connection_string;
            break;
    }
 
    /*
     * If we intend to re-use connection parameters, collect them out of the
     * old connection, then replace individual values as necessary.  (We may
     * need to resort to looking at pset.dead_conn, if the connection died
     * previously.)  Otherwise, obtain a PQconninfoOption array containing
     * libpq's defaults, and modify that.  Note this function assumes that
     * PQconninfo, PQconndefaults, and PQconninfoParse will all produce arrays
     * containing the same options in the same order.
     */
    if (reuse_previous)
    {
        if (o_conn)
            cinfo = PQconninfo(o_conn);
        else if (pset.dead_conn)
            cinfo = PQconninfo(pset.dead_conn);
        else
        {
            /* This is reachable after a non-interactive \connect failure */
            pg_log_error("No database connection exists to re-use parameters from");
            return false;
        }
    }
    else
        cinfo = PQconndefaults();
 
    if (cinfo)
    {
        if (has_connection_string)
        {
            /* Parse the connstring and insert values into cinfo */
            PQconninfoOption *replcinfo;
            char       *errmsg;
 
            replcinfo = PQconninfoParse(dbname, &errmsg);
            if (replcinfo)
            {
                PQconninfoOption *ci;
                PQconninfoOption *replci;
                bool        have_password = false;
 
                for (ci = cinfo, replci = replcinfo;
                     ci->keyword && replci->keyword;
                     ci++, replci++)
                {
                    Assert(strcmp(ci->keyword, replci->keyword) == 0);
                    /* Insert value from connstring if one was provided */
                    if (replci->val)
                    {
                        /*
                         * We know that both val strings were allocated by
                         * libpq, so the least messy way to avoid memory leaks
                         * is to swap them.
                         */
                        char       *swap = replci->val;
 
                        replci->val = ci->val;
                        ci->val = swap;
 
                        /*
                         * Check whether connstring provides options affecting
                         * password re-use.  While any change in user, host,
                         * hostaddr, or port causes us to ignore the old
                         * connection's password, we don't force that for
                         * dbname, since passwords aren't database-specific.
                         */
                        if (replci->val == NULL ||
                            strcmp(ci->val, replci->val) != 0)
                        {
                            if (strcmp(replci->keyword, "user") == 0 ||
                                strcmp(replci->keyword, "host") == 0 ||
                                strcmp(replci->keyword, "hostaddr") == 0 ||
                                strcmp(replci->keyword, "port") == 0)
                                keep_password = false;
                        }
                        /* Also note whether connstring contains a password. */
                        if (strcmp(replci->keyword, "password") == 0)
                            have_password = true;
                    }
                    else if (!reuse_previous)
                    {
                        /*
                         * When we have a connstring and are not re-using
                         * parameters, swap *all* entries, even those not set
                         * by the connstring.  This avoids absorbing
                         * environment-dependent defaults from the result of
                         * PQconndefaults().  We don't want to do that because
                         * they'd override service-file entries if the
                         * connstring specifies a service parameter, whereas
                         * the priority should be the other way around.  libpq
                         * can certainly recompute any defaults we don't pass
                         * here.  (In this situation, it's a bit wasteful to
                         * have called PQconndefaults() at all, but not doing
                         * so would require yet another major code path here.)
                         */
                        replci->val = ci->val;
                        ci->val = NULL;
                    }
                }
                Assert(ci->keyword == NULL && replci->keyword == NULL);
 
                /* While here, determine how many option slots there are */
                nconnopts = ci - cinfo;
 
                PQconninfoFree(replcinfo);
 
                /*
                 * If the connstring contains a password, tell the loop below
                 * that we may use it, regardless of other settings (i.e.,
                 * cinfo's password is no longer an "old" password).
                 */
                if (have_password)
                    keep_password = true;
 
                /* Don't let code below try to inject dbname into params. */
                dbname = NULL;
            }
            else
            {
                /* PQconninfoParse failed */
                if (errmsg)
                {
                    pg_log_error("%s", errmsg);
                    PQfreemem(errmsg);
                }
                else
                    pg_log_error("out of memory");
                success = false;
            }
        }
        else
        {
            /*
             * If dbname isn't a connection string, then we'll inject it and
             * the other parameters into the keyword array below.  (We can't
             * easily insert them into the cinfo array because of memory
             * management issues: PQconninfoFree would misbehave on Windows.)
             * However, to avoid dependencies on the order in which parameters
             * appear in the array, make a preliminary scan to set
             * keep_password and same_host correctly.
             *
             * While any change in user, host, or port causes us to ignore the
             * old connection's password, we don't force that for dbname,
             * since passwords aren't database-specific.
             */
            PQconninfoOption *ci;
 
            for (ci = cinfo; ci->keyword; ci++)
            {
                if (user && strcmp(ci->keyword, "user") == 0)
                {
                    if (!(ci->val && strcmp(user, ci->val) == 0))
                        keep_password = false;
                }
                else if (host && strcmp(ci->keyword, "host") == 0)
                {
                    if (ci->val && strcmp(host, ci->val) == 0)
                        same_host = true;
                    else
                        keep_password = false;
                }
                else if (port && strcmp(ci->keyword, "port") == 0)
                {
                    if (!(ci->val && strcmp(port, ci->val) == 0))
                        keep_password = false;
                }
            }
 
            /* While here, determine how many option slots there are */
            nconnopts = ci - cinfo;
        }
    }
    else
    {
        /* We failed to create the cinfo structure */
        pg_log_error("out of memory");
        success = false;
    }
 
    /*
     * If the user asked to be prompted for a password, ask for one now. If
     * not, use the password from the old connection, provided the username
     * etc have not changed. Otherwise, try to connect without a password
     * first, and then ask for a password if needed.
     *
     * XXX: this behavior leads to spurious connection attempts recorded in
     * the postmaster's log.  But libpq offers no API that would let us obtain
     * a password and then continue with the first connection attempt.
     */
    if (pset.getPassword == TRI_YES && success)
    {
        bool        canceled = false;
 
        /*
         * If a connstring or URI is provided, we don't know which username
         * will be used, since we haven't dug that out of the connstring.
         * Don't risk issuing a misleading prompt.  As in startup.c, it does
         * not seem worth working harder, since this getPassword setting is
         * normally only used in noninteractive cases.
         */
        password = prompt_for_password(has_connection_string ? NULL : user,
                                       &canceled);
        success = !canceled;
    }
 
    /*
     * Consider whether to force client_encoding to "auto" (overriding
     * anything in the connection string).  We do so if we have a terminal
     * connection and there is no PGCLIENTENCODING environment setting.
     */
    if (pset.notty || getenv("PGCLIENTENCODING"))
        client_encoding = NULL;
    else
        client_encoding = "auto";
 
    /* Loop till we have a connection or fail, which we might've already */
    while (success)
    {
        const char **keywords = pg_malloc((nconnopts + 1) * sizeof(*keywords));
        const char **values = pg_malloc((nconnopts + 1) * sizeof(*values));
        int         paramnum = 0;
        PQconninfoOption *ci;
 
        /*
         * Copy non-default settings into the PQconnectdbParams parameter
         * arrays; but inject any values specified old-style, as well as any
         * interactively-obtained password, and a couple of fields we want to
         * set forcibly.
         *
         * If you change this code, see also the initial-connection code in
         * main().
         */
        for (ci = cinfo; ci->keyword; ci++)
        {
            keywords[paramnum] = ci->keyword;
 
            if (dbname && strcmp(ci->keyword, "dbname") == 0)
                values[paramnum++] = dbname;
            else if (user && strcmp(ci->keyword, "user") == 0)
                values[paramnum++] = user;
            else if (host && strcmp(ci->keyword, "host") == 0)
                values[paramnum++] = host;
            else if (host && !same_host && strcmp(ci->keyword, "hostaddr") == 0)
            {
                /* If we're changing the host value, drop any old hostaddr */
                values[paramnum++] = NULL;
            }
            else if (port && strcmp(ci->keyword, "port") == 0)
                values[paramnum++] = port;
            /* If !keep_password, we unconditionally drop old password */
            else if ((password || !keep_password) &&
                     strcmp(ci->keyword, "password") == 0)
                values[paramnum++] = password;
            else if (strcmp(ci->keyword, "fallback_application_name") == 0)
                values[paramnum++] = pset.progname;
            else if (client_encoding &&
                     strcmp(ci->keyword, "client_encoding") == 0)
                values[paramnum++] = client_encoding;
            else if (ci->val)
                values[paramnum++] = ci->val;
            /* else, don't bother making libpq parse this keyword */
        }
        /* add array terminator */
        keywords[paramnum] = NULL;
        values[paramnum] = NULL;
 
        /* Note we do not want libpq to re-expand the dbname parameter */
        n_conn = PQconnectStartParams(keywords, values, false);
 
        pg_free(keywords);
        pg_free(values);
 
        wait_until_connected(n_conn);
        if (PQstatus(n_conn) == CONNECTION_OK)
            break;
 
        /*
         * Connection attempt failed; either retry the connection attempt with
         * a new password, or give up.
         */
        if (!password && PQconnectionNeedsPassword(n_conn) && pset.getPassword != TRI_NO)
        {
            bool        canceled = false;
 
            /*
             * Prompt for password using the username we actually connected
             * with --- it might've come out of "dbname" rather than "user".
             */
            password = prompt_for_password(PQuser(n_conn), &canceled);
            PQfinish(n_conn);
            n_conn = NULL;
            success = !canceled;
            continue;
        }
 
        /*
         * We'll report the error below ... unless n_conn is NULL, indicating
         * that libpq didn't have enough memory to make a PGconn.
         */
        if (n_conn == NULL)
            pg_log_error("out of memory");
 
        success = false;
    }                           /* end retry loop */
 
    /* Release locally allocated data, whether we succeeded or not */
    pg_free(password);
    PQconninfoFree(cinfo);
 
    if (!success)
    {
        /*
         * Failed to connect to the database. In interactive mode, keep the
         * previous connection to the DB; in scripting mode, close our
         * previous connection as well.
         */
        if (pset.cur_cmd_interactive)
        {
            if (n_conn)
            {
                pg_log_info("%s", PQerrorMessage(n_conn));
                PQfinish(n_conn);
            }
 
            /* pset.db is left unmodified */
            if (o_conn)
                pg_log_info("Previous connection kept");
        }
        else
        {
            if (n_conn)
            {
                pg_log_error("\\connect: %s", PQerrorMessage(n_conn));
                PQfinish(n_conn);
            }
 
            if (o_conn)
            {
                /*
                 * Transition to having no connection.
                 *
                 * Unlike CheckConnection(), we close the old connection
                 * immediately to prevent its parameters from being re-used.
                 * This is so that a script cannot accidentally reuse
                 * parameters it did not expect to.  Otherwise, the state
                 * cleanup should be the same as in CheckConnection().
                 */
                PQfinish(o_conn);
                pset.db = NULL;
                ResetCancelConn();
                UnsyncVariables();
            }
 
            /* On the same reasoning, release any dead_conn to prevent reuse */
            if (pset.dead_conn)
            {
                PQfinish(pset.dead_conn);
                pset.dead_conn = NULL;
            }
        }
 
        return false;
    }
 
    /*
     * Replace the old connection with the new one, and update
     * connection-dependent variables.  Keep the resynchronization logic in
     * sync with CheckConnection().
     */
    PQsetNoticeProcessor(n_conn, NoticeProcessor, NULL);
    pset.db = n_conn;
    SyncVariables();
    connection_warnings(false); /* Must be after SyncVariables */
 
    /* Tell the user about the new connection */
    if (!pset.quiet)
    {
        if (!o_conn ||
            param_is_newly_set(PQhost(o_conn), PQhost(pset.db)) ||
            param_is_newly_set(PQport(o_conn), PQport(pset.db)))
        {
            char       *connhost = PQhost(pset.db);
            char       *hostaddr = PQhostaddr(pset.db);
 
            if (is_unixsock_path(connhost))
            {
                /* hostaddr overrides connhost */
                if (hostaddr && *hostaddr)
                    printf(_("You are now connected to database \"%s\" as user \"%s\" on address \"%s\" at port \"%s\".\n"),
                           PQdb(pset.db), PQuser(pset.db), hostaddr, PQport(pset.db));
                else
                    printf(_("You are now connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n"),
                           PQdb(pset.db), PQuser(pset.db), connhost, PQport(pset.db));
            }
            else
            {
                if (hostaddr && *hostaddr && strcmp(connhost, hostaddr) != 0)
                    printf(_("You are now connected to database \"%s\" as user \"%s\" on host \"%s\" (address \"%s\") at port \"%s\".\n"),
                           PQdb(pset.db), PQuser(pset.db), connhost, hostaddr, PQport(pset.db));
                else
                    printf(_("You are now connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n"),
                           PQdb(pset.db), PQuser(pset.db), connhost, PQport(pset.db));
            }
        }
        else
            printf(_("You are now connected to database \"%s\" as user \"%s\".\n"),
                   PQdb(pset.db), PQuser(pset.db));
    }
 
    /* Drop no-longer-needed connection(s) */
    if (o_conn)
        PQfinish(o_conn);
    if (pset.dead_conn)
    {
        PQfinish(pset.dead_conn);
        pset.dead_conn = NULL;
    }
 
    return true;
}

References _, Assert(), CONNECTION_OK, connection_warnings(), _psqlSettings::cur_cmd_interactive, _psqlSettings::db, dbname, _psqlSettings::dead_conn, errmsg(), _psqlSettings::getPassword, is_unixsock_path(), _PQconninfoOption::keyword, keywords, NoticeProcessor(), _psqlSettings::notty, param_is_newly_set(), password, pg_free(), pg_log_error, pg_log_info, pg_malloc(), port, PQconndefaults(), PQconnectionNeedsPassword(), PQconnectStartParams(), PQconninfo(), PQconninfoFree(), PQconninfoParse(), PQdb(), PQerrorMessage(), PQfinish(), PQfreemem(), PQhost(), PQhostaddr(), PQport(), PQsetNoticeProcessor(), PQstatus(), PQuser(), printf, _psqlSettings::progname, prompt_for_password(), pset, _psqlSettings::quiet, recognized_connection_string(), ResetCancelConn(), success, SyncVariables(), TRI_NO, TRI_YES, UnsyncVariables(), user, _PQconninfoOption::val, values, and wait_until_connected().

Referenced by exec_command_connect().

do_edit()

static bool do_edit ( const char *  filename_arg, PQExpBuffer  query_buf, int  lineno, bool  discard_on_quit, bool *  edited  )

static

Definition at line 4623 of file command.c.

{
    char        fnametmp[MAXPGPATH];
    FILE       *stream = NULL;
    const char *fname;
    bool        error = false;
    int         fd;
    struct stat before,
                after;
 
    if (filename_arg)
        fname = filename_arg;
    else
    {
        /* make a temp file to edit */
#ifndef WIN32
        const char *tmpdir = getenv("TMPDIR");
 
        if (!tmpdir)
            tmpdir = "/tmp";
#else
        char        tmpdir[MAXPGPATH];
        int         ret;
 
        ret = GetTempPath(MAXPGPATH, tmpdir);
        if (ret == 0 || ret > MAXPGPATH)
        {
            pg_log_error("could not locate temporary directory: %s",
                         !ret ? strerror(errno) : "");
            return false;
        }
#endif
 
        /*
         * No canonicalize_path() here. EDIT.EXE run from CMD.EXE prepends the
         * current directory to the supplied path unless we use only
         * backslashes, so we do that.
         */
#ifndef WIN32
        snprintf(fnametmp, sizeof(fnametmp), "%s%spsql.edit.%d.sql", tmpdir,
                 "/", (int) getpid());
#else
        snprintf(fnametmp, sizeof(fnametmp), "%s%spsql.edit.%d.sql", tmpdir,
                 "" /* trailing separator already present */ , (int) getpid());
#endif
 
        fname = (const char *) fnametmp;
 
        fd = open(fname, O_WRONLY | O_CREAT | O_EXCL, 0600);
        if (fd != -1)
            stream = fdopen(fd, "w");
 
        if (fd == -1 || !stream)
        {
            pg_log_error("could not open temporary file \"%s\": %m", fname);
            error = true;
        }
        else
        {
            unsigned int ql = query_buf->len;
 
            /* force newline-termination of what we send to editor */
            if (ql > 0 && query_buf->data[ql - 1] != '\n')
            {
                appendPQExpBufferChar(query_buf, '\n');
                ql++;
            }
 
            if (fwrite(query_buf->data, 1, ql, stream) != ql)
            {
                pg_log_error("%s: %m", fname);
 
                if (fclose(stream) != 0)
                    pg_log_error("%s: %m", fname);
 
                if (remove(fname) != 0)
                    pg_log_error("%s: %m", fname);
 
                error = true;
            }
            else if (fclose(stream) != 0)
            {
                pg_log_error("%s: %m", fname);
                if (remove(fname) != 0)
                    pg_log_error("%s: %m", fname);
                error = true;
            }
            else
            {
                struct utimbuf ut;
 
                /*
                 * Try to set the file modification time of the temporary file
                 * a few seconds in the past.  Otherwise, the low granularity
                 * (one second, or even worse on some filesystems) that we can
                 * portably measure with stat(2) could lead us to not
                 * recognize a modification, if the user typed very quickly.
                 *
                 * This is a rather unlikely race condition, so don't error
                 * out if the utime(2) call fails --- that would make the cure
                 * worse than the disease.
                 */
                ut.modtime = ut.actime = time(NULL) - 2;
                (void) utime(fname, &ut);
            }
        }
    }
 
    if (!error && stat(fname, &before) != 0)
    {
        pg_log_error("%s: %m", fname);
        error = true;
    }
 
    /* call editor */
    if (!error)
        error = !editFile(fname, lineno);
 
    if (!error && stat(fname, &after) != 0)
    {
        pg_log_error("%s: %m", fname);
        error = true;
    }
 
    /* file was edited if the size or modification time has changed */
    if (!error &&
        (before.st_size != after.st_size ||
         before.st_mtime != after.st_mtime))
    {
        stream = fopen(fname, PG_BINARY_R);
        if (!stream)
        {
            pg_log_error("%s: %m", fname);
            error = true;
        }
        else
        {
            /* read file back into query_buf */
            char        line[1024];
 
            resetPQExpBuffer(query_buf);
            while (fgets(line, sizeof(line), stream) != NULL)
                appendPQExpBufferStr(query_buf, line);
 
            if (ferror(stream))
            {
                pg_log_error("%s: %m", fname);
                error = true;
                resetPQExpBuffer(query_buf);
            }
            else if (edited)
            {
                *edited = true;
            }
 
            fclose(stream);
        }
    }
    else
    {
        /*
         * If the file was not modified, and the caller requested it, discard
         * the query buffer.
         */
        if (discard_on_quit)
            resetPQExpBuffer(query_buf);
    }
 
    /* remove temp file */
    if (!filename_arg)
    {
        if (remove(fname) == -1)
        {
            pg_log_error("%s: %m", fname);
            error = true;
        }
    }
 
    return !error;
}

References appendPQExpBufferChar(), appendPQExpBufferStr(), before(), PQExpBufferData::data, editFile(), error(), fd(), PQExpBufferData::len, MAXPGPATH, PG_BINARY_R, pg_log_error, resetPQExpBuffer(), snprintf, stat::st_mtime, stat::st_size, stat, and strerror.

Referenced by exec_command_edit(), and exec_command_ef_ev().

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().

do_shell()

static bool do_shell ( const char *  command )

static

Definition at line 5720 of file command.c.

{
    int         result;
 
    fflush(NULL);
    if (!command)
    {
        char       *sys;
        const char *shellName;
 
        shellName = getenv("SHELL");
#ifdef WIN32
        if (shellName == NULL)
            shellName = getenv("COMSPEC");
#endif
        if (shellName == NULL)
            shellName = DEFAULT_SHELL;
 
        /* See EDITOR handling comment for an explanation */
#ifndef WIN32
        sys = psprintf("exec %s", shellName);
#else
        sys = psprintf("\"%s\"", shellName);
#endif
        result = system(sys);
        free(sys);
    }
    else
        result = system(command);
 
    SetShellResultVariables(result);
 
    if (result == 127 || result == -1)
    {
        pg_log_error("\\!: failed");
        return false;
    }
    return true;
}

References DEFAULT_SHELL, free, pg_log_error, psprintf(), and SetShellResultVariables().

Referenced by exec_command_shell_escape().

do_watch()

static bool do_watch ( PQExpBuffer  query_buf, double  sleep, int  iter, int  min_rows  )

static

Definition at line 5771 of file command.c.

{
    long        sleep_ms = (long) (sleep * 1000);
    printQueryOpt myopt = pset.popt;
    const char *strftime_fmt;
    const char *user_title;
    char       *title;
    const char *pagerprog = NULL;
    FILE       *pagerpipe = NULL;
    int         title_len;
    int         res = 0;
    bool        done = false;
#ifndef WIN32
    sigset_t    sigalrm_sigchld_sigint;
    sigset_t    sigalrm_sigchld;
    sigset_t    sigint;
    struct itimerval interval;
#endif
 
    if (!query_buf || query_buf->len <= 0)
    {
        pg_log_error("\\watch cannot be used with an empty query");
        return false;
    }
 
#ifndef WIN32
    sigemptyset(&sigalrm_sigchld_sigint);
    sigaddset(&sigalrm_sigchld_sigint, SIGCHLD);
    sigaddset(&sigalrm_sigchld_sigint, SIGALRM);
    sigaddset(&sigalrm_sigchld_sigint, SIGINT);
 
    sigemptyset(&sigalrm_sigchld);
    sigaddset(&sigalrm_sigchld, SIGCHLD);
    sigaddset(&sigalrm_sigchld, SIGALRM);
 
    sigemptyset(&sigint);
    sigaddset(&sigint, SIGINT);
 
    /*
     * Block SIGALRM and SIGCHLD before we start the timer and the pager (if
     * configured), to avoid races.  sigwait() will receive them.
     */
    sigprocmask(SIG_BLOCK, &sigalrm_sigchld, NULL);
 
    /*
     * Set a timer to interrupt sigwait() so we can run the query at the
     * requested intervals.
     */
    interval.it_value.tv_sec = sleep_ms / 1000;
    interval.it_value.tv_usec = (sleep_ms % 1000) * 1000;
    interval.it_interval = interval.it_value;
    if (setitimer(ITIMER_REAL, &interval, NULL) < 0)
    {
        pg_log_error("could not set timer: %m");
        done = true;
    }
#endif
 
    /*
     * For \watch, we ignore the size of the result and always use the pager
     * as long as we're talking to a terminal and "\pset pager" is enabled.
     * However, we'll only use the pager identified by PSQL_WATCH_PAGER.  We
     * ignore the regular PSQL_PAGER or PAGER environment variables, because
     * traditional pagers probably won't be very useful for showing a stream
     * of results.
     */
#ifndef WIN32
    pagerprog = getenv("PSQL_WATCH_PAGER");
    /* if variable is empty or all-white-space, don't use pager */
    if (pagerprog && strspn(pagerprog, " \t\r\n") == strlen(pagerprog))
        pagerprog = NULL;
#endif
    if (pagerprog && myopt.topt.pager &&
        isatty(fileno(stdin)) && isatty(fileno(stdout)))
    {
        fflush(NULL);
        disable_sigpipe_trap();
        pagerpipe = popen(pagerprog, "w");
 
        if (!pagerpipe)
            /* silently proceed without pager */
            restore_sigpipe_trap();
    }
 
    /*
     * Choose format for timestamps.  We might eventually make this a \pset
     * option.  In the meantime, using a variable for the format suppresses
     * overly-anal-retentive gcc warnings about %c being Y2K sensitive.
     */
    strftime_fmt = "%c";
 
    /*
     * Set up rendering options, in particular, disable the pager unless
     * PSQL_WATCH_PAGER was successfully launched.
     */
    if (!pagerpipe)
        myopt.topt.pager = 0;
 
    /*
     * If there's a title in the user configuration, make sure we have room
     * for it in the title buffer.  Allow 128 bytes for the timestamp plus 128
     * bytes for the rest.
     */
    user_title = myopt.title;
    title_len = (user_title ? strlen(user_title) : 0) + 256;
    title = pg_malloc(title_len);
 
    /* Loop to run query and then sleep awhile */
    while (!done)
    {
        time_t      timer;
        char        timebuf[128];
 
        /*
         * Prepare title for output.  Note that we intentionally include a
         * newline at the end of the title; this is somewhat historical but it
         * makes for reasonably nicely formatted output in simple cases.
         */
        timer = time(NULL);
        strftime(timebuf, sizeof(timebuf), strftime_fmt, localtime(&timer));
 
        if (user_title)
            snprintf(title, title_len, _("%s\t%s (every %gs)\n"),
                     user_title, timebuf, sleep_ms / 1000.0);
        else
            snprintf(title, title_len, _("%s (every %gs)\n"),
                     timebuf, sleep_ms / 1000.0);
        myopt.title = title;
 
        /* Run the query and print out the result */
        res = PSQLexecWatch(query_buf->data, &myopt, pagerpipe, min_rows);
 
        /*
         * PSQLexecWatch handles the case where we can no longer repeat the
         * query, and returns 0 or -1.
         */
        if (res <= 0)
            break;
 
        /* If we have iteration count, check that it's not exceeded yet */
        if (iter && (--iter <= 0))
            break;
 
        /* Quit if error on pager pipe (probably pager has quit) */
        if (pagerpipe && ferror(pagerpipe))
            break;
 
        /* Tight loop, no wait needed */
        if (sleep_ms == 0)
            continue;
 
#ifdef WIN32
 
        /*
         * Wait a while before running the query again.  Break the sleep into
         * short intervals (at most 1s); that's probably unnecessary since
         * pg_usleep is interruptible on Windows, but it's cheap insurance.
         */
        for (long i = sleep_ms; i > 0;)
        {
            long        s = Min(i, 1000L);
 
            pg_usleep(s * 1000L);
            if (cancel_pressed)
            {
                done = true;
                break;
            }
            i -= s;
        }
#else
        /* sigwait() will handle SIGINT. */
        sigprocmask(SIG_BLOCK, &sigint, NULL);
        if (cancel_pressed)
            done = true;
 
        /* Wait for SIGINT, SIGCHLD or SIGALRM. */
        while (!done)
        {
            int         signal_received;
 
            errno = sigwait(&sigalrm_sigchld_sigint, &signal_received);
            if (errno != 0)
            {
                /* Some other signal arrived? */
                if (errno == EINTR)
                    continue;
                else
                {
                    pg_log_error("could not wait for signals: %m");
                    done = true;
                    break;
                }
            }
            /* On ^C or pager exit, it's time to stop running the query. */
            if (signal_received == SIGINT || signal_received == SIGCHLD)
                done = true;
            /* Otherwise, we must have SIGALRM.  Time to run the query again. */
            break;
        }
 
        /* Unblock SIGINT so that slow queries can be interrupted. */
        sigprocmask(SIG_UNBLOCK, &sigint, NULL);
#endif
    }
 
    if (pagerpipe)
    {
        pclose(pagerpipe);
        restore_sigpipe_trap();
    }
    else
    {
        /*
         * If the terminal driver echoed "^C", libedit/libreadline might be
         * confused about the cursor position.  Therefore, inject a newline
         * before the next prompt is displayed.  We only do this when not
         * using a pager, because pagers are expected to restore the screen to
         * a sane state on exit.
         */
        fprintf(stdout, "\n");
        fflush(stdout);
    }
 
#ifndef WIN32
    /* Disable the interval timer. */
    memset(&interval, 0, sizeof(interval));
    setitimer(ITIMER_REAL, &interval, NULL);
    /* Unblock SIGINT, SIGCHLD and SIGALRM. */
    sigprocmask(SIG_UNBLOCK, &sigalrm_sigchld_sigint, NULL);
#endif
 
    pg_free(title);
    return (res >= 0);
}

References _, cancel_pressed, PQExpBufferData::data, disable_sigpipe_trap(), EINTR, fprintf, i, ITIMER_REAL, PQExpBufferData::len, Min, printTableOpt::pager, pg_free(), pg_log_error, pg_malloc(), pg_usleep(), _psqlSettings::popt, pset, PSQLexecWatch(), restore_sigpipe_trap(), setitimer(), SIGALRM, SIGCHLD, sleep_ms, snprintf, generate_unaccent_rules::stdout, printQueryOpt::title, and printQueryOpt::topt.

Referenced by exec_command_watch().

echo_hidden_command()

static bool echo_hidden_command ( const char *  query )

static

Definition at line 6012 of file command.c.

{
    if (pset.echo_hidden != PSQL_ECHO_HIDDEN_OFF)
    {
        printf(_("/******** QUERY *********/\n"
                 "%s\n"
                 "/************************/\n\n"), query);
        fflush(stdout);
        if (pset.logfile)
        {
            fprintf(pset.logfile,
                    _("/******** QUERY *********/\n"
                      "%s\n"
                      "/************************/\n\n"), query);
            fflush(pset.logfile);
        }
 
        if (pset.echo_hidden == PSQL_ECHO_HIDDEN_NOEXEC)
            return false;
    }
    return true;
}

References _, _psqlSettings::echo_hidden, fprintf, _psqlSettings::logfile, printf, pset, PSQL_ECHO_HIDDEN_NOEXEC, PSQL_ECHO_HIDDEN_OFF, and generate_unaccent_rules::stdout.

Referenced by get_create_object_cmd(), and lookup_object_oid().

editFile()

static bool editFile ( const char *  fname, int  lineno  )

static

Definition at line 4541 of file command.c.

{
    const char *editorName;
    const char *editor_lineno_arg = NULL;
    char       *sys;
    int         result;
 
    Assert(fname != NULL);
 
    /* Find an editor to use */
    editorName = getenv("PSQL_EDITOR");
    if (!editorName)
        editorName = getenv("EDITOR");
    if (!editorName)
        editorName = getenv("VISUAL");
    if (!editorName)
        editorName = DEFAULT_EDITOR;
 
    /* Get line number argument, if we need it. */
    if (lineno > 0)
    {
        editor_lineno_arg = getenv("PSQL_EDITOR_LINENUMBER_ARG");
#ifdef DEFAULT_EDITOR_LINENUMBER_ARG
        if (!editor_lineno_arg)
            editor_lineno_arg = DEFAULT_EDITOR_LINENUMBER_ARG;
#endif
        if (!editor_lineno_arg)
        {
            pg_log_error("environment variable PSQL_EDITOR_LINENUMBER_ARG must be set to specify a line number");
            return false;
        }
    }
 
    /*
     * On Unix the EDITOR value should *not* be quoted, since it might include
     * switches, eg, EDITOR="pico -t"; it's up to the user to put quotes in it
     * if necessary.  But this policy is not very workable on Windows, due to
     * severe brain damage in their command shell plus the fact that standard
     * program paths include spaces.
     */
#ifndef WIN32
    if (lineno > 0)
        sys = psprintf("exec %s %s%d '%s'",
                       editorName, editor_lineno_arg, lineno, fname);
    else
        sys = psprintf("exec %s '%s'",
                       editorName, fname);
#else
    if (lineno > 0)
        sys = psprintf("\"%s\" %s%d \"%s\"",
                       editorName, editor_lineno_arg, lineno, fname);
    else
        sys = psprintf("\"%s\" \"%s\"",
                       editorName, fname);
#endif
    fflush(NULL);
    result = system(sys);
    if (result == -1)
        pg_log_error("could not start editor \"%s\"", editorName);
    else if (result == 127)
        pg_log_error("could not start /bin/sh");
    free(sys);
 
    return result == 0;
}

References Assert(), DEFAULT_EDITOR, DEFAULT_EDITOR_LINENUMBER_ARG, free, pg_log_error, and psprintf().

Referenced by do_edit().

exec_command()

static backslashResult exec_command ( const char *  cmd, PsqlScanState  scan_state, ConditionalStack  cstack, PQExpBuffer  query_buf, PQExpBuffer  previous_buf  )

static

Definition at line 298 of file command.c.

{
    backslashResult status;
    bool        active_branch = conditional_active(cstack);
 
    /*
     * In interactive mode, warn when we're ignoring a command within a false
     * \if-branch.  But we continue on, so as to parse and discard the right
     * amount of parameter text.  Each individual backslash command subroutine
     * is responsible for doing nothing after discarding appropriate
     * arguments, if !active_branch.
     */
    if (pset.cur_cmd_interactive && !active_branch &&
        !is_branching_command(cmd))
    {
        pg_log_warning("\\%s command ignored; use \\endif or Ctrl-C to exit current \\if block",
                       cmd);
    }
 
    if (strcmp(cmd, "a") == 0)
        status = exec_command_a(scan_state, active_branch);
    else if (strcmp(cmd, "bind") == 0)
        status = exec_command_bind(scan_state, active_branch);
    else if (strcmp(cmd, "bind_named") == 0)
        status = exec_command_bind_named(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "C") == 0)
        status = exec_command_C(scan_state, active_branch);
    else if (strcmp(cmd, "c") == 0 || strcmp(cmd, "connect") == 0)
        status = exec_command_connect(scan_state, active_branch);
    else if (strcmp(cmd, "cd") == 0)
        status = exec_command_cd(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "close") == 0)
        status = exec_command_close(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "conninfo") == 0)
        status = exec_command_conninfo(scan_state, active_branch);
    else if (pg_strcasecmp(cmd, "copy") == 0)
        status = exec_command_copy(scan_state, active_branch);
    else if (strcmp(cmd, "copyright") == 0)
        status = exec_command_copyright(scan_state, active_branch);
    else if (strcmp(cmd, "crosstabview") == 0)
        status = exec_command_crosstabview(scan_state, active_branch);
    else if (cmd[0] == 'd')
        status = exec_command_d(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "e") == 0 || strcmp(cmd, "edit") == 0)
        status = exec_command_edit(scan_state, active_branch,
                                   query_buf, previous_buf);
    else if (strcmp(cmd, "ef") == 0)
        status = exec_command_ef_ev(scan_state, active_branch, query_buf, true);
    else if (strcmp(cmd, "ev") == 0)
        status = exec_command_ef_ev(scan_state, active_branch, query_buf, false);
    else if (strcmp(cmd, "echo") == 0 || strcmp(cmd, "qecho") == 0 ||
             strcmp(cmd, "warn") == 0)
        status = exec_command_echo(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "elif") == 0)
        status = exec_command_elif(scan_state, cstack, query_buf);
    else if (strcmp(cmd, "else") == 0)
        status = exec_command_else(scan_state, cstack, query_buf);
    else if (strcmp(cmd, "endif") == 0)
        status = exec_command_endif(scan_state, cstack, query_buf);
    else if (strcmp(cmd, "endpipeline") == 0)
        status = exec_command_endpipeline(scan_state, active_branch);
    else if (strcmp(cmd, "encoding") == 0)
        status = exec_command_encoding(scan_state, active_branch);
    else if (strcmp(cmd, "errverbose") == 0)
        status = exec_command_errverbose(scan_state, active_branch);
    else if (strcmp(cmd, "f") == 0)
        status = exec_command_f(scan_state, active_branch);
    else if (strcmp(cmd, "flush") == 0)
        status = exec_command_flush(scan_state, active_branch);
    else if (strcmp(cmd, "flushrequest") == 0)
        status = exec_command_flushrequest(scan_state, active_branch);
    else if (strcmp(cmd, "g") == 0 || strcmp(cmd, "gx") == 0)
        status = exec_command_g(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "gdesc") == 0)
        status = exec_command_gdesc(scan_state, active_branch);
    else if (strcmp(cmd, "getenv") == 0)
        status = exec_command_getenv(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "getresults") == 0)
        status = exec_command_getresults(scan_state, active_branch);
    else if (strcmp(cmd, "gexec") == 0)
        status = exec_command_gexec(scan_state, active_branch);
    else if (strcmp(cmd, "gset") == 0)
        status = exec_command_gset(scan_state, active_branch);
    else if (strcmp(cmd, "h") == 0 || strcmp(cmd, "help") == 0)
        status = exec_command_help(scan_state, active_branch);
    else if (strcmp(cmd, "H") == 0 || strcmp(cmd, "html") == 0)
        status = exec_command_html(scan_state, active_branch);
    else if (strcmp(cmd, "i") == 0 || strcmp(cmd, "include") == 0 ||
             strcmp(cmd, "ir") == 0 || strcmp(cmd, "include_relative") == 0)
        status = exec_command_include(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "if") == 0)
        status = exec_command_if(scan_state, cstack, query_buf);
    else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0 ||
             strcmp(cmd, "lx") == 0 || strcmp(cmd, "listx") == 0 ||
             strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0 ||
             strcmp(cmd, "lx+") == 0 || strcmp(cmd, "listx+") == 0 ||
             strcmp(cmd, "l+x") == 0 || strcmp(cmd, "list+x") == 0)
        status = exec_command_list(scan_state, active_branch, cmd);
    else if (strncmp(cmd, "lo_", 3) == 0)
        status = exec_command_lo(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "o") == 0 || strcmp(cmd, "out") == 0)
        status = exec_command_out(scan_state, active_branch);
    else if (strcmp(cmd, "p") == 0 || strcmp(cmd, "print") == 0)
        status = exec_command_print(scan_state, active_branch,
                                    query_buf, previous_buf);
    else if (strcmp(cmd, "parse") == 0)
        status = exec_command_parse(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "password") == 0)
        status = exec_command_password(scan_state, active_branch);
    else if (strcmp(cmd, "prompt") == 0)
        status = exec_command_prompt(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "pset") == 0)
        status = exec_command_pset(scan_state, active_branch);
    else if (strcmp(cmd, "q") == 0 || strcmp(cmd, "quit") == 0)
        status = exec_command_quit(scan_state, active_branch);
    else if (strcmp(cmd, "r") == 0 || strcmp(cmd, "reset") == 0)
        status = exec_command_reset(scan_state, active_branch, query_buf);
    else if (strcmp(cmd, "s") == 0)
        status = exec_command_s(scan_state, active_branch);
    else if (strcmp(cmd, "sendpipeline") == 0)
        status = exec_command_sendpipeline(scan_state, active_branch);
    else if (strcmp(cmd, "set") == 0)
        status = exec_command_set(scan_state, active_branch);
    else if (strcmp(cmd, "setenv") == 0)
        status = exec_command_setenv(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "sf") == 0 || strcmp(cmd, "sf+") == 0)
        status = exec_command_sf_sv(scan_state, active_branch, cmd, true);
    else if (strcmp(cmd, "sv") == 0 || strcmp(cmd, "sv+") == 0)
        status = exec_command_sf_sv(scan_state, active_branch, cmd, false);
    else if (strcmp(cmd, "startpipeline") == 0)
        status = exec_command_startpipeline(scan_state, active_branch);
    else if (strcmp(cmd, "syncpipeline") == 0)
        status = exec_command_syncpipeline(scan_state, active_branch);
    else if (strcmp(cmd, "t") == 0)
        status = exec_command_t(scan_state, active_branch);
    else if (strcmp(cmd, "T") == 0)
        status = exec_command_T(scan_state, active_branch);
    else if (strcmp(cmd, "timing") == 0)
        status = exec_command_timing(scan_state, active_branch);
    else if (strcmp(cmd, "unset") == 0)
        status = exec_command_unset(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "w") == 0 || strcmp(cmd, "write") == 0)
        status = exec_command_write(scan_state, active_branch, cmd,
                                    query_buf, previous_buf);
    else if (strcmp(cmd, "watch") == 0)
        status = exec_command_watch(scan_state, active_branch,
                                    query_buf, previous_buf);
    else if (strcmp(cmd, "x") == 0)
        status = exec_command_x(scan_state, active_branch);
    else if (strcmp(cmd, "z") == 0 ||
             strcmp(cmd, "zS") == 0 || strcmp(cmd, "zx") == 0 ||
             strcmp(cmd, "zSx") == 0 || strcmp(cmd, "zxS") == 0)
        status = exec_command_z(scan_state, active_branch, cmd);
    else if (strcmp(cmd, "!") == 0)
        status = exec_command_shell_escape(scan_state, active_branch);
    else if (strcmp(cmd, "?") == 0)
        status = exec_command_slash_command_help(scan_state, active_branch);
    else
        status = PSQL_CMD_UNKNOWN;
 
    /*
     * All the commands that return PSQL_CMD_SEND want to execute previous_buf
     * if query_buf is empty.  For convenience we implement that here, not in
     * the individual command subroutines.
     */
    if (status == PSQL_CMD_SEND)
        (void) copy_previous_query(query_buf, previous_buf);
 
    return status;
}

References conditional_active(), copy_previous_query(), _psqlSettings::cur_cmd_interactive, exec_command_a(), exec_command_bind(), exec_command_bind_named(), exec_command_C(), exec_command_cd(), exec_command_close(), exec_command_connect(), exec_command_conninfo(), exec_command_copy(), exec_command_copyright(), exec_command_crosstabview(), exec_command_d(), exec_command_echo(), exec_command_edit(), exec_command_ef_ev(), exec_command_elif(), exec_command_else(), exec_command_encoding(), exec_command_endif(), exec_command_endpipeline(), exec_command_errverbose(), exec_command_f(), exec_command_flush(), exec_command_flushrequest(), exec_command_g(), exec_command_gdesc(), exec_command_getenv(), exec_command_getresults(), exec_command_gexec(), exec_command_gset(), exec_command_help(), exec_command_html(), exec_command_if(), exec_command_include(), exec_command_list(), exec_command_lo(), exec_command_out(), exec_command_parse(), exec_command_password(), exec_command_print(), exec_command_prompt(), exec_command_pset(), exec_command_quit(), exec_command_reset(), exec_command_s(), exec_command_sendpipeline(), exec_command_set(), exec_command_setenv(), exec_command_sf_sv(), exec_command_shell_escape(), exec_command_slash_command_help(), exec_command_startpipeline(), exec_command_syncpipeline(), exec_command_t(), exec_command_T(), exec_command_timing(), exec_command_unset(), exec_command_watch(), exec_command_write(), exec_command_x(), exec_command_z(), is_branching_command(), pg_log_warning, pg_strcasecmp(), pset, PSQL_CMD_SEND, and PSQL_CMD_UNKNOWN.

Referenced by HandleSlashCmds().

exec_command_a()

static backslashResult exec_command_a ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 480 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        if (pset.popt.topt.format != PRINT_ALIGNED)
            success = do_pset("format", "aligned", &pset.popt, pset.quiet);
        else
            success = do_pset("format", "unaligned", &pset.popt, pset.quiet);
    }
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), printTableOpt::format, _psqlSettings::popt, PRINT_ALIGNED, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, _psqlSettings::quiet, success, and printQueryOpt::topt.

Referenced by exec_command().

exec_command_bind()

static backslashResult exec_command_bind ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 499 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *opt;
        int         nparams = 0;
        int         nalloc = 0;
 
        clean_extended_state();
 
        while ((opt = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false)))
        {
            nparams++;
            if (nparams > nalloc)
            {
                nalloc = nalloc ? nalloc * 2 : 1;
                pset.bind_params = pg_realloc_array(pset.bind_params, char *, nalloc);
            }
            pset.bind_params[nparams - 1] = opt;
        }
 
        pset.bind_nparams = nparams;
        pset.send_mode = PSQL_SEND_EXTENDED_QUERY_PARAMS;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References _psqlSettings::bind_nparams, _psqlSettings::bind_params, clean_extended_state(), ignore_slash_options(), OT_NORMAL, pg_realloc_array, pset, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), PSQL_SEND_EXTENDED_QUERY_PARAMS, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_bind_named()

static backslashResult exec_command_bind_named ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 535 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *opt;
        int         nparams = 0;
        int         nalloc = 0;
 
        clean_extended_state();
 
        /* get the mandatory prepared statement name */
        opt = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false);
        if (!opt)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            status = PSQL_CMD_ERROR;
        }
        else
        {
            pset.stmtName = opt;
            pset.send_mode = PSQL_SEND_EXTENDED_QUERY_PREPARED;
 
            /* set of parameters */
            while ((opt = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false)))
            {
                nparams++;
                if (nparams > nalloc)
                {
                    nalloc = nalloc ? nalloc * 2 : 1;
                    pset.bind_params = pg_realloc_array(pset.bind_params, char *, nalloc);
                }
                pset.bind_params[nparams - 1] = opt;
            }
            pset.bind_nparams = nparams;
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References _psqlSettings::bind_nparams, _psqlSettings::bind_params, clean_extended_state(), ignore_slash_options(), OT_NORMAL, pg_log_error, pg_realloc_array, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), PSQL_SEND_EXTENDED_QUERY_PREPARED, _psqlSettings::send_mode, and _psqlSettings::stmtName.

Referenced by exec_command().

exec_command_C()

static backslashResult exec_command_C ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 584 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, true);
 
        success = do_pset("title", opt, &pset.popt, pset.quiet);
        free(opt);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), free, ignore_slash_options(), OT_NORMAL, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, and success.

Referenced by exec_command().

exec_command_cd()

static backslashResult exec_command_cd ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 670 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, true);
        char       *dir;
 
        if (opt)
            dir = opt;
        else
        {
#ifndef WIN32
            /* This should match get_home_path() */
            dir = getenv("HOME");
            if (dir == NULL || dir[0] == '\0')
            {
                uid_t       user_id = geteuid();
                struct passwd *pw;
 
                errno = 0;      /* clear errno before call */
                pw = getpwuid(user_id);
                if (pw)
                    dir = pw->pw_dir;
                else
                {
                    pg_log_error("could not get home directory for user ID %ld: %s",
                                 (long) user_id,
                                 errno ? strerror(errno) : _("user does not exist"));
                    success = false;
                }
            }
#else                           /* WIN32 */
 
            /*
             * On Windows, 'cd' without arguments prints the current
             * directory, so if someone wants to code this here instead...
             */
            dir = "/";
#endif                          /* WIN32 */
        }
 
        if (success &&
            chdir(dir) < 0)
        {
            pg_log_error("\\%s: could not change directory to \"%s\": %m",
                         cmd, dir);
            success = false;
        }
 
        free(opt);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References _, free, ignore_slash_options(), OT_NORMAL, pg_log_error, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), strerror, and success.

Referenced by exec_command().

exec_command_close()

static backslashResult exec_command_close ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 734 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, false);
 
        clean_extended_state();
 
        if (!opt)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            status = PSQL_CMD_ERROR;
        }
        else
        {
            pset.stmtName = opt;
            pset.send_mode = PSQL_SEND_EXTENDED_CLOSE;
            status = PSQL_CMD_SEND;
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References clean_extended_state(), ignore_slash_options(), OT_NORMAL, pg_log_error, pset, PSQL_CMD_ERROR, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), PSQL_SEND_EXTENDED_CLOSE, _psqlSettings::send_mode, and _psqlSettings::stmtName.

Referenced by exec_command().

exec_command_connect()

static backslashResult exec_command_connect ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 617 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        static const char prefix[] = "-reuse-previous=";
        char       *opt1,
                   *opt2,
                   *opt3,
                   *opt4;
        enum trivalue reuse_previous = TRI_DEFAULT;
 
        opt1 = read_connect_arg(scan_state);
        if (opt1 != NULL && strncmp(opt1, prefix, sizeof(prefix) - 1) == 0)
        {
            bool        on_off;
 
            success = ParseVariableBool(opt1 + sizeof(prefix) - 1,
                                        "-reuse-previous",
                                        &on_off);
            if (success)
            {
                reuse_previous = on_off ? TRI_YES : TRI_NO;
                free(opt1);
                opt1 = read_connect_arg(scan_state);
            }
        }
 
        if (success)            /* give up if reuse_previous was invalid */
        {
            opt2 = read_connect_arg(scan_state);
            opt3 = read_connect_arg(scan_state);
            opt4 = read_connect_arg(scan_state);
 
            success = do_connect(reuse_previous, opt1, opt2, opt3, opt4);
 
            free(opt2);
            free(opt3);
            free(opt4);
        }
        free(opt1);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_connect(), free, ignore_slash_options(), ParseVariableBool(), PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, read_connect_arg(), success, TRI_DEFAULT, TRI_NO, and TRI_YES.

Referenced by exec_command().

exec_command_conninfo()

static backslashResult exec_command_conninfo ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 767 of file command.c.

{
    printTableContent cont;
    int         rows,
                cols;
    char       *db;
    char       *host;
    bool        print_hostaddr;
    char       *hostaddr;
    char       *protocol_version,
               *backend_pid;
    int         ssl_in_use,
                password_used,
                gssapi_used;
    char       *paramval;
 
    if (!active_branch)
        return PSQL_CMD_SKIP_LINE;
 
    db = PQdb(pset.db);
    if (db == NULL)
    {
        printf(_("You are currently not connected to a database.\n"));
        return PSQL_CMD_SKIP_LINE;
    }
 
    /* Get values for the parameters */
    host = PQhost(pset.db);
    hostaddr = PQhostaddr(pset.db);
    protocol_version = psprintf("%d", PQprotocolVersion(pset.db));
    ssl_in_use = PQsslInUse(pset.db);
    password_used = PQconnectionUsedPassword(pset.db);
    gssapi_used = PQconnectionUsedGSSAPI(pset.db);
    backend_pid = psprintf("%d", PQbackendPID(pset.db));
 
    /* Only print hostaddr if it differs from host, and not if unixsock */
    print_hostaddr = (!is_unixsock_path(host) &&
                      hostaddr && *hostaddr && strcmp(host, hostaddr) != 0);
 
    /* Determine the exact number of rows to print */
    rows = 12;
    cols = 2;
    if (ssl_in_use)
        rows += 6;
    if (print_hostaddr)
        rows++;
 
    /* Set it all up */
    printTableInit(&cont, &pset.popt.topt, _("Connection Information"), cols, rows);
    printTableAddHeader(&cont, _("Parameter"), true, 'l');
    printTableAddHeader(&cont, _("Value"), true, 'l');
 
    /* Database */
    printTableAddCell(&cont, _("Database"), false, false);
    printTableAddCell(&cont, db, false, false);
 
    /* Client User */
    printTableAddCell(&cont, _("Client User"), false, false);
    printTableAddCell(&cont, PQuser(pset.db), false, false);
 
    /* Host/hostaddr/socket */
    if (is_unixsock_path(host))
    {
        /* hostaddr if specified overrides socket, so suppress the latter */
        if (hostaddr && *hostaddr)
        {
            printTableAddCell(&cont, _("Host Address"), false, false);
            printTableAddCell(&cont, hostaddr, false, false);
        }
        else
        {
            printTableAddCell(&cont, _("Socket Directory"), false, false);
            printTableAddCell(&cont, host, false, false);
        }
    }
    else
    {
        printTableAddCell(&cont, _("Host"), false, false);
        printTableAddCell(&cont, host, false, false);
        if (print_hostaddr)
        {
            printTableAddCell(&cont, _("Host Address"), false, false);
            printTableAddCell(&cont, hostaddr, false, false);
        }
    }
 
    /* Server Port */
    printTableAddCell(&cont, _("Server Port"), false, false);
    printTableAddCell(&cont, PQport(pset.db), false, false);
 
    /* Options */
    printTableAddCell(&cont, _("Options"), false, false);
    printTableAddCell(&cont, PQoptions(pset.db), false, false);
 
    /* Protocol Version */
    printTableAddCell(&cont, _("Protocol Version"), false, false);
    printTableAddCell(&cont, protocol_version, false, false);
 
    /* Password Used */
    printTableAddCell(&cont, _("Password Used"), false, false);
    printTableAddCell(&cont, password_used ? _("true") : _("false"), false, false);
 
    /* GSSAPI Authenticated */
    printTableAddCell(&cont, _("GSSAPI Authenticated"), false, false);
    printTableAddCell(&cont, gssapi_used ? _("true") : _("false"), false, false);
 
    /* Backend PID */
    printTableAddCell(&cont, _("Backend PID"), false, false);
    printTableAddCell(&cont, backend_pid, false, false);
 
    /* TLS Connection */
    printTableAddCell(&cont, _("TLS Connection"), false, false);
    printTableAddCell(&cont, ssl_in_use ? _("true") : _("false"), false, false);
 
    /* TLS Information */
    if (ssl_in_use)
    {
        char       *library,
                   *protocol,
                   *key_bits,
                   *cipher,
                   *compression,
                   *alpn;
 
        library = (char *) PQsslAttribute(pset.db, "library");
        protocol = (char *) PQsslAttribute(pset.db, "protocol");
        key_bits = (char *) PQsslAttribute(pset.db, "key_bits");
        cipher = (char *) PQsslAttribute(pset.db, "cipher");
        compression = (char *) PQsslAttribute(pset.db, "compression");
        alpn = (char *) PQsslAttribute(pset.db, "alpn");
 
        printTableAddCell(&cont, _("TLS Library"), false, false);
        printTableAddCell(&cont, library ? library : _("unknown"), false, false);
 
        printTableAddCell(&cont, _("TLS Protocol"), false, false);
        printTableAddCell(&cont, protocol ? protocol : _("unknown"), false, false);
 
        printTableAddCell(&cont, _("TLS Key Bits"), false, false);
        printTableAddCell(&cont, key_bits ? key_bits : _("unknown"), false, false);
 
        printTableAddCell(&cont, _("TLS Cipher"), false, false);
        printTableAddCell(&cont, cipher ? cipher : _("unknown"), false, false);
 
        printTableAddCell(&cont, _("TLS Compression"), false, false);
        printTableAddCell(&cont, (compression && strcmp(compression, "off") != 0) ?
                          _("true") : _("false"), false, false);
 
        printTableAddCell(&cont, _("ALPN"), false, false);
        printTableAddCell(&cont, (alpn && alpn[0] != '\0') ? alpn : _("none"), false, false);
    }
 
    paramval = (char *) PQparameterStatus(pset.db, "is_superuser");
    printTableAddCell(&cont, "Superuser", false, false);
    printTableAddCell(&cont, paramval ? paramval : _("unknown"), false, false);
 
    paramval = (char *) PQparameterStatus(pset.db, "in_hot_standby");
    printTableAddCell(&cont, "Hot Standby", false, false);
    printTableAddCell(&cont, paramval ? paramval : _("unknown"), false, false);
 
    printTable(&cont, pset.queryFout, false, pset.logfile);
    printTableCleanup(&cont);
 
    pfree(protocol_version);
    pfree(backend_pid);
 
    return PSQL_CMD_SKIP_LINE;
}

References _, _psqlSettings::db, is_unixsock_path(), _psqlSettings::logfile, pfree(), _psqlSettings::popt, PQbackendPID(), PQconnectionUsedGSSAPI(), PQconnectionUsedPassword(), PQdb(), PQhost(), PQhostaddr(), PQoptions(), PQparameterStatus(), PQport(), PQprotocolVersion(), PQsslAttribute(), PQsslInUse(), PQuser(), printf, printTable(), printTableAddCell(), printTableAddHeader(), printTableCleanup(), printTableInit(), pset, psprintf(), PSQL_CMD_SKIP_LINE, _psqlSettings::queryFout, and printQueryOpt::topt.

Referenced by exec_command().

exec_command_copy()

static backslashResult exec_command_copy ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 939 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_WHOLE_LINE, NULL, false);
 
        success = do_copy(opt);
        free(opt);
    }
    else
        ignore_slash_whole_line(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_copy(), free, ignore_slash_whole_line(), OT_WHOLE_LINE, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), and success.

Referenced by exec_command().

exec_command_copyright()

static backslashResult exec_command_copyright ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 961 of file command.c.

{
    if (active_branch)
        print_copyright();
 
    return PSQL_CMD_SKIP_LINE;
}

References print_copyright(), and PSQL_CMD_SKIP_LINE.

Referenced by exec_command().

exec_command_crosstabview()

static backslashResult exec_command_crosstabview ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 973 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        int         i;
 
        for (i = 0; i < lengthof(pset.ctv_args); i++)
            pset.ctv_args[i] = psql_scan_slash_option(scan_state,
                                                      OT_NORMAL, NULL, true);
        pset.crosstab_flag = true;
        status = PSQL_CMD_SEND;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References _psqlSettings::crosstab_flag, _psqlSettings::ctv_args, i, ignore_slash_options(), lengthof, OT_NORMAL, pset, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, and psql_scan_slash_option().

Referenced by exec_command().

exec_command_d()

static backslashResult exec_command_d ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 997 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
    bool        success = true;
 
    if (active_branch)
    {
        char       *pattern;
        bool        show_verbose,
                    show_system;
        unsigned short int save_expanded;
 
        /* We don't do SQLID reduction on the pattern yet */
        pattern = psql_scan_slash_option(scan_state,
                                         OT_NORMAL, NULL, true);
 
        show_verbose = strchr(cmd, '+') ? true : false;
        show_system = strchr(cmd, 'S') ? true : false;
 
        /*
         * The 'x' option turns expanded mode on for this command only. This
         * is allowed in all \d* commands, except \d by itself, since \dx is a
         * separate command. So the 'x' option cannot appear immediately after
         * \d, but it can appear after \d followed by other options.
         */
        save_expanded = pset.popt.topt.expanded;
        if (cmd[1] != '\0' && strchr(&cmd[2], 'x'))
            pset.popt.topt.expanded = 1;
 
        switch (cmd[1])
        {
            case '\0':
            case '+':
            case 'S':
                if (pattern)
                    success = describeTableDetails(pattern, show_verbose, show_system);
                else
                    /* standard listing of interesting things */
                    success = listTables("tvmsE", NULL, show_verbose, show_system);
                break;
            case 'A':
                {
                    char       *pattern2 = NULL;
 
                    if (pattern && cmd[2] != '\0' && cmd[2] != '+' && cmd[2] != 'x')
                        pattern2 = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, true);
 
                    switch (cmd[2])
                    {
                        case '\0':
                        case '+':
                        case 'x':
                            success = describeAccessMethods(pattern, show_verbose);
                            break;
                        case 'c':
                            success = listOperatorClasses(pattern, pattern2, show_verbose);
                            break;
                        case 'f':
                            success = listOperatorFamilies(pattern, pattern2, show_verbose);
                            break;
                        case 'o':
                            success = listOpFamilyOperators(pattern, pattern2, show_verbose);
                            break;
                        case 'p':
                            success = listOpFamilyFunctions(pattern, pattern2, show_verbose);
                            break;
                        default:
                            status = PSQL_CMD_UNKNOWN;
                            break;
                    }
 
                    free(pattern2);
                }
                break;
            case 'a':
                success = describeAggregates(pattern, show_verbose, show_system);
                break;
            case 'b':
                success = describeTablespaces(pattern, show_verbose);
                break;
            case 'c':
                if (strncmp(cmd, "dconfig", 7) == 0)
                    success = describeConfigurationParameters(pattern,
                                                              show_verbose,
                                                              show_system);
                else
                    success = listConversions(pattern,
                                              show_verbose,
                                              show_system);
                break;
            case 'C':
                success = listCasts(pattern, show_verbose);
                break;
            case 'd':
                if (strncmp(cmd, "ddp", 3) == 0)
                    success = listDefaultACLs(pattern);
                else
                    success = objectDescription(pattern, show_system);
                break;
            case 'D':
                success = listDomains(pattern, show_verbose, show_system);
                break;
            case 'f':           /* function subsystem */
                switch (cmd[2])
                {
                    case '\0':
                    case '+':
                    case 'S':
                    case 'a':
                    case 'n':
                    case 'p':
                    case 't':
                    case 'w':
                    case 'x':
                        success = exec_command_dfo(scan_state, cmd, pattern,
                                                   show_verbose, show_system);
                        break;
                    default:
                        status = PSQL_CMD_UNKNOWN;
                        break;
                }
                break;
            case 'g':
                /* no longer distinct from \du */
                success = describeRoles(pattern, show_verbose, show_system);
                break;
            case 'l':
                success = listLargeObjects(show_verbose);
                break;
            case 'L':
                success = listLanguages(pattern, show_verbose, show_system);
                break;
            case 'n':
                success = listSchemas(pattern, show_verbose, show_system);
                break;
            case 'o':
                success = exec_command_dfo(scan_state, cmd, pattern,
                                           show_verbose, show_system);
                break;
            case 'O':
                success = listCollations(pattern, show_verbose, show_system);
                break;
            case 'p':
                success = permissionsList(pattern, show_system);
                break;
            case 'P':
                {
                    switch (cmd[2])
                    {
                        case '\0':
                        case '+':
                        case 't':
                        case 'i':
                        case 'n':
                        case 'x':
                            success = listPartitionedTables(&cmd[2], pattern, show_verbose);
                            break;
                        default:
                            status = PSQL_CMD_UNKNOWN;
                            break;
                    }
                }
                break;
            case 'T':
                success = describeTypes(pattern, show_verbose, show_system);
                break;
            case 't':
            case 'v':
            case 'm':
            case 'i':
            case 's':
            case 'E':
                success = listTables(&cmd[1], pattern, show_verbose, show_system);
                break;
            case 'r':
                if (cmd[2] == 'd' && cmd[3] == 's')
                {
                    char       *pattern2 = NULL;
 
                    if (pattern)
                        pattern2 = psql_scan_slash_option(scan_state,
                                                          OT_NORMAL, NULL, true);
                    success = listDbRoleSettings(pattern, pattern2);
 
                    free(pattern2);
                }
                else if (cmd[2] == 'g')
                    success = describeRoleGrants(pattern, show_system);
                else
                    status = PSQL_CMD_UNKNOWN;
                break;
            case 'R':
                switch (cmd[2])
                {
                    case 'p':
                        if (show_verbose)
                            success = describePublications(pattern);
                        else
                            success = listPublications(pattern);
                        break;
                    case 's':
                        success = describeSubscriptions(pattern, show_verbose);
                        break;
                    default:
                        status = PSQL_CMD_UNKNOWN;
                }
                break;
            case 'u':
                success = describeRoles(pattern, show_verbose, show_system);
                break;
            case 'F':           /* text search subsystem */
                switch (cmd[2])
                {
                    case '\0':
                    case '+':
                    case 'x':
                        success = listTSConfigs(pattern, show_verbose);
                        break;
                    case 'p':
                        success = listTSParsers(pattern, show_verbose);
                        break;
                    case 'd':
                        success = listTSDictionaries(pattern, show_verbose);
                        break;
                    case 't':
                        success = listTSTemplates(pattern, show_verbose);
                        break;
                    default:
                        status = PSQL_CMD_UNKNOWN;
                        break;
                }
                break;
            case 'e':           /* SQL/MED subsystem */
                switch (cmd[2])
                {
                    case 's':
                        success = listForeignServers(pattern, show_verbose);
                        break;
                    case 'u':
                        success = listUserMappings(pattern, show_verbose);
                        break;
                    case 'w':
                        success = listForeignDataWrappers(pattern, show_verbose);
                        break;
                    case 't':
                        success = listForeignTables(pattern, show_verbose);
                        break;
                    default:
                        status = PSQL_CMD_UNKNOWN;
                        break;
                }
                break;
            case 'x':           /* Extensions */
                if (show_verbose)
                    success = listExtensionContents(pattern);
                else
                    success = listExtensions(pattern);
                break;
            case 'X':           /* Extended Statistics */
                success = listExtendedStats(pattern);
                break;
            case 'y':           /* Event Triggers */
                success = listEventTriggers(pattern, show_verbose);
                break;
            default:
                status = PSQL_CMD_UNKNOWN;
        }
 
        /* Restore original expanded mode */
        pset.popt.topt.expanded = save_expanded;
 
        free(pattern);
    }
    else
        ignore_slash_options(scan_state);
 
    if (!success)
        status = PSQL_CMD_ERROR;
 
    return status;
}

References describeAccessMethods(), describeAggregates(), describeConfigurationParameters(), describePublications(), describeRoleGrants(), describeRoles(), describeSubscriptions(), describeTableDetails(), describeTablespaces(), describeTypes(), exec_command_dfo(), printTableOpt::expanded, free, ignore_slash_options(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtendedStats(), listExtensionContents(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listLargeObjects(), listOperatorClasses(), listOperatorFamilies(), listOpFamilyFunctions(), listOpFamilyOperators(), listPartitionedTables(), listPublications(), listSchemas(), listTables(), listTSConfigs(), listTSDictionaries(), listTSParsers(), listTSTemplates(), listUserMappings(), objectDescription(), OT_NORMAL, permissionsList(), _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, PSQL_CMD_UNKNOWN, psql_scan_slash_option(), success, printQueryOpt::topt, and true.

Referenced by exec_command().

exec_command_dfo()

static bool exec_command_dfo ( PsqlScanState  scan_state, const char *  cmd, const char *  pattern, bool  show_verbose, bool  show_system  )

static

Definition at line 1281 of file command.c.

{
    bool        success;
    char       *arg_patterns[FUNC_MAX_ARGS];
    int         num_arg_patterns = 0;
 
    /* Collect argument-type patterns too */
    if (pattern)                /* otherwise it was just \df or \do */
    {
        char       *ap;
 
        while ((ap = psql_scan_slash_option(scan_state,
                                            OT_NORMAL, NULL, true)) != NULL)
        {
            arg_patterns[num_arg_patterns++] = ap;
            if (num_arg_patterns >= FUNC_MAX_ARGS)
                break;          /* protect limited-size array */
        }
    }
 
    if (cmd[1] == 'f')
        success = describeFunctions(&cmd[2], pattern,
                                    arg_patterns, num_arg_patterns,
                                    show_verbose, show_system);
    else
        success = describeOperators(pattern,
                                    arg_patterns, num_arg_patterns,
                                    show_verbose, show_system);
 
    while (--num_arg_patterns >= 0)
        free(arg_patterns[num_arg_patterns]);
 
    return success;
}

References describeFunctions(), describeOperators(), free, FUNC_MAX_ARGS, OT_NORMAL, psql_scan_slash_option(), and success.

Referenced by exec_command_d().

exec_command_echo()

static backslashResult exec_command_echo ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 1535 of file command.c.

{
    if (active_branch)
    {
        char       *value;
        char        quoted;
        bool        no_newline = false;
        bool        first = true;
        FILE       *fout;
 
        if (strcmp(cmd, "qecho") == 0)
            fout = pset.queryFout;
        else if (strcmp(cmd, "warn") == 0)
            fout = stderr;
        else
            fout = stdout;
 
        while ((value = psql_scan_slash_option(scan_state,
                                               OT_NORMAL, &quoted, false)))
        {
            if (first && !no_newline && !quoted && strcmp(value, "-n") == 0)
                no_newline = true;
            else
            {
                if (first)
                    first = false;
                else
                    fputc(' ', fout);
                fputs(value, fout);
            }
            free(value);
        }
        if (!no_newline)
            fputs("\n", fout);
    }
    else
        ignore_slash_options(scan_state);
 
    return PSQL_CMD_SKIP_LINE;
}

References free, ignore_slash_options(), OT_NORMAL, pset, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::queryFout, generate_unaccent_rules::stdout, and value.

Referenced by exec_command().

exec_command_edit()

static backslashResult exec_command_edit ( PsqlScanState  scan_state, bool  active_branch, PQExpBuffer  query_buf, PQExpBuffer  previous_buf  )

static

Definition at line 1323 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        if (!query_buf)
        {
            pg_log_error("no query buffer");
            status = PSQL_CMD_ERROR;
        }
        else
        {
            char       *fname;
            char       *ln = NULL;
            int         lineno = -1;
 
            fname = psql_scan_slash_option(scan_state,
                                           OT_NORMAL, NULL, true);
            if (fname)
            {
                /* try to get separate lineno arg */
                ln = psql_scan_slash_option(scan_state,
                                            OT_NORMAL, NULL, true);
                if (ln == NULL)
                {
                    /* only one arg; maybe it is lineno not fname */
                    if (fname[0] &&
                        strspn(fname, "0123456789") == strlen(fname))
                    {
                        /* all digits, so assume it is lineno */
                        ln = fname;
                        fname = NULL;
                    }
                }
            }
            if (ln)
            {
                lineno = atoi(ln);
                if (lineno < 1)
                {
                    pg_log_error("invalid line number: %s", ln);
                    status = PSQL_CMD_ERROR;
                }
            }
            if (status != PSQL_CMD_ERROR)
            {
                bool        discard_on_quit;
 
                expand_tilde(&fname);
                if (fname)
                {
                    canonicalize_path_enc(fname, pset.encoding);
                    /* Always clear buffer if the file isn't modified */
                    discard_on_quit = true;
                }
                else
                {
                    /*
                     * If query_buf is empty, recall previous query for
                     * editing.  But in that case, the query buffer should be
                     * emptied if editing doesn't modify the file.
                     */
                    discard_on_quit = copy_previous_query(query_buf,
                                                          previous_buf);
                }
 
                if (do_edit(fname, query_buf, lineno, discard_on_quit, NULL))
                    status = PSQL_CMD_NEWEDIT;
                else
                    status = PSQL_CMD_ERROR;
            }
 
            /*
             * On error while editing or if specifying an incorrect line
             * number, reset the query buffer.
             */
            if (status == PSQL_CMD_ERROR)
                resetPQExpBuffer(query_buf);
 
            free(fname);
            free(ln);
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References canonicalize_path_enc(), copy_previous_query(), do_edit(), _psqlSettings::encoding, expand_tilde(), free, ignore_slash_options(), OT_NORMAL, pg_log_error, pset, PSQL_CMD_ERROR, PSQL_CMD_NEWEDIT, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), and resetPQExpBuffer().

Referenced by exec_command().

exec_command_ef_ev()

static backslashResult exec_command_ef_ev ( PsqlScanState  scan_state, bool  active_branch, PQExpBuffer  query_buf, bool  is_func  )

static

Definition at line 1419 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *obj_desc = psql_scan_slash_option(scan_state,
                                                      OT_WHOLE_LINE,
                                                      NULL, true);
        int         lineno = -1;
 
        if (!query_buf)
        {
            pg_log_error("no query buffer");
            status = PSQL_CMD_ERROR;
        }
        else
        {
            Oid         obj_oid = InvalidOid;
            EditableObjectType eot = is_func ? EditableFunction : EditableView;
 
            lineno = strip_lineno_from_objdesc(obj_desc);
            if (lineno == 0)
            {
                /* error already reported */
                status = PSQL_CMD_ERROR;
            }
            else if (!obj_desc)
            {
                /* set up an empty command to fill in */
                resetPQExpBuffer(query_buf);
                if (is_func)
                    appendPQExpBufferStr(query_buf,
                                         "CREATE FUNCTION ( )\n"
                                         " RETURNS \n"
                                         " LANGUAGE \n"
                                         " -- common options:  IMMUTABLE  STABLE  STRICT  SECURITY DEFINER\n"
                                         "AS $function$\n"
                                         "\n$function$\n");
                else
                    appendPQExpBufferStr(query_buf,
                                         "CREATE VIEW  AS\n"
                                         " SELECT \n"
                                         "  -- something...\n");
            }
            else if (!lookup_object_oid(eot, obj_desc, &obj_oid))
            {
                /* error already reported */
                status = PSQL_CMD_ERROR;
            }
            else if (!get_create_object_cmd(eot, obj_oid, query_buf))
            {
                /* error already reported */
                status = PSQL_CMD_ERROR;
            }
            else if (is_func && lineno > 0)
            {
                /*
                 * lineno "1" should correspond to the first line of the
                 * function body.  We expect that pg_get_functiondef() will
                 * emit that on a line beginning with "AS ", "BEGIN ", or
                 * "RETURN ", and that there can be no such line before the
                 * real start of the function body.  Increment lineno by the
                 * number of lines before that line, so that it becomes
                 * relative to the first line of the function definition.
                 */
                const char *lines = query_buf->data;
 
                while (*lines != '\0')
                {
                    if (strncmp(lines, "AS ", 3) == 0 ||
                        strncmp(lines, "BEGIN ", 6) == 0 ||
                        strncmp(lines, "RETURN ", 7) == 0)
                        break;
                    lineno++;
                    /* find start of next line */
                    lines = strchr(lines, '\n');
                    if (!lines)
                        break;
                    lines++;
                }
            }
        }
 
        if (status != PSQL_CMD_ERROR)
        {
            bool        edited = false;
 
            if (!do_edit(NULL, query_buf, lineno, true, &edited))
                status = PSQL_CMD_ERROR;
            else if (!edited)
                puts(_("No changes"));
            else
                status = PSQL_CMD_NEWEDIT;
        }
 
        /*
         * On error while doing object lookup or while editing, or if
         * specifying an incorrect line number, reset the query buffer.
         */
        if (status == PSQL_CMD_ERROR)
            resetPQExpBuffer(query_buf);
 
        free(obj_desc);
    }
    else
        ignore_slash_whole_line(scan_state);
 
    return status;
}

References _, appendPQExpBufferStr(), PQExpBufferData::data, do_edit(), EditableFunction, EditableView, free, get_create_object_cmd(), ignore_slash_whole_line(), InvalidOid, lookup_object_oid(), OT_WHOLE_LINE, pg_log_error, PSQL_CMD_ERROR, PSQL_CMD_NEWEDIT, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), resetPQExpBuffer(), and strip_lineno_from_objdesc().

Referenced by exec_command().

exec_command_elif()

static backslashResult exec_command_elif ( PsqlScanState  scan_state, ConditionalStack  cstack, PQExpBuffer  query_buf  )

static

Definition at line 2126 of file command.c.

{
    bool        success = true;
 
    switch (conditional_stack_peek(cstack))
    {
        case IFSTATE_TRUE:
 
            /*
             * Just finished active branch of this \if block.  Update saved
             * state so we will keep whatever data was put in query_buf by the
             * active branch.
             */
            save_query_text_state(scan_state, cstack, query_buf);
 
            /*
             * Discard \elif expression and ignore the rest until \endif.
             * Switch state before reading expression to ensure proper lexer
             * behavior.
             */
            conditional_stack_poke(cstack, IFSTATE_IGNORED);
            ignore_boolean_expression(scan_state);
            break;
        case IFSTATE_FALSE:
 
            /*
             * Discard any query text added by the just-skipped branch.
             */
            discard_query_text(scan_state, cstack, query_buf);
 
            /*
             * Have not yet found a true expression in this \if block, so this
             * might be the first.  We have to change state before examining
             * the expression, or the lexer won't do the right thing.
             */
            conditional_stack_poke(cstack, IFSTATE_TRUE);
            if (!is_true_boolean_expression(scan_state, "\\elif expression"))
                conditional_stack_poke(cstack, IFSTATE_FALSE);
            break;
        case IFSTATE_IGNORED:
 
            /*
             * Discard any query text added by the just-skipped branch.
             */
            discard_query_text(scan_state, cstack, query_buf);
 
            /*
             * Skip expression and move on.  Either the \if block already had
             * an active section, or whole block is being skipped.
             */
            ignore_boolean_expression(scan_state);
            break;
        case IFSTATE_ELSE_TRUE:
        case IFSTATE_ELSE_FALSE:
            pg_log_error("\\elif: cannot occur after \\else");
            success = false;
            break;
        case IFSTATE_NONE:
            /* no \if to elif from */
            pg_log_error("\\elif: no matching \\if");
            success = false;
            break;
    }
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References conditional_stack_peek(), conditional_stack_poke(), discard_query_text(), IFSTATE_ELSE_FALSE, IFSTATE_ELSE_TRUE, IFSTATE_FALSE, IFSTATE_IGNORED, IFSTATE_NONE, IFSTATE_TRUE, ignore_boolean_expression(), is_true_boolean_expression(), pg_log_error, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, save_query_text_state(), and success.

Referenced by exec_command().

exec_command_else()

static backslashResult exec_command_else ( PsqlScanState  scan_state, ConditionalStack  cstack, PQExpBuffer  query_buf  )

static

Definition at line 2202 of file command.c.

{
    bool        success = true;
 
    switch (conditional_stack_peek(cstack))
    {
        case IFSTATE_TRUE:
 
            /*
             * Just finished active branch of this \if block.  Update saved
             * state so we will keep whatever data was put in query_buf by the
             * active branch.
             */
            save_query_text_state(scan_state, cstack, query_buf);
 
            /* Now skip the \else branch */
            conditional_stack_poke(cstack, IFSTATE_ELSE_FALSE);
            break;
        case IFSTATE_FALSE:
 
            /*
             * Discard any query text added by the just-skipped branch.
             */
            discard_query_text(scan_state, cstack, query_buf);
 
            /*
             * We've not found any true \if or \elif expression, so execute
             * the \else branch.
             */
            conditional_stack_poke(cstack, IFSTATE_ELSE_TRUE);
            break;
        case IFSTATE_IGNORED:
 
            /*
             * Discard any query text added by the just-skipped branch.
             */
            discard_query_text(scan_state, cstack, query_buf);
 
            /*
             * Either we previously processed the active branch of this \if,
             * or the whole \if block is being skipped.  Either way, skip the
             * \else branch.
             */
            conditional_stack_poke(cstack, IFSTATE_ELSE_FALSE);
            break;
        case IFSTATE_ELSE_TRUE:
        case IFSTATE_ELSE_FALSE:
            pg_log_error("\\else: cannot occur after \\else");
            success = false;
            break;
        case IFSTATE_NONE:
            /* no \if to else from */
            pg_log_error("\\else: no matching \\if");
            success = false;
            break;
    }
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References conditional_stack_peek(), conditional_stack_poke(), discard_query_text(), IFSTATE_ELSE_FALSE, IFSTATE_ELSE_TRUE, IFSTATE_FALSE, IFSTATE_IGNORED, IFSTATE_NONE, IFSTATE_TRUE, pg_log_error, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, save_query_text_state(), and success.

Referenced by exec_command().

exec_command_encoding()

static backslashResult exec_command_encoding ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1580 of file command.c.

{
    if (active_branch)
    {
        char       *encoding = psql_scan_slash_option(scan_state,
                                                      OT_NORMAL, NULL, false);
 
        if (!encoding)
        {
            /* show encoding */
            puts(pg_encoding_to_char(pset.encoding));
        }
        else
        {
            /* set encoding */
            if (PQsetClientEncoding(pset.db, encoding) == -1)
                pg_log_error("%s: invalid encoding name or conversion procedure not found", encoding);
            else
            {
                /* save encoding info into psql internal data */
                pset.encoding = PQclientEncoding(pset.db);
                pset.popt.topt.encoding = pset.encoding;
                setFmtEncoding(pset.encoding);
                SetVariable(pset.vars, "ENCODING",
                            pg_encoding_to_char(pset.encoding));
            }
            free(encoding);
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return PSQL_CMD_SKIP_LINE;
}

References _psqlSettings::db, _psqlSettings::encoding, encoding, printTableOpt::encoding, free, ignore_slash_options(), OT_NORMAL, pg_encoding_to_char, pg_log_error, _psqlSettings::popt, PQclientEncoding(), PQsetClientEncoding(), pset, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), setFmtEncoding(), SetVariable(), printQueryOpt::topt, and _psqlSettings::vars.

Referenced by exec_command().

exec_command_endif()

static backslashResult exec_command_endif ( PsqlScanState  scan_state, ConditionalStack  cstack, PQExpBuffer  query_buf  )

static

Definition at line 2267 of file command.c.

{
    bool        success = true;
 
    switch (conditional_stack_peek(cstack))
    {
        case IFSTATE_TRUE:
        case IFSTATE_ELSE_TRUE:
            /* Close the \if block, keeping the query text */
            success = conditional_stack_pop(cstack);
            Assert(success);
            break;
        case IFSTATE_FALSE:
        case IFSTATE_IGNORED:
        case IFSTATE_ELSE_FALSE:
 
            /*
             * Discard any query text added by the just-skipped branch.
             */
            discard_query_text(scan_state, cstack, query_buf);
 
            /* Close the \if block */
            success = conditional_stack_pop(cstack);
            Assert(success);
            break;
        case IFSTATE_NONE:
            /* no \if to end */
            pg_log_error("\\endif: no matching \\if");
            success = false;
            break;
    }
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References Assert(), conditional_stack_peek(), conditional_stack_pop(), discard_query_text(), IFSTATE_ELSE_FALSE, IFSTATE_ELSE_TRUE, IFSTATE_FALSE, IFSTATE_IGNORED, IFSTATE_NONE, IFSTATE_TRUE, pg_log_error, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, and success.

Referenced by exec_command().

exec_command_endpipeline()

static backslashResult exec_command_endpipeline ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3044 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        pset.send_mode = PSQL_SEND_END_PIPELINE_MODE;
        status = PSQL_CMD_SEND;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References ignore_slash_options(), pset, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, PSQL_SEND_END_PIPELINE_MODE, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_errverbose()

static backslashResult exec_command_errverbose ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1619 of file command.c.

{
    if (active_branch)
    {
        if (pset.last_error_result)
        {
            char       *msg;
 
            msg = PQresultVerboseErrorMessage(pset.last_error_result,
                                              PQERRORS_VERBOSE,
                                              PQSHOW_CONTEXT_ALWAYS);
            if (msg)
            {
                pg_log_error("%s", msg);
                PQfreemem(msg);
            }
            else
                puts(_("out of memory"));
        }
        else
            puts(_("There is no previous error."));
    }
 
    return PSQL_CMD_SKIP_LINE;
}

References _, _psqlSettings::last_error_result, pg_log_error, PQERRORS_VERBOSE, PQfreemem(), PQresultVerboseErrorMessage(), PQSHOW_CONTEXT_ALWAYS, pset, and PSQL_CMD_SKIP_LINE.

Referenced by exec_command().

exec_command_f()

static backslashResult exec_command_f ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1649 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *fname = psql_scan_slash_option(scan_state,
                                                   OT_NORMAL, NULL, false);
 
        success = do_pset("fieldsep", fname, &pset.popt, pset.quiet);
        free(fname);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), free, ignore_slash_options(), OT_NORMAL, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, and success.

Referenced by exec_command().

exec_command_flush()

static backslashResult exec_command_flush ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1671 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        pset.send_mode = PSQL_SEND_FLUSH;
        status = PSQL_CMD_SEND;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References ignore_slash_options(), pset, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, PSQL_SEND_FLUSH, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_flushrequest()

static backslashResult exec_command_flushrequest ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1690 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        pset.send_mode = PSQL_SEND_FLUSH_REQUEST;
        status = PSQL_CMD_SEND;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References ignore_slash_options(), pset, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, PSQL_SEND_FLUSH_REQUEST, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_g()

static backslashResult exec_command_g ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 1715 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
    char       *fname;
 
    /*
     * Because the option processing for this is fairly complicated, we do it
     * and then decide whether the branch is active.
     */
    fname = psql_scan_slash_option(scan_state,
                                   OT_FILEPIPE, NULL, false);
 
    if (fname && fname[0] == '(')
    {
        /* Consume pset options through trailing ')' ... */
        status = process_command_g_options(fname + 1, scan_state,
                                           active_branch, cmd);
        free(fname);
        /* ... and again attempt to scan the filename. */
        fname = psql_scan_slash_option(scan_state,
                                       OT_FILEPIPE, NULL, false);
    }
 
    if (status == PSQL_CMD_SKIP_LINE && active_branch)
    {
        if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
        {
            pg_log_error("\\%s not allowed in pipeline mode", cmd);
            clean_extended_state();
            free(fname);
            return PSQL_CMD_ERROR;
        }
 
        if (!fname)
            pset.gfname = NULL;
        else
        {
            expand_tilde(&fname);
            pset.gfname = pg_strdup(fname);
        }
        if (strcmp(cmd, "gx") == 0)
        {
            /* save settings if not done already, then force expanded=on */
            if (pset.gsavepopt == NULL)
                pset.gsavepopt = savePsetInfo(&pset.popt);
            pset.popt.topt.expanded = 1;
        }
        status = PSQL_CMD_SEND;
    }
 
    free(fname);
 
    return status;
}

References clean_extended_state(), _psqlSettings::db, expand_tilde(), printTableOpt::expanded, free, _psqlSettings::gfname, _psqlSettings::gsavepopt, OT_FILEPIPE, pg_log_error, pg_strdup(), _psqlSettings::popt, PQ_PIPELINE_OFF, PQpipelineStatus(), process_command_g_options(), pset, PSQL_CMD_ERROR, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), savePsetInfo(), and printQueryOpt::topt.

Referenced by exec_command().

exec_command_gdesc()

static backslashResult exec_command_gdesc ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1851 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        pset.gdesc_flag = true;
        status = PSQL_CMD_SEND;
    }
 
    return status;
}

References _psqlSettings::gdesc_flag, pset, PSQL_CMD_SEND, and PSQL_CMD_SKIP_LINE.

Referenced by exec_command().

exec_command_getenv()

static backslashResult exec_command_getenv ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 1868 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *myvar = psql_scan_slash_option(scan_state,
                                                   OT_NORMAL, NULL, false);
        char       *envvar = psql_scan_slash_option(scan_state,
                                                    OT_NORMAL, NULL, false);
 
        if (!myvar || !envvar)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            success = false;
        }
        else
        {
            char       *envval = getenv(envvar);
 
            if (envval && !SetVariable(pset.vars, myvar, envval))
                success = false;
        }
        free(myvar);
        free(envvar);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References free, ignore_slash_options(), OT_NORMAL, pg_log_error, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), SetVariable(), success, and _psqlSettings::vars.

Referenced by exec_command().

exec_command_getresults()

static backslashResult exec_command_getresults ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1905 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *opt;
        int         num_results;
 
        pset.send_mode = PSQL_SEND_GET_RESULTS;
        status = PSQL_CMD_SEND;
        opt = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false);
 
        pset.requested_results = 0;
        if (opt != NULL)
        {
            num_results = atoi(opt);
            if (num_results < 0)
            {
                pg_log_error("\\getresults: invalid number of requested results");
                return PSQL_CMD_SKIP_LINE;
            }
            pset.requested_results = num_results;
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References ignore_slash_options(), OT_NORMAL, pg_log_error, pset, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), PSQL_SEND_GET_RESULTS, _psqlSettings::requested_results, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_gexec()

static backslashResult exec_command_gexec ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1941 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
        {
            pg_log_error("\\gexec not allowed in pipeline mode");
            clean_extended_state();
            return PSQL_CMD_ERROR;
        }
        pset.gexec_flag = true;
        status = PSQL_CMD_SEND;
    }
 
    return status;
}

References clean_extended_state(), _psqlSettings::db, _psqlSettings::gexec_flag, pg_log_error, PQ_PIPELINE_OFF, PQpipelineStatus(), pset, PSQL_CMD_ERROR, PSQL_CMD_SEND, and PSQL_CMD_SKIP_LINE.

Referenced by exec_command().

exec_command_gset()

static backslashResult exec_command_gset ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1964 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *prefix = psql_scan_slash_option(scan_state,
                                                    OT_NORMAL, NULL, false);
 
        if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
        {
            pg_log_error("\\gset not allowed in pipeline mode");
            clean_extended_state();
            return PSQL_CMD_ERROR;
        }
 
        if (prefix)
            pset.gset_prefix = prefix;
        else
        {
            /* we must set a non-NULL prefix to trigger storing */
            pset.gset_prefix = pg_strdup("");
        }
        /* gset_prefix is freed later */
        status = PSQL_CMD_SEND;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References clean_extended_state(), _psqlSettings::db, _psqlSettings::gset_prefix, ignore_slash_options(), OT_NORMAL, pg_log_error, pg_strdup(), PQ_PIPELINE_OFF, PQpipelineStatus(), pset, PSQL_CMD_ERROR, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, and psql_scan_slash_option().

Referenced by exec_command().

exec_command_help()

static backslashResult exec_command_help ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2000 of file command.c.

{
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_WHOLE_LINE, NULL, true);
 
        helpSQL(opt, pset.popt.topt.pager);
        free(opt);
    }
    else
        ignore_slash_whole_line(scan_state);
 
    return PSQL_CMD_SKIP_LINE;
}

References free, helpSQL(), ignore_slash_whole_line(), OT_WHOLE_LINE, printTableOpt::pager, _psqlSettings::popt, pset, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), and printQueryOpt::topt.

Referenced by exec_command().

exec_command_html()

static backslashResult exec_command_html ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2020 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        if (pset.popt.topt.format != PRINT_HTML)
            success = do_pset("format", "html", &pset.popt, pset.quiet);
        else
            success = do_pset("format", "aligned", &pset.popt, pset.quiet);
    }
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), printTableOpt::format, _psqlSettings::popt, PRINT_HTML, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, _psqlSettings::quiet, success, and printQueryOpt::topt.

Referenced by exec_command().

exec_command_if()

static backslashResult exec_command_if ( PsqlScanState  scan_state, ConditionalStack  cstack, PQExpBuffer  query_buf  )

static

Definition at line 2080 of file command.c.

{
    if (conditional_active(cstack))
    {
        /*
         * First, push a new active stack entry; this ensures that the lexer
         * will perform variable substitution and backtick evaluation while
         * scanning the expression.  (That should happen anyway, since we know
         * we're in an active outer branch, but let's be sure.)
         */
        conditional_stack_push(cstack, IFSTATE_TRUE);
 
        /* Remember current query state in case we need to restore later */
        save_query_text_state(scan_state, cstack, query_buf);
 
        /*
         * Evaluate the expression; if it's false, change to inactive state.
         */
        if (!is_true_boolean_expression(scan_state, "\\if expression"))
            conditional_stack_poke(cstack, IFSTATE_FALSE);
    }
    else
    {
        /*
         * We're within an inactive outer branch, so this entire \if block
         * will be ignored.  We don't want to evaluate the expression, so push
         * the "ignored" stack state before scanning it.
         */
        conditional_stack_push(cstack, IFSTATE_IGNORED);
 
        /* Remember current query state in case we need to restore later */
        save_query_text_state(scan_state, cstack, query_buf);
 
        ignore_boolean_expression(scan_state);
    }
 
    return PSQL_CMD_SKIP_LINE;
}

References conditional_active(), conditional_stack_poke(), conditional_stack_push(), IFSTATE_FALSE, IFSTATE_IGNORED, IFSTATE_TRUE, ignore_boolean_expression(), is_true_boolean_expression(), PSQL_CMD_SKIP_LINE, and save_query_text_state().

Referenced by exec_command().

exec_command_include()

static backslashResult exec_command_include ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 2039 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *fname = psql_scan_slash_option(scan_state,
                                                   OT_NORMAL, NULL, true);
 
        if (!fname)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            success = false;
        }
        else
        {
            bool        include_relative;
 
            include_relative = (strcmp(cmd, "ir") == 0
                                || strcmp(cmd, "include_relative") == 0);
            expand_tilde(&fname);
            success = (process_file(fname, include_relative) == EXIT_SUCCESS);
            free(fname);
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References EXIT_SUCCESS, expand_tilde(), free, ignore_slash_options(), OT_NORMAL, pg_log_error, process_file(), PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), and success.

Referenced by exec_command().

exec_command_list()

static backslashResult exec_command_list ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 2307 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *pattern;
        bool        show_verbose;
        unsigned short int save_expanded;
 
        pattern = psql_scan_slash_option(scan_state,
                                         OT_NORMAL, NULL, true);
 
        show_verbose = strchr(cmd, '+') ? true : false;
 
        /* if 'x' option specified, force expanded mode */
        save_expanded = pset.popt.topt.expanded;
        if (strchr(cmd, 'x'))
            pset.popt.topt.expanded = 1;
 
        success = listAllDbs(pattern, show_verbose);
 
        /* restore original expanded mode */
        pset.popt.topt.expanded = save_expanded;
 
        free(pattern);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References printTableOpt::expanded, free, ignore_slash_options(), listAllDbs(), OT_NORMAL, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), success, printQueryOpt::topt, and true.

Referenced by exec_command().

exec_command_lo()

static backslashResult exec_command_lo ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 2344 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt1,
                   *opt2;
 
        opt1 = psql_scan_slash_option(scan_state,
                                      OT_NORMAL, NULL, true);
        opt2 = psql_scan_slash_option(scan_state,
                                      OT_NORMAL, NULL, true);
 
        if (strcmp(cmd + 3, "export") == 0)
        {
            if (!opt2)
            {
                pg_log_error("\\%s: missing required argument", cmd);
                success = false;
            }
            else
            {
                expand_tilde(&opt2);
                success = do_lo_export(opt1, opt2);
            }
        }
 
        else if (strcmp(cmd + 3, "import") == 0)
        {
            if (!opt1)
            {
                pg_log_error("\\%s: missing required argument", cmd);
                success = false;
            }
            else
            {
                expand_tilde(&opt1);
                success = do_lo_import(opt1, opt2);
            }
        }
 
        else if (strncmp(cmd + 3, "list", 4) == 0)
        {
            bool        show_verbose;
            unsigned short int save_expanded;
 
            show_verbose = strchr(cmd, '+') ? true : false;
 
            /* if 'x' option specified, force expanded mode */
            save_expanded = pset.popt.topt.expanded;
            if (strchr(cmd, 'x'))
                pset.popt.topt.expanded = 1;
 
            success = listLargeObjects(show_verbose);
 
            /* restore original expanded mode */
            pset.popt.topt.expanded = save_expanded;
        }
 
        else if (strcmp(cmd + 3, "unlink") == 0)
        {
            if (!opt1)
            {
                pg_log_error("\\%s: missing required argument", cmd);
                success = false;
            }
            else
                success = do_lo_unlink(opt1);
        }
 
        else
            status = PSQL_CMD_UNKNOWN;
 
        free(opt1);
        free(opt2);
    }
    else
        ignore_slash_options(scan_state);
 
    if (!success)
        status = PSQL_CMD_ERROR;
 
    return status;
}

References do_lo_export(), do_lo_import(), do_lo_unlink(), expand_tilde(), printTableOpt::expanded, free, ignore_slash_options(), listLargeObjects(), OT_NORMAL, pg_log_error, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, PSQL_CMD_UNKNOWN, psql_scan_slash_option(), success, printQueryOpt::topt, and true.

Referenced by exec_command().

exec_command_out()

static backslashResult exec_command_out ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2435 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *fname = psql_scan_slash_option(scan_state,
                                                   OT_FILEPIPE, NULL, true);
 
        expand_tilde(&fname);
        success = setQFout(fname);
        free(fname);
    }
    else
        ignore_slash_filepipe(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References expand_tilde(), free, ignore_slash_filepipe(), OT_FILEPIPE, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), setQFout(), and success.

Referenced by exec_command().

exec_command_parse()

static backslashResult exec_command_parse ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 2484 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, false);
 
        clean_extended_state();
 
        if (!opt)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            status = PSQL_CMD_ERROR;
        }
        else
        {
            pset.stmtName = opt;
            pset.send_mode = PSQL_SEND_EXTENDED_PARSE;
            status = PSQL_CMD_SEND;
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References clean_extended_state(), ignore_slash_options(), OT_NORMAL, pg_log_error, pset, PSQL_CMD_ERROR, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), PSQL_SEND_EXTENDED_PARSE, _psqlSettings::send_mode, and _psqlSettings::stmtName.

Referenced by exec_command().

exec_command_password()

static backslashResult exec_command_password ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2518 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *user = psql_scan_slash_option(scan_state,
                                                  OT_SQLID, NULL, true);
        char       *pw1 = NULL;
        char       *pw2 = NULL;
        PQExpBufferData buf;
        PromptInterruptContext prompt_ctx;
 
        if (user == NULL)
        {
            /* By default, the command applies to CURRENT_USER */
            PGresult   *res;
 
            res = PSQLexec("SELECT CURRENT_USER");
            if (!res)
                return PSQL_CMD_ERROR;
 
            user = pg_strdup(PQgetvalue(res, 0, 0));
            PQclear(res);
        }
 
        /* Set up to let SIGINT cancel simple_prompt_extended() */
        prompt_ctx.jmpbuf = sigint_interrupt_jmp;
        prompt_ctx.enabled = &sigint_interrupt_enabled;
        prompt_ctx.canceled = false;
 
        initPQExpBuffer(&buf);
        printfPQExpBuffer(&buf, _("Enter new password for user \"%s\": "), user);
 
        pw1 = simple_prompt_extended(buf.data, false, &prompt_ctx);
        if (!prompt_ctx.canceled)
            pw2 = simple_prompt_extended("Enter it again: ", false, &prompt_ctx);
 
        if (prompt_ctx.canceled)
        {
            /* fail silently */
            success = false;
        }
        else if (strcmp(pw1, pw2) != 0)
        {
            pg_log_error("Passwords didn't match.");
            success = false;
        }
        else
        {
            PGresult   *res = PQchangePassword(pset.db, user, pw1);
 
            if (PQresultStatus(res) != PGRES_COMMAND_OK)
            {
                pg_log_info("%s", PQerrorMessage(pset.db));
                success = false;
            }
 
            PQclear(res);
        }
 
        free(user);
        free(pw1);
        free(pw2);
        termPQExpBuffer(&buf);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References _, buf, PromptInterruptContext::canceled, _psqlSettings::db, PromptInterruptContext::enabled, free, ignore_slash_options(), initPQExpBuffer(), PromptInterruptContext::jmpbuf, OT_SQLID, pg_log_error, pg_log_info, pg_strdup(), PGRES_COMMAND_OK, PQchangePassword(), PQclear(), PQerrorMessage(), PQgetvalue(), PQresultStatus(), printfPQExpBuffer(), pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), PSQLexec(), sigint_interrupt_enabled, sigint_interrupt_jmp, simple_prompt_extended(), success, termPQExpBuffer(), and user.

Referenced by exec_command().

exec_command_print()

static backslashResult exec_command_print ( PsqlScanState  scan_state, bool  active_branch, PQExpBuffer  query_buf, PQExpBuffer  previous_buf  )

static

Definition at line 2458 of file command.c.

{
    if (active_branch)
    {
        /*
         * We want to print the same thing \g would execute, but not to change
         * the query buffer state; so we can't use copy_previous_query().
         * Also, beware of possibility that buffer pointers are NULL.
         */
        if (query_buf && query_buf->len > 0)
            puts(query_buf->data);
        else if (previous_buf && previous_buf->len > 0)
            puts(previous_buf->data);
        else if (!pset.quiet)
            puts(_("Query buffer is empty."));
        fflush(stdout);
    }
 
    return PSQL_CMD_SKIP_LINE;
}

References _, PQExpBufferData::data, PQExpBufferData::len, pset, PSQL_CMD_SKIP_LINE, _psqlSettings::quiet, and generate_unaccent_rules::stdout.

Referenced by exec_command().

exec_command_prompt()

static backslashResult exec_command_prompt ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 2594 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt,
                   *prompt_text = NULL;
        char       *arg1,
                   *arg2;
 
        arg1 = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false);
        arg2 = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false);
 
        if (!arg1)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            success = false;
        }
        else
        {
            char       *result;
            PromptInterruptContext prompt_ctx;
 
            /* Set up to let SIGINT cancel simple_prompt_extended() */
            prompt_ctx.jmpbuf = sigint_interrupt_jmp;
            prompt_ctx.enabled = &sigint_interrupt_enabled;
            prompt_ctx.canceled = false;
 
            if (arg2)
            {
                prompt_text = arg1;
                opt = arg2;
            }
            else
                opt = arg1;
 
            if (!pset.inputfile)
            {
                result = simple_prompt_extended(prompt_text, true, &prompt_ctx);
            }
            else
            {
                if (prompt_text)
                {
                    fputs(prompt_text, stdout);
                    fflush(stdout);
                }
                result = gets_fromFile(stdin);
                if (!result)
                {
                    pg_log_error("\\%s: could not read value for variable",
                                 cmd);
                    success = false;
                }
            }
 
            if (prompt_ctx.canceled ||
                (result && !SetVariable(pset.vars, opt, result)))
                success = false;
 
            free(result);
            free(prompt_text);
            free(opt);
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References PromptInterruptContext::canceled, PromptInterruptContext::enabled, free, gets_fromFile(), ignore_slash_options(), _psqlSettings::inputfile, PromptInterruptContext::jmpbuf, OT_NORMAL, pg_log_error, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), SetVariable(), sigint_interrupt_enabled, sigint_interrupt_jmp, simple_prompt_extended(), generate_unaccent_rules::stdout, success, and _psqlSettings::vars.

Referenced by exec_command().

exec_command_pset()

static backslashResult exec_command_pset ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2671 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt0 = psql_scan_slash_option(scan_state,
                                                  OT_NORMAL, NULL, false);
        char       *opt1 = psql_scan_slash_option(scan_state,
                                                  OT_NORMAL, NULL, false);
 
        if (!opt0)
        {
            /* list all variables */
 
            int         i;
            static const char *const my_list[] = {
                "border", "columns", "csv_fieldsep", "expanded", "fieldsep",
                "fieldsep_zero", "footer", "format", "linestyle", "null",
                "numericlocale", "pager", "pager_min_lines",
                "recordsep", "recordsep_zero",
                "tableattr", "title", "tuples_only",
                "unicode_border_linestyle",
                "unicode_column_linestyle",
                "unicode_header_linestyle",
                "xheader_width",
                NULL
            };
 
            for (i = 0; my_list[i] != NULL; i++)
            {
                char       *val = pset_value_string(my_list[i], &pset.popt);
 
                printf("%-24s %s\n", my_list[i], val);
                free(val);
            }
 
            success = true;
        }
        else
            success = do_pset(opt0, opt1, &pset.popt, pset.quiet);
 
        free(opt0);
        free(opt1);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), free, i, ignore_slash_options(), OT_NORMAL, _psqlSettings::popt, printf, pset, pset_value_string(), PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, success, and val.

Referenced by exec_command().

exec_command_quit()

static backslashResult exec_command_quit ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2726 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
        status = PSQL_CMD_TERMINATE;
 
    return status;
}

References PSQL_CMD_SKIP_LINE, and PSQL_CMD_TERMINATE.

Referenced by exec_command().

exec_command_reset()

static backslashResult exec_command_reset ( PsqlScanState  scan_state, bool  active_branch, PQExpBuffer  query_buf  )

static

Definition at line 2740 of file command.c.

{
    if (active_branch)
    {
        resetPQExpBuffer(query_buf);
        psql_scan_reset(scan_state);
        if (!pset.quiet)
            puts(_("Query buffer reset (cleared)."));
    }
 
    return PSQL_CMD_SKIP_LINE;
}

References _, pset, PSQL_CMD_SKIP_LINE, psql_scan_reset(), _psqlSettings::quiet, and resetPQExpBuffer().

Referenced by exec_command().

exec_command_s()

static backslashResult exec_command_s ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2758 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *fname = psql_scan_slash_option(scan_state,
                                                   OT_NORMAL, NULL, true);
 
        expand_tilde(&fname);
        success = printHistory(fname, pset.popt.topt.pager);
        if (success && !pset.quiet && fname)
            printf(_("Wrote history to file \"%s\".\n"), fname);
        if (!fname)
            putchar('\n');
        free(fname);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References _, expand_tilde(), free, ignore_slash_options(), OT_NORMAL, printTableOpt::pager, _psqlSettings::popt, printf, printHistory(), pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, success, and printQueryOpt::topt.

Referenced by exec_command().

exec_command_sendpipeline()

static backslashResult exec_command_sendpipeline ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2785 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
        {
            if (pset.send_mode == PSQL_SEND_EXTENDED_QUERY_PREPARED ||
                pset.send_mode == PSQL_SEND_EXTENDED_QUERY_PARAMS)
            {
                status = PSQL_CMD_SEND;
            }
            else
            {
                pg_log_error("\\sendpipeline must be used after \\bind or \\bind_named");
                clean_extended_state();
                return PSQL_CMD_ERROR;
            }
        }
        else
        {
            pg_log_error("\\sendpipeline not allowed outside of pipeline mode");
            clean_extended_state();
            return PSQL_CMD_ERROR;
        }
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References clean_extended_state(), _psqlSettings::db, ignore_slash_options(), pg_log_error, PQ_PIPELINE_OFF, PQpipelineStatus(), pset, PSQL_CMD_ERROR, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, PSQL_SEND_EXTENDED_QUERY_PARAMS, PSQL_SEND_EXTENDED_QUERY_PREPARED, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_set()

static backslashResult exec_command_set ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2822 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt0 = psql_scan_slash_option(scan_state,
                                                  OT_NORMAL, NULL, false);
 
        if (!opt0)
        {
            /* list all variables */
            PrintVariables(pset.vars);
            success = true;
        }
        else
        {
            /*
             * Set variable to the concatenation of the arguments.
             */
            char       *newval;
            char       *opt;
 
            opt = psql_scan_slash_option(scan_state,
                                         OT_NORMAL, NULL, false);
            newval = pg_strdup(opt ? opt : "");
            free(opt);
 
            while ((opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, false)))
            {
                newval = pg_realloc(newval, strlen(newval) + strlen(opt) + 1);
                strcat(newval, opt);
                free(opt);
            }
 
            if (!SetVariable(pset.vars, opt0, newval))
                success = false;
 
            free(newval);
        }
        free(opt0);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References free, ignore_slash_options(), newval, OT_NORMAL, pg_realloc(), pg_strdup(), PrintVariables(), pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), SetVariable(), success, and _psqlSettings::vars.

Referenced by exec_command().

exec_command_setenv()

static backslashResult exec_command_setenv ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 2875 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *envvar = psql_scan_slash_option(scan_state,
                                                    OT_NORMAL, NULL, false);
        char       *envval = psql_scan_slash_option(scan_state,
                                                    OT_NORMAL, NULL, false);
 
        if (!envvar)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            success = false;
        }
        else if (strchr(envvar, '=') != NULL)
        {
            pg_log_error("\\%s: environment variable name must not contain \"=\"",
                         cmd);
            success = false;
        }
        else if (!envval)
        {
            /* No argument - unset the environment variable */
            unsetenv(envvar);
            success = true;
        }
        else
        {
            /* Set variable to the value of the next argument */
            setenv(envvar, envval, 1);
            success = true;
        }
        free(envvar);
        free(envval);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References free, ignore_slash_options(), OT_NORMAL, pg_log_error, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), setenv, success, and unsetenv.

Referenced by exec_command().

exec_command_sf_sv()

static backslashResult exec_command_sf_sv ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd, bool  is_func  )

static

Definition at line 2923 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        bool        show_linenumbers = (strchr(cmd, '+') != NULL);
        PQExpBuffer buf;
        char       *obj_desc;
        Oid         obj_oid = InvalidOid;
        EditableObjectType eot = is_func ? EditableFunction : EditableView;
 
        buf = createPQExpBuffer();
        obj_desc = psql_scan_slash_option(scan_state,
                                          OT_WHOLE_LINE, NULL, true);
        if (!obj_desc)
        {
            if (is_func)
                pg_log_error("function name is required");
            else
                pg_log_error("view name is required");
            status = PSQL_CMD_ERROR;
        }
        else if (!lookup_object_oid(eot, obj_desc, &obj_oid))
        {
            /* error already reported */
            status = PSQL_CMD_ERROR;
        }
        else if (!get_create_object_cmd(eot, obj_oid, buf))
        {
            /* error already reported */
            status = PSQL_CMD_ERROR;
        }
        else
        {
            FILE       *output;
            bool        is_pager;
 
            /* Select output stream: stdout, pager, or file */
            if (pset.queryFout == stdout)
            {
                /* count lines in function to see if pager is needed */
                int         lineno = count_lines_in_buf(buf);
 
                output = PageOutput(lineno, &(pset.popt.topt));
                is_pager = true;
            }
            else
            {
                /* use previously set output file, without pager */
                output = pset.queryFout;
                is_pager = false;
            }
 
            if (show_linenumbers)
            {
                /* add line numbers */
                print_with_linenumbers(output, buf->data, is_func);
            }
            else
            {
                /* just send the definition to output */
                fputs(buf->data, output);
            }
 
            if (is_pager)
                ClosePager(output);
        }
 
        free(obj_desc);
        destroyPQExpBuffer(buf);
    }
    else
        ignore_slash_whole_line(scan_state);
 
    return status;
}

References buf, ClosePager(), count_lines_in_buf(), createPQExpBuffer(), destroyPQExpBuffer(), EditableFunction, EditableView, free, get_create_object_cmd(), ignore_slash_whole_line(), InvalidOid, lookup_object_oid(), OT_WHOLE_LINE, output, PageOutput(), pg_log_error, _psqlSettings::popt, print_with_linenumbers(), pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::queryFout, generate_unaccent_rules::stdout, and printQueryOpt::topt.

Referenced by exec_command().

exec_command_shell_escape()

static backslashResult exec_command_shell_escape ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3486 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_WHOLE_LINE, NULL, false);
 
        success = do_shell(opt);
        free(opt);
    }
    else
        ignore_slash_whole_line(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_shell(), free, ignore_slash_whole_line(), OT_WHOLE_LINE, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), and success.

Referenced by exec_command().

exec_command_slash_command_help()

static backslashResult exec_command_slash_command_help ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3508 of file command.c.

{
    if (active_branch)
    {
        char       *opt0 = psql_scan_slash_option(scan_state,
                                                  OT_NORMAL, NULL, false);
 
        if (!opt0 || strcmp(opt0, "commands") == 0)
            slashUsage(pset.popt.topt.pager);
        else if (strcmp(opt0, "options") == 0)
            usage(pset.popt.topt.pager);
        else if (strcmp(opt0, "variables") == 0)
            helpVariables(pset.popt.topt.pager);
        else
            slashUsage(pset.popt.topt.pager);
 
        free(opt0);
    }
    else
        ignore_slash_options(scan_state);
 
    return PSQL_CMD_SKIP_LINE;
}

References free, helpVariables(), ignore_slash_options(), OT_NORMAL, printTableOpt::pager, _psqlSettings::popt, pset, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), slashUsage(), printQueryOpt::topt, and usage().

Referenced by exec_command().

exec_command_startpipeline()

static backslashResult exec_command_startpipeline ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3006 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        pset.send_mode = PSQL_SEND_START_PIPELINE_MODE;
        status = PSQL_CMD_SEND;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References ignore_slash_options(), pset, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, PSQL_SEND_START_PIPELINE_MODE, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_syncpipeline()

static backslashResult exec_command_syncpipeline ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3025 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        pset.send_mode = PSQL_SEND_PIPELINE_SYNC;
        status = PSQL_CMD_SEND;
    }
    else
        ignore_slash_options(scan_state);
 
    return status;
}

References ignore_slash_options(), pset, PSQL_CMD_SEND, PSQL_CMD_SKIP_LINE, PSQL_SEND_PIPELINE_SYNC, and _psqlSettings::send_mode.

Referenced by exec_command().

exec_command_t()

static backslashResult exec_command_t ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3063 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, true);
 
        success = do_pset("tuples_only", opt, &pset.popt, pset.quiet);
        free(opt);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), free, ignore_slash_options(), OT_NORMAL, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, and success.

Referenced by exec_command().

exec_command_T()

static backslashResult exec_command_T ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3085 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *value = psql_scan_slash_option(scan_state,
                                                   OT_NORMAL, NULL, false);
 
        success = do_pset("tableattr", value, &pset.popt, pset.quiet);
        free(value);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), free, ignore_slash_options(), OT_NORMAL, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, success, and value.

Referenced by exec_command().

exec_command_timing()

static backslashResult exec_command_timing ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3107 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, false);
 
        if (opt)
            success = ParseVariableBool(opt, "\\timing", &pset.timing);
        else
            pset.timing = !pset.timing;
        if (!pset.quiet)
        {
            if (pset.timing)
                puts(_("Timing is on."));
            else
                puts(_("Timing is off."));
        }
        free(opt);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References _, free, ignore_slash_options(), OT_NORMAL, ParseVariableBool(), pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, success, and _psqlSettings::timing.

Referenced by exec_command().

exec_command_unset()

static backslashResult exec_command_unset ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 3139 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, false);
 
        if (!opt)
        {
            pg_log_error("\\%s: missing required argument", cmd);
            success = false;
        }
        else if (!SetVariable(pset.vars, opt, NULL))
            success = false;
 
        free(opt);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References free, ignore_slash_options(), OT_NORMAL, pg_log_error, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), SetVariable(), success, and _psqlSettings::vars.

Referenced by exec_command().

exec_command_watch()

static backslashResult exec_command_watch ( PsqlScanState  scan_state, bool  active_branch, PQExpBuffer  query_buf, PQExpBuffer  previous_buf  )

static

Definition at line 3271 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        bool        have_sleep = false;
        bool        have_iter = false;
        bool        have_min_rows = false;
        double      sleep = pset.watch_interval;
        int         iter = 0;
        int         min_rows = 0;
 
        if (PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF)
        {
            pg_log_error("\\watch not allowed in pipeline mode");
            clean_extended_state();
            success = false;
        }
 
        /*
         * Parse arguments.  We allow either an unlabeled interval or
         * "name=value", where name is from the set ('i', 'interval', 'c',
         * 'count', 'm', 'min_rows').  The parsing of interval value should be
         * kept in sync with ParseVariableDouble which is used for setting the
         * default interval value.
         */
        while (success)
        {
            char       *opt = psql_scan_slash_option(scan_state,
                                                     OT_NORMAL, NULL, true);
            char       *valptr;
            char       *opt_end;
 
            if (!opt)
                break;          /* no more arguments */
 
            valptr = strchr(opt, '=');
            if (valptr)
            {
                /* Labeled argument */
                valptr++;
                if (strncmp("i=", opt, strlen("i=")) == 0 ||
                    strncmp("interval=", opt, strlen("interval=")) == 0)
                {
                    if (have_sleep)
                    {
                        pg_log_error("\\watch: interval value is specified more than once");
                        success = false;
                    }
                    else
                    {
                        have_sleep = true;
                        errno = 0;
                        sleep = strtod(valptr, &opt_end);
                        if (sleep < 0 || *opt_end || errno == ERANGE)
                        {
                            pg_log_error("\\watch: incorrect interval value \"%s\"", valptr);
                            success = false;
                        }
                    }
                }
                else if (strncmp("c=", opt, strlen("c=")) == 0 ||
                         strncmp("count=", opt, strlen("count=")) == 0)
                {
                    if (have_iter)
                    {
                        pg_log_error("\\watch: iteration count is specified more than once");
                        success = false;
                    }
                    else
                    {
                        have_iter = true;
                        errno = 0;
                        iter = strtoint(valptr, &opt_end, 10);
                        if (iter <= 0 || *opt_end || errno == ERANGE)
                        {
                            pg_log_error("\\watch: incorrect iteration count \"%s\"", valptr);
                            success = false;
                        }
                    }
                }
                else if (strncmp("m=", opt, strlen("m=")) == 0 ||
                         strncmp("min_rows=", opt, strlen("min_rows=")) == 0)
                {
                    if (have_min_rows)
                    {
                        pg_log_error("\\watch: minimum row count specified more than once");
                        success = false;
                    }
                    else
                    {
                        have_min_rows = true;
                        errno = 0;
                        min_rows = strtoint(valptr, &opt_end, 10);
                        if (min_rows <= 0 || *opt_end || errno == ERANGE)
                        {
                            pg_log_error("\\watch: incorrect minimum row count \"%s\"", valptr);
                            success = false;
                        }
                    }
                }
                else
                {
                    pg_log_error("\\watch: unrecognized parameter \"%s\"", opt);
                    success = false;
                }
            }
            else
            {
                /* Unlabeled argument: take it as interval */
                if (have_sleep)
                {
                    pg_log_error("\\watch: interval value is specified more than once");
                    success = false;
                }
                else
                {
                    have_sleep = true;
                    errno = 0;
                    sleep = strtod(opt, &opt_end);
                    if (sleep < 0 || *opt_end || errno == ERANGE)
                    {
                        pg_log_error("\\watch: incorrect interval value \"%s\"", opt);
                        success = false;
                    }
                }
            }
 
            free(opt);
        }
 
        /* If we parsed arguments successfully, do the command */
        if (success)
        {
            /* If query_buf is empty, recall and execute previous query */
            (void) copy_previous_query(query_buf, previous_buf);
 
            success = do_watch(query_buf, sleep, iter, min_rows);
        }
 
        /* Reset the query buffer as though for \r */
        resetPQExpBuffer(query_buf);
        psql_scan_reset(scan_state);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References clean_extended_state(), copy_previous_query(), _psqlSettings::db, do_watch(), free, ignore_slash_options(), OT_NORMAL, pg_log_error, PQ_PIPELINE_OFF, PQpipelineStatus(), pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_reset(), psql_scan_slash_option(), resetPQExpBuffer(), strtoint(), success, and _psqlSettings::watch_interval.

Referenced by exec_command().

exec_command_write()

static backslashResult exec_command_write ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd, PQExpBuffer  query_buf, PQExpBuffer  previous_buf  )

static

Definition at line 3169 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
 
    if (active_branch)
    {
        char       *fname = psql_scan_slash_option(scan_state,
                                                   OT_FILEPIPE, NULL, true);
        FILE       *fd = NULL;
        bool        is_pipe = false;
 
        if (!query_buf)
        {
            pg_log_error("no query buffer");
            status = PSQL_CMD_ERROR;
        }
        else
        {
            if (!fname)
            {
                pg_log_error("\\%s: missing required argument", cmd);
                status = PSQL_CMD_ERROR;
            }
            else
            {
                expand_tilde(&fname);
                if (fname[0] == '|')
                {
                    is_pipe = true;
                    fflush(NULL);
                    disable_sigpipe_trap();
                    fd = popen(&fname[1], "w");
                }
                else
                {
                    canonicalize_path_enc(fname, pset.encoding);
                    fd = fopen(fname, "w");
                }
                if (!fd)
                {
                    pg_log_error("%s: %m", fname);
                    status = PSQL_CMD_ERROR;
                }
            }
        }
 
        if (fd)
        {
            int         result;
 
            /*
             * We want to print the same thing \g would execute, but not to
             * change the query buffer state; so we can't use
             * copy_previous_query().  Also, beware of possibility that buffer
             * pointers are NULL.
             */
            if (query_buf && query_buf->len > 0)
                fprintf(fd, "%s\n", query_buf->data);
            else if (previous_buf && previous_buf->len > 0)
                fprintf(fd, "%s\n", previous_buf->data);
 
            if (is_pipe)
            {
                result = pclose(fd);
 
                if (result != 0)
                {
                    pg_log_error("%s: %s", fname, wait_result_to_str(result));
                    status = PSQL_CMD_ERROR;
                }
                SetShellResultVariables(result);
            }
            else
            {
                result = fclose(fd);
 
                if (result == EOF)
                {
                    pg_log_error("%s: %m", fname);
                    status = PSQL_CMD_ERROR;
                }
            }
        }
 
        if (is_pipe)
            restore_sigpipe_trap();
 
        free(fname);
    }
    else
        ignore_slash_filepipe(scan_state);
 
    return status;
}

References canonicalize_path_enc(), PQExpBufferData::data, disable_sigpipe_trap(), _psqlSettings::encoding, expand_tilde(), fd(), fprintf, free, ignore_slash_filepipe(), PQExpBufferData::len, OT_FILEPIPE, pg_log_error, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), restore_sigpipe_trap(), SetShellResultVariables(), and wait_result_to_str().

Referenced by exec_command().

exec_command_x()

static backslashResult exec_command_x ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 3427 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *opt = psql_scan_slash_option(scan_state,
                                                 OT_NORMAL, NULL, true);
 
        success = do_pset("expanded", opt, &pset.popt, pset.quiet);
        free(opt);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), free, ignore_slash_options(), OT_NORMAL, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), _psqlSettings::quiet, and success.

Referenced by exec_command().

exec_command_z()

static backslashResult exec_command_z ( PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 3449 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *pattern;
        bool        show_system;
        unsigned short int save_expanded;
 
        pattern = psql_scan_slash_option(scan_state,
                                         OT_NORMAL, NULL, true);
 
        show_system = strchr(cmd, 'S') ? true : false;
 
        /* if 'x' option specified, force expanded mode */
        save_expanded = pset.popt.topt.expanded;
        if (strchr(cmd, 'x'))
            pset.popt.topt.expanded = 1;
 
        success = permissionsList(pattern, show_system);
 
        /* restore original expanded mode */
        pset.popt.topt.expanded = save_expanded;
 
        free(pattern);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References printTableOpt::expanded, free, ignore_slash_options(), OT_NORMAL, permissionsList(), _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), success, printQueryOpt::topt, and true.

Referenced by exec_command().

gather_boolean_expression()

static PQExpBuffer gather_boolean_expression ( PsqlScanState  scan_state )

static

Definition at line 3579 of file command.c.

{
    PQExpBuffer exp_buf = createPQExpBuffer();
    int         num_options = 0;
    char       *value;
 
    /* collect all arguments for the conditional command into exp_buf */
    while ((value = psql_scan_slash_option(scan_state,
                                           OT_NORMAL, NULL, false)) != NULL)
    {
        /* add spaces between tokens */
        if (num_options > 0)
            appendPQExpBufferChar(exp_buf, ' ');
        appendPQExpBufferStr(exp_buf, value);
        num_options++;
        free(value);
    }
 
    return exp_buf;
}

References appendPQExpBufferChar(), appendPQExpBufferStr(), createPQExpBuffer(), free, OT_NORMAL, psql_scan_slash_option(), and value.

Referenced by ignore_boolean_expression(), and is_true_boolean_expression().

get_create_object_cmd()

static bool get_create_object_cmd ( EditableObjectType  obj_type, Oid  oid, PQExpBuffer  buf  )

static

Definition at line 6104 of file command.c.

{
    bool        result = true;
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
 
    switch (obj_type)
    {
        case EditableFunction:
            printfPQExpBuffer(query,
                              "SELECT pg_catalog.pg_get_functiondef(%u)",
                              oid);
            break;
 
        case EditableView:
 
            /*
             * pg_get_viewdef() just prints the query, so we must prepend
             * CREATE for ourselves.  We must fully qualify the view name to
             * ensure the right view gets replaced.  Also, check relation kind
             * to be sure it's a view.
             *
             * Starting with PG 9.4, views may have WITH [LOCAL|CASCADED]
             * CHECK OPTION.  These are not part of the view definition
             * returned by pg_get_viewdef() and so need to be retrieved
             * separately.  Materialized views (introduced in 9.3) may have
             * arbitrary storage parameter reloptions.
             */
            if (pset.sversion >= 90400)
            {
                printfPQExpBuffer(query,
                                  "SELECT nspname, relname, relkind, "
                                  "pg_catalog.pg_get_viewdef(c.oid, true), "
                                  "pg_catalog.array_remove(pg_catalog.array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
                                  "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
                                  "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption "
                                  "FROM pg_catalog.pg_class c "
                                  "LEFT JOIN pg_catalog.pg_namespace n "
                                  "ON c.relnamespace = n.oid WHERE c.oid = %u",
                                  oid);
            }
            else
            {
                printfPQExpBuffer(query,
                                  "SELECT nspname, relname, relkind, "
                                  "pg_catalog.pg_get_viewdef(c.oid, true), "
                                  "c.reloptions AS reloptions, "
                                  "NULL AS checkoption "
                                  "FROM pg_catalog.pg_class c "
                                  "LEFT JOIN pg_catalog.pg_namespace n "
                                  "ON c.relnamespace = n.oid WHERE c.oid = %u",
                                  oid);
            }
            break;
    }
 
    if (!echo_hidden_command(query->data))
    {
        destroyPQExpBuffer(query);
        return false;
    }
    res = PQexec(pset.db, query->data);
    if (PQresultStatus(res) == PGRES_TUPLES_OK && PQntuples(res) == 1)
    {
        resetPQExpBuffer(buf);
        switch (obj_type)
        {
            case EditableFunction:
                appendPQExpBufferStr(buf, PQgetvalue(res, 0, 0));
                break;
 
            case EditableView:
                {
                    char       *nspname = PQgetvalue(res, 0, 0);
                    char       *relname = PQgetvalue(res, 0, 1);
                    char       *relkind = PQgetvalue(res, 0, 2);
                    char       *viewdef = PQgetvalue(res, 0, 3);
                    char       *reloptions = PQgetvalue(res, 0, 4);
                    char       *checkoption = PQgetvalue(res, 0, 5);
 
                    /*
                     * If the backend ever supports CREATE OR REPLACE
                     * MATERIALIZED VIEW, allow that here; but as of today it
                     * does not, so editing a matview definition in this way
                     * is impossible.
                     */
                    switch (relkind[0])
                    {
#ifdef NOT_USED
                        case RELKIND_MATVIEW:
                            appendPQExpBufferStr(buf, "CREATE OR REPLACE MATERIALIZED VIEW ");
                            break;
#endif
                        case RELKIND_VIEW:
                            appendPQExpBufferStr(buf, "CREATE OR REPLACE VIEW ");
                            break;
                        default:
                            pg_log_error("\"%s.%s\" is not a view",
                                         nspname, relname);
                            result = false;
                            break;
                    }
                    appendPQExpBuffer(buf, "%s.", fmtId(nspname));
                    appendPQExpBufferStr(buf, fmtId(relname));
 
                    /* reloptions, if not an empty array "{}" */
                    if (reloptions != NULL && strlen(reloptions) > 2)
                    {
                        appendPQExpBufferStr(buf, "\n WITH (");
                        if (!appendReloptionsArray(buf, reloptions, "",
                                                   pset.encoding,
                                                   standard_strings()))
                        {
                            pg_log_error("could not parse reloptions array");
                            result = false;
                        }
                        appendPQExpBufferChar(buf, ')');
                    }
 
                    /* View definition from pg_get_viewdef (a SELECT query) */
                    appendPQExpBuffer(buf, " AS\n%s", viewdef);
 
                    /* Get rid of the semicolon that pg_get_viewdef appends */
                    if (buf->len > 0 && buf->data[buf->len - 1] == ';')
                        buf->data[--(buf->len)] = '\0';
 
                    /* WITH [LOCAL|CASCADED] CHECK OPTION */
                    if (checkoption && checkoption[0] != '\0')
                        appendPQExpBuffer(buf, "\n WITH %s CHECK OPTION",
                                          checkoption);
                }
                break;
        }
        /* Make sure result ends with a newline */
        if (buf->len > 0 && buf->data[buf->len - 1] != '\n')
            appendPQExpBufferChar(buf, '\n');
    }
    else
    {
        minimal_error_message(res);
        result = false;
    }
 
    PQclear(res);
    destroyPQExpBuffer(query);
 
    return result;
}

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendReloptionsArray(), buf, createPQExpBuffer(), PQExpBufferData::data, _psqlSettings::db, destroyPQExpBuffer(), echo_hidden_command(), EditableFunction, EditableView, _psqlSettings::encoding, fmtId(), minimal_error_message(), pg_log_error, PGRES_TUPLES_OK, PQclear(), PQexec(), PQgetvalue(), PQntuples(), PQresultStatus(), printfPQExpBuffer(), pset, relname, resetPQExpBuffer(), standard_strings(), and _psqlSettings::sversion.

Referenced by exec_command_ef_ev(), and exec_command_sf_sv().

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().

ignore_boolean_expression()

static void ignore_boolean_expression ( PsqlScanState  scan_state )

static

Definition at line 3626 of file command.c.

{
    PQExpBuffer buf = gather_boolean_expression(scan_state);
 
    destroyPQExpBuffer(buf);
}

References buf, destroyPQExpBuffer(), and gather_boolean_expression().

Referenced by exec_command_elif(), and exec_command_if().

ignore_slash_filepipe()

static void ignore_slash_filepipe ( PsqlScanState  scan_state )

static

Definition at line 3659 of file command.c.

{
    char       *arg = psql_scan_slash_option(scan_state,
                                             OT_FILEPIPE, NULL, false);
 
    free(arg);
}

References arg, free, OT_FILEPIPE, and psql_scan_slash_option().

Referenced by exec_command_out(), and exec_command_write().

ignore_slash_options()

static void ignore_slash_options ( PsqlScanState  scan_state )

static

Definition at line 3642 of file command.c.

{
    char       *arg;
 
    while ((arg = psql_scan_slash_option(scan_state,
                                         OT_NORMAL, NULL, false)) != NULL)
        free(arg);
}

References arg, free, OT_NORMAL, and psql_scan_slash_option().

Referenced by exec_command_bind(), exec_command_bind_named(), exec_command_C(), exec_command_cd(), exec_command_close(), exec_command_connect(), exec_command_crosstabview(), exec_command_d(), exec_command_echo(), exec_command_edit(), exec_command_encoding(), exec_command_endpipeline(), exec_command_f(), exec_command_flush(), exec_command_flushrequest(), exec_command_getenv(), exec_command_getresults(), exec_command_gset(), exec_command_include(), exec_command_list(), exec_command_lo(), exec_command_parse(), exec_command_password(), exec_command_prompt(), exec_command_pset(), exec_command_s(), exec_command_sendpipeline(), exec_command_set(), exec_command_setenv(), exec_command_slash_command_help(), exec_command_startpipeline(), exec_command_syncpipeline(), exec_command_t(), exec_command_T(), exec_command_timing(), exec_command_unset(), exec_command_watch(), exec_command_x(), and exec_command_z().

ignore_slash_whole_line()

static void ignore_slash_whole_line ( PsqlScanState  scan_state )

static

Definition at line 3679 of file command.c.

{
    char       *arg = psql_scan_slash_option(scan_state,
                                             OT_WHOLE_LINE, NULL, false);
 
    free(arg);
}

References arg, free, OT_WHOLE_LINE, and psql_scan_slash_option().

Referenced by exec_command_copy(), exec_command_ef_ev(), exec_command_help(), exec_command_sf_sv(), and exec_command_shell_escape().

is_branching_command()

static bool is_branching_command ( const char *  cmd )

static

Definition at line 3691 of file command.c.

{
    return (strcmp(cmd, "if") == 0 ||
            strcmp(cmd, "elif") == 0 ||
            strcmp(cmd, "else") == 0 ||
            strcmp(cmd, "endif") == 0);
}

Referenced by exec_command().

is_true_boolean_expression()

static bool is_true_boolean_expression ( PsqlScanState  scan_state, const char *  name  )

static

Definition at line 3609 of file command.c.

{
    PQExpBuffer buf = gather_boolean_expression(scan_state);
    bool        value = false;
    bool        success = ParseVariableBool(buf->data, name, &value);
 
    destroyPQExpBuffer(buf);
    return success && value;
}

References buf, destroyPQExpBuffer(), gather_boolean_expression(), name, ParseVariableBool(), success, and value.

Referenced by exec_command_elif(), and exec_command_if().

lookup_object_oid()

static bool lookup_object_oid ( EditableObjectType  obj_type, const char *  desc, Oid *  obj_oid  )

static

Definition at line 6044 of file command.c.

{
    bool        result = true;
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
 
    switch (obj_type)
    {
        case EditableFunction:
 
            /*
             * We have a function description, e.g. "x" or "x(int)".  Issue a
             * query to retrieve the function's OID using a cast to regproc or
             * regprocedure (as appropriate).
             */
            appendPQExpBufferStr(query, "SELECT ");
            appendStringLiteralConn(query, desc, pset.db);
            appendPQExpBuffer(query, "::pg_catalog.%s::pg_catalog.oid",
                              strchr(desc, '(') ? "regprocedure" : "regproc");
            break;
 
        case EditableView:
 
            /*
             * Convert view name (possibly schema-qualified) to OID.  Note:
             * this code doesn't check if the relation is actually a view.
             * We'll detect that in get_create_object_cmd().
             */
            appendPQExpBufferStr(query, "SELECT ");
            appendStringLiteralConn(query, desc, pset.db);
            appendPQExpBufferStr(query, "::pg_catalog.regclass::pg_catalog.oid");
            break;
    }
 
    if (!echo_hidden_command(query->data))
    {
        destroyPQExpBuffer(query);
        return false;
    }
    res = PQexec(pset.db, query->data);
    if (PQresultStatus(res) == PGRES_TUPLES_OK && PQntuples(res) == 1)
        *obj_oid = atooid(PQgetvalue(res, 0, 0));
    else
    {
        minimal_error_message(res);
        result = false;
    }
 
    PQclear(res);
    destroyPQExpBuffer(query);
 
    return result;
}

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralConn(), atooid, createPQExpBuffer(), PQExpBufferData::data, _psqlSettings::db, destroyPQExpBuffer(), echo_hidden_command(), EditableFunction, EditableView, minimal_error_message(), PGRES_TUPLES_OK, PQclear(), PQexec(), PQgetvalue(), PQntuples(), PQresultStatus(), and pset.

Referenced by exec_command_ef_ev(), and exec_command_sf_sv().

minimal_error_message()

static void minimal_error_message ( PGresult *  res )

static

Definition at line 6394 of file command.c.

{
    PQExpBuffer msg;
    const char *fld;
 
    msg = createPQExpBuffer();
 
    fld = PQresultErrorField(res, PG_DIAG_SEVERITY);
    if (fld)
        printfPQExpBuffer(msg, "%s:  ", fld);
    else
        printfPQExpBuffer(msg, "ERROR:  ");
    fld = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
    if (fld)
        appendPQExpBufferStr(msg, fld);
    else
        appendPQExpBufferStr(msg, "(not available)");
    appendPQExpBufferChar(msg, '\n');
 
    pg_log_error("%s", msg->data);
 
    destroyPQExpBuffer(msg);
}

References appendPQExpBufferChar(), appendPQExpBufferStr(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), PG_DIAG_MESSAGE_PRIMARY, PG_DIAG_SEVERITY, pg_log_error, PQresultErrorField(), and printfPQExpBuffer().

Referenced by get_create_object_cmd(), and lookup_object_oid().

param_is_newly_set()

static bool param_is_newly_set ( const char *  old_val, const char *  new_val  )

static

Definition at line 3799 of file command.c.

{
    if (new_val == NULL)
        return false;
 
    if (old_val == NULL || strcmp(old_val, new_val) != 0)
        return true;
 
    return false;
}

Referenced by do_connect().

print_with_linenumbers()

static void print_with_linenumbers ( FILE *  output, char *  lines, bool  is_func  )

static

Definition at line 6352 of file command.c.

{
    bool        in_header = is_func;
    int         lineno = 0;
 
    while (*lines != '\0')
    {
        char       *eol;
 
        if (in_header &&
            (strncmp(lines, "AS ", 3) == 0 ||
             strncmp(lines, "BEGIN ", 6) == 0 ||
             strncmp(lines, "RETURN ", 7) == 0))
            in_header = false;
 
        /* increment lineno only for body's lines */
        if (!in_header)
            lineno++;
 
        /* find and mark end of current line */
        eol = strchr(lines, '\n');
        if (eol != NULL)
            *eol = '\0';
 
        /* show current line as appropriate */
        if (in_header)
            fprintf(output, "        %s\n", lines);
        else
            fprintf(output, "%-7d %s\n", lineno, lines);
 
        /* advance to next line, if any */
        if (eol == NULL)
            break;
        lines = ++eol;
    }
}

References fprintf, and output.

Referenced by exec_command_sf_sv().

printGSSInfo()

static void printGSSInfo ( void  )

static

Definition at line 4435 of file command.c.

{
    if (!PQgssEncInUse(pset.db))
        return;                 /* no GSSAPI encryption in use */
 
    printf(_("GSSAPI-encrypted connection\n"));
}

References _, _psqlSettings::db, PQgssEncInUse(), printf, and pset.

Referenced by connection_warnings().

printPsetInfo()

static bool printPsetInfo ( const char *  param, printQueryOpt *  popt  )

static

Definition at line 5324 of file command.c.

{
    Assert(param != NULL);
 
    /* show border style/width */
    if (strcmp(param, "border") == 0)
        printf(_("Border style is %d.\n"), popt->topt.border);
 
    /* show the target width for the wrapped format */
    else if (strcmp(param, "columns") == 0)
    {
        if (!popt->topt.columns)
            printf(_("Target width is unset.\n"));
        else
            printf(_("Target width is %d.\n"), popt->topt.columns);
    }
 
    /* show expanded/vertical mode */
    else if (strcmp(param, "x") == 0 || strcmp(param, "expanded") == 0 || strcmp(param, "vertical") == 0)
    {
        if (popt->topt.expanded == 1)
            printf(_("Expanded display is on.\n"));
        else if (popt->topt.expanded == 2)
            printf(_("Expanded display is used automatically.\n"));
        else
            printf(_("Expanded display is off.\n"));
    }
 
    /* show xheader width value */
    else if (strcmp(param, "xheader_width") == 0)
    {
        if (popt->topt.expanded_header_width_type == PRINT_XHEADER_FULL)
            printf(_("Expanded header width is \"%s\".\n"), "full");
        else if (popt->topt.expanded_header_width_type == PRINT_XHEADER_COLUMN)
            printf(_("Expanded header width is \"%s\".\n"), "column");
        else if (popt->topt.expanded_header_width_type == PRINT_XHEADER_PAGE)
            printf(_("Expanded header width is \"%s\".\n"), "page");
        else if (popt->topt.expanded_header_width_type == PRINT_XHEADER_EXACT_WIDTH)
            printf(_("Expanded header width is %d.\n"), popt->topt.expanded_header_exact_width);
    }
 
    /* show field separator for CSV format */
    else if (strcmp(param, "csv_fieldsep") == 0)
    {
        printf(_("Field separator for CSV is \"%s\".\n"),
               popt->topt.csvFieldSep);
    }
 
    /* show field separator for unaligned text */
    else if (strcmp(param, "fieldsep") == 0)
    {
        if (popt->topt.fieldSep.separator_zero)
            printf(_("Field separator is zero byte.\n"));
        else
            printf(_("Field separator is \"%s\".\n"),
                   popt->topt.fieldSep.separator);
    }
 
    else if (strcmp(param, "fieldsep_zero") == 0)
    {
        printf(_("Field separator is zero byte.\n"));
    }
 
    /* show disable "(x rows)" footer */
    else if (strcmp(param, "footer") == 0)
    {
        if (popt->topt.default_footer)
            printf(_("Default footer is on.\n"));
        else
            printf(_("Default footer is off.\n"));
    }
 
    /* show format */
    else if (strcmp(param, "format") == 0)
    {
        printf(_("Output format is %s.\n"), _align2string(popt->topt.format));
    }
 
    /* show table line style */
    else if (strcmp(param, "linestyle") == 0)
    {
        printf(_("Line style is %s.\n"),
               get_line_style(&popt->topt)->name);
    }
 
    /* show null display */
    else if (strcmp(param, "null") == 0)
    {
        printf(_("Null display is \"%s\".\n"),
               popt->nullPrint ? popt->nullPrint : "");
    }
 
    /* show locale-aware numeric output */
    else if (strcmp(param, "numericlocale") == 0)
    {
        if (popt->topt.numericLocale)
            printf(_("Locale-adjusted numeric output is on.\n"));
        else
            printf(_("Locale-adjusted numeric output is off.\n"));
    }
 
    /* show toggle use of pager */
    else if (strcmp(param, "pager") == 0)
    {
        if (popt->topt.pager == 1)
            printf(_("Pager is used for long output.\n"));
        else if (popt->topt.pager == 2)
            printf(_("Pager is always used.\n"));
        else
            printf(_("Pager usage is off.\n"));
    }
 
    /* show minimum lines for pager use */
    else if (strcmp(param, "pager_min_lines") == 0)
    {
        printf(ngettext("Pager won't be used for less than %d line.\n",
                        "Pager won't be used for less than %d lines.\n",
                        popt->topt.pager_min_lines),
               popt->topt.pager_min_lines);
    }
 
    /* show record separator for unaligned text */
    else if (strcmp(param, "recordsep") == 0)
    {
        if (popt->topt.recordSep.separator_zero)
            printf(_("Record separator is zero byte.\n"));
        else if (strcmp(popt->topt.recordSep.separator, "\n") == 0)
            printf(_("Record separator is <newline>.\n"));
        else
            printf(_("Record separator is \"%s\".\n"),
                   popt->topt.recordSep.separator);
    }
 
    else if (strcmp(param, "recordsep_zero") == 0)
    {
        printf(_("Record separator is zero byte.\n"));
    }
 
    /* show HTML table tag options */
    else if (strcmp(param, "T") == 0 || strcmp(param, "tableattr") == 0)
    {
        if (popt->topt.tableAttr)
            printf(_("Table attributes are \"%s\".\n"),
                   popt->topt.tableAttr);
        else
            printf(_("Table attributes unset.\n"));
    }
 
    /* show title override */
    else if (strcmp(param, "C") == 0 || strcmp(param, "title") == 0)
    {
        if (popt->title)
            printf(_("Title is \"%s\".\n"), popt->title);
        else
            printf(_("Title is unset.\n"));
    }
 
    /* show toggle between full and tuples-only format */
    else if (strcmp(param, "t") == 0 || strcmp(param, "tuples_only") == 0)
    {
        if (popt->topt.tuples_only)
            printf(_("Tuples only is on.\n"));
        else
            printf(_("Tuples only is off.\n"));
    }
 
    /* Unicode style formatting */
    else if (strcmp(param, "unicode_border_linestyle") == 0)
    {
        printf(_("Unicode border line style is \"%s\".\n"),
               _unicode_linestyle2string(popt->topt.unicode_border_linestyle));
    }
 
    else if (strcmp(param, "unicode_column_linestyle") == 0)
    {
        printf(_("Unicode column line style is \"%s\".\n"),
               _unicode_linestyle2string(popt->topt.unicode_column_linestyle));
    }
 
    else if (strcmp(param, "unicode_header_linestyle") == 0)
    {
        printf(_("Unicode header line style is \"%s\".\n"),
               _unicode_linestyle2string(popt->topt.unicode_header_linestyle));
    }
 
    else
    {
        pg_log_error("\\pset: unknown option: %s", param);
        return false;
    }
 
    return true;
}

References _, _align2string(), _unicode_linestyle2string(), 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, get_line_style(), printTextFormat::name, ngettext, printQueryOpt::nullPrint, printTableOpt::numericLocale, printTableOpt::pager, printTableOpt::pager_min_lines, pg_log_error, PRINT_XHEADER_COLUMN, PRINT_XHEADER_EXACT_WIDTH, PRINT_XHEADER_FULL, PRINT_XHEADER_PAGE, printf, printTableOpt::recordSep, separator::separator, separator::separator_zero, printTableOpt::tableAttr, printQueryOpt::title, printQueryOpt::topt, printTableOpt::tuples_only, printTableOpt::unicode_border_linestyle, printTableOpt::unicode_column_linestyle, and printTableOpt::unicode_header_linestyle.

Referenced by do_pset().

printSSLInfo()

static void printSSLInfo ( void  )

static

Definition at line 4407 of file command.c.

{
    const char *protocol;
    const char *cipher;
    const char *compression;
    const char *alpn;
 
    if (!PQsslInUse(pset.db))
        return;                 /* no SSL */
 
    protocol = PQsslAttribute(pset.db, "protocol");
    cipher = PQsslAttribute(pset.db, "cipher");
    compression = PQsslAttribute(pset.db, "compression");
    alpn = PQsslAttribute(pset.db, "alpn");
 
    printf(_("SSL connection (protocol: %s, cipher: %s, compression: %s, ALPN: %s)\n"),
           protocol ? protocol : _("unknown"),
           cipher ? cipher : _("unknown"),
           (compression && strcmp(compression, "off") != 0) ? _("on") : _("off"),
           (alpn && alpn[0] != '\0') ? alpn : _("none"));
}

References _, _psqlSettings::db, PQsslAttribute(), PQsslInUse(), printf, and pset.

Referenced by connection_warnings().

process_command_g_options()

static backslashResult process_command_g_options ( char *  first_option, PsqlScanState  scan_state, bool  active_branch, const char *  cmd  )

static

Definition at line 1776 of file command.c.

{
    bool        success = true;
    bool        found_r_paren = false;
 
    do
    {
        char       *option;
        size_t      optlen;
 
        /* If not first time through, collect a new option */
        if (first_option)
            option = first_option;
        else
        {
            option = psql_scan_slash_option(scan_state,
                                            OT_NORMAL, NULL, false);
            if (!option)
            {
                if (active_branch)
                {
                    pg_log_error("\\%s: missing right parenthesis", cmd);
                    success = false;
                }
                break;
            }
        }
 
        /* Check for terminating right paren, and remove it from string */
        optlen = strlen(option);
        if (optlen > 0 && option[optlen - 1] == ')')
        {
            option[--optlen] = '\0';
            found_r_paren = true;
        }
 
        /* If there was anything besides parentheses, parse/execute it */
        if (optlen > 0)
        {
            /* We can have either "name" or "name=value" */
            char       *valptr = strchr(option, '=');
 
            if (valptr)
                *valptr++ = '\0';
            if (active_branch)
            {
                /* save settings if not done already, then apply option */
                if (pset.gsavepopt == NULL)
                    pset.gsavepopt = savePsetInfo(&pset.popt);
                success &= do_pset(option, valptr, &pset.popt, true);
            }
        }
 
        /* Clean up after this option.  We should not free first_option. */
        if (first_option)
            first_option = NULL;
        else
            free(option);
    } while (!found_r_paren);
 
    /* If we failed after already changing some options, undo side-effects */
    if (!success && active_branch && pset.gsavepopt)
    {
        restorePsetInfo(&pset.popt, pset.gsavepopt);
        pset.gsavepopt = NULL;
    }
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References do_pset(), free, _psqlSettings::gsavepopt, OT_NORMAL, pg_log_error, _psqlSettings::popt, pset, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), restorePsetInfo(), savePsetInfo(), and success.

Referenced by exec_command_g().

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().

prompt_for_password()

static char * prompt_for_password ( const char *  username, bool *  canceled  )

static

Definition at line 3771 of file command.c.

{
    char       *result;
    PromptInterruptContext prompt_ctx;
 
    /* Set up to let SIGINT cancel simple_prompt_extended() */
    prompt_ctx.jmpbuf = sigint_interrupt_jmp;
    prompt_ctx.enabled = &sigint_interrupt_enabled;
    prompt_ctx.canceled = false;
 
    if (username == NULL || username[0] == '\0')
        result = simple_prompt_extended("Password: ", false, &prompt_ctx);
    else
    {
        char       *prompt_text;
 
        prompt_text = psprintf(_("Password for user %s: "), username);
        result = simple_prompt_extended(prompt_text, false, &prompt_ctx);
        free(prompt_text);
    }
 
    if (canceled)
        *canceled = prompt_ctx.canceled;
 
    return result;
}

References _, PromptInterruptContext::canceled, PromptInterruptContext::enabled, free, PromptInterruptContext::jmpbuf, psprintf(), sigint_interrupt_enabled, sigint_interrupt_jmp, simple_prompt_extended(), and username.

Referenced by do_connect().

pset_bool_string()

static const char * pset_bool_string ( bool  val )

static

Definition at line 5586 of file command.c.

{
    return val ? "on" : "off";
}

References val.

Referenced by pset_value_string().

pset_quoted_string()

static char * pset_quoted_string ( const char *  str )

static

Definition at line 5593 of file command.c.

{
    char       *ret = pg_malloc(strlen(str) * 2 + 3);
    char       *r = ret;
 
    *r++ = '\'';
 
    for (; *str; str++)
    {
        if (*str == '\n')
        {
            *r++ = '\\';
            *r++ = 'n';
        }
        else if (*str == '\'')
        {
            *r++ = '\\';
            *r++ = '\'';
        }
        else
            *r++ = *str;
    }
 
    *r++ = '\'';
    *r = '\0';
 
    return ret;
}

References pg_malloc(), and str.

Referenced by pset_value_string().

pset_value_string()

static char * pset_value_string ( const char *  param, printQueryOpt *  popt  )

static

Definition at line 5631 of file command.c.

{
    Assert(param != NULL);
 
    if (strcmp(param, "border") == 0)
        return psprintf("%d", popt->topt.border);
    else if (strcmp(param, "columns") == 0)
        return psprintf("%d", popt->topt.columns);
    else if (strcmp(param, "csv_fieldsep") == 0)
        return pset_quoted_string(popt->topt.csvFieldSep);
    else if (strcmp(param, "expanded") == 0)
        return pstrdup(popt->topt.expanded == 2
                       ? "auto"
                       : pset_bool_string(popt->topt.expanded));
    else if (strcmp(param, "fieldsep") == 0)
        return pset_quoted_string(popt->topt.fieldSep.separator
                                  ? popt->topt.fieldSep.separator
                                  : "");
    else if (strcmp(param, "fieldsep_zero") == 0)
        return pstrdup(pset_bool_string(popt->topt.fieldSep.separator_zero));
    else if (strcmp(param, "footer") == 0)
        return pstrdup(pset_bool_string(popt->topt.default_footer));
    else if (strcmp(param, "format") == 0)
        return pstrdup(_align2string(popt->topt.format));
    else if (strcmp(param, "linestyle") == 0)
        return pstrdup(get_line_style(&popt->topt)->name);
    else if (strcmp(param, "null") == 0)
        return pset_quoted_string(popt->nullPrint
                                  ? popt->nullPrint
                                  : "");
    else if (strcmp(param, "numericlocale") == 0)
        return pstrdup(pset_bool_string(popt->topt.numericLocale));
    else if (strcmp(param, "pager") == 0)
        return psprintf("%d", popt->topt.pager);
    else if (strcmp(param, "pager_min_lines") == 0)
        return psprintf("%d", popt->topt.pager_min_lines);
    else if (strcmp(param, "recordsep") == 0)
        return pset_quoted_string(popt->topt.recordSep.separator
                                  ? popt->topt.recordSep.separator
                                  : "");
    else if (strcmp(param, "recordsep_zero") == 0)
        return pstrdup(pset_bool_string(popt->topt.recordSep.separator_zero));
    else if (strcmp(param, "tableattr") == 0)
        return popt->topt.tableAttr ? pset_quoted_string(popt->topt.tableAttr) : pstrdup("");
    else if (strcmp(param, "title") == 0)
        return popt->title ? pset_quoted_string(popt->title) : pstrdup("");
    else if (strcmp(param, "tuples_only") == 0)
        return pstrdup(pset_bool_string(popt->topt.tuples_only));
    else if (strcmp(param, "unicode_border_linestyle") == 0)
        return pstrdup(_unicode_linestyle2string(popt->topt.unicode_border_linestyle));
    else if (strcmp(param, "unicode_column_linestyle") == 0)
        return pstrdup(_unicode_linestyle2string(popt->topt.unicode_column_linestyle));
    else if (strcmp(param, "unicode_header_linestyle") == 0)
        return pstrdup(_unicode_linestyle2string(popt->topt.unicode_header_linestyle));
    else if (strcmp(param, "xheader_width") == 0)
    {
        if (popt->topt.expanded_header_width_type == PRINT_XHEADER_FULL)
            return pstrdup("full");
        else if (popt->topt.expanded_header_width_type == PRINT_XHEADER_COLUMN)
            return pstrdup("column");
        else if (popt->topt.expanded_header_width_type == PRINT_XHEADER_PAGE)
            return pstrdup("page");
        else
        {
            /* must be PRINT_XHEADER_EXACT_WIDTH */
            char        wbuff[32];
 
            snprintf(wbuff, sizeof(wbuff), "%d",
                     popt->topt.expanded_header_exact_width);
            return pstrdup(wbuff);
        }
    }
    else
        return pstrdup("ERROR");
}

References _align2string(), _unicode_linestyle2string(), 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, get_line_style(), printTextFormat::name, printQueryOpt::nullPrint, printTableOpt::numericLocale, printTableOpt::pager, printTableOpt::pager_min_lines, PRINT_XHEADER_COLUMN, PRINT_XHEADER_FULL, PRINT_XHEADER_PAGE, pset_bool_string(), pset_quoted_string(), psprintf(), pstrdup(), printTableOpt::recordSep, separator::separator, separator::separator_zero, snprintf, printTableOpt::tableAttr, printQueryOpt::title, printQueryOpt::topt, printTableOpt::tuples_only, printTableOpt::unicode_border_linestyle, printTableOpt::unicode_column_linestyle, and printTableOpt::unicode_header_linestyle.

Referenced by exec_command_pset().

read_connect_arg()

static char * read_connect_arg ( PsqlScanState  scan_state )

static

Definition at line 3539 of file command.c.

{
    char       *result;
    char        quote;
 
    /*
     * Ideally we should treat the arguments as SQL identifiers.  But for
     * backwards compatibility with 7.2 and older pg_dump files, we have to
     * take unquoted arguments verbatim (don't downcase them). For now,
     * double-quoted arguments may be stripped of double quotes (as if SQL
     * identifiers).  By 7.4 or so, pg_dump files can be expected to
     * double-quote all mixed-case \connect arguments, and then we can get rid
     * of OT_SQLIDHACK.
     */
    result = psql_scan_slash_option(scan_state, OT_SQLIDHACK, &quote, true);
 
    if (!result)
        return NULL;
 
    if (quote)
        return result;
 
    if (*result == '\0' || strcmp(result, "-") == 0)
    {
        free(result);
        return NULL;
    }
 
    return result;
}

References free, OT_SQLIDHACK, and psql_scan_slash_option().

Referenced by exec_command_connect().

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().

save_query_text_state()

static void save_query_text_state ( PsqlScanState  scan_state, ConditionalStack  cstack, PQExpBuffer  query_buf  )

static

Definition at line 3707 of file command.c.

{
    if (query_buf)
        conditional_stack_set_query_len(cstack, query_buf->len);
    conditional_stack_set_paren_depth(cstack,
                                      psql_scan_get_paren_depth(scan_state));
}

References conditional_stack_set_paren_depth(), conditional_stack_set_query_len(), PQExpBufferData::len, and psql_scan_get_paren_depth().

Referenced by exec_command_elif(), exec_command_else(), and exec_command_if().

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().

set_unicode_line_style()

static bool set_unicode_line_style ( const char *  value, size_t  vallen, unicode_linestyle *  linestyle  )

static

Definition at line 4928 of file command.c.

{
    if (pg_strncasecmp("single", value, vallen) == 0)
        *linestyle = UNICODE_LINESTYLE_SINGLE;
    else if (pg_strncasecmp("double", value, vallen) == 0)
        *linestyle = UNICODE_LINESTYLE_DOUBLE;
    else
        return false;
    return true;
}

References pg_strncasecmp(), UNICODE_LINESTYLE_DOUBLE, UNICODE_LINESTYLE_SINGLE, and value.

Referenced by do_pset().

strip_lineno_from_objdesc()

static int strip_lineno_from_objdesc ( char *  obj )

static

Definition at line 6264 of file command.c.

{
    char       *c;
    int         lineno;
 
    if (!obj || obj[0] == '\0')
        return -1;
 
    c = obj + strlen(obj) - 1;
 
    /*
     * This business of parsing backwards is dangerous as can be in a
     * multibyte environment: there is no reason to believe that we are
     * looking at the first byte of a character, nor are we necessarily
     * working in a "safe" encoding.  Fortunately the bitpatterns we are
     * looking for are unlikely to occur as non-first bytes, but beware of
     * trying to expand the set of cases that can be recognized.  We must
     * guard the <ctype.h> macros by using isascii() first, too.
     */
 
    /* skip trailing whitespace */
    while (c > obj && isascii((unsigned char) *c) && isspace((unsigned char) *c))
        c--;
 
    /* must have a digit as last non-space char */
    if (c == obj || !isascii((unsigned char) *c) || !isdigit((unsigned char) *c))
        return -1;
 
    /* find start of digit string */
    while (c > obj && isascii((unsigned char) *c) && isdigit((unsigned char) *c))
        c--;
 
    /* digits must be separated from object name by space or closing paren */
    /* notice also that we are not allowing an empty object name ... */
    if (c == obj || !isascii((unsigned char) *c) ||
        !(isspace((unsigned char) *c) || *c == ')'))
        return -1;
 
    /* parse digit string */
    c++;
    lineno = atoi(c);
    if (lineno < 1)
    {
        pg_log_error("invalid line number: %s", c);
        return 0;
    }
 
    /* strip digit string from object name */
    *c = '\0';
 
    return lineno;
}

References pg_log_error.

Referenced by exec_command_ef_ev().

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().

wait_until_connected()

static void wait_until_connected ( PGconn *  conn )

static

Definition at line 4286 of file command.c.

{
    bool        forRead = false;
 
    while (true)
    {
        int         rc;
        int         sock;
        pg_usec_time_t end_time;
 
        /*
         * On every iteration of the connection sequence, let's check if the
         * user has requested a cancellation.
         */
        if (cancel_pressed)
            break;
 
        /*
         * Do not assume that the socket remains the same across
         * PQconnectPoll() calls.
         */
        sock = PQsocket(conn);
        if (sock == -1)
            break;
 
        /*
         * If the user sends SIGINT between the cancel_pressed check, and
         * polling of the socket, it will not be recognized. Instead, we will
         * just wait until the next step in the connection sequence or
         * forever, which might require users to send SIGTERM or SIGQUIT.
         *
         * Some solutions would include the "self-pipe trick," using
         * pselect(2) and ppoll(2), or using a timeout.
         *
         * The self-pipe trick requires a bit of code to setup. pselect(2) and
         * ppoll(2) are not on all the platforms we support. The simplest
         * solution happens to just be adding a timeout, so let's wait for 1
         * second and check cancel_pressed again.
         */
        end_time = PQgetCurrentTimeUSec() + 1000000;
        rc = PQsocketPoll(sock, forRead, !forRead, end_time);
        if (rc == -1)
            return;
 
        switch (PQconnectPoll(conn))
        {
            case PGRES_POLLING_OK:
            case PGRES_POLLING_FAILED:
                return;
            case PGRES_POLLING_READING:
                forRead = true;
                continue;
            case PGRES_POLLING_WRITING:
                forRead = false;
                continue;
            case PGRES_POLLING_ACTIVE:
                pg_unreachable();
        }
    }
}

References cancel_pressed, conn, end_time, pg_unreachable, PGRES_POLLING_ACTIVE, PGRES_POLLING_FAILED, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PQconnectPoll(), PQgetCurrentTimeUSec(), PQsocket(), and PQsocketPoll().

Referenced by do_connect().