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_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_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_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_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_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 5304 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 4479 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 4535 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 3946 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 3351 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 5916 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 3325 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 3420 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, 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 4217 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 4565 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, fmt, 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 5314 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, fflush(), 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 5365 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, fflush(), fprintf, i, ITIMER_REAL, PQExpBufferData::len, Min, printTableOpt::pager, pg_free(), pg_log_error, pg_malloc(), pg_usleep(), _psqlSettings::popt, pset, PSQLexecWatch(), res, 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 5606 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, fflush(), 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 4135 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, fflush(), 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 291 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, "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, "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, "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, "l+") == 0 || strcmp(cmd, "list+") == 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, "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, "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)
        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_errverbose(), exec_command_f(), exec_command_g(), exec_command_gdesc(), exec_command_getenv(), 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_set(), exec_command_setenv(), exec_command_sf_sv(), exec_command_shell_escape(), exec_command_slash_command_help(), 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 454 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 473 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 509 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 558 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 644 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 708 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 591 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 741 of file command.c.

{
    if (active_branch)
    {
        char       *db = PQdb(pset.db);
 
        if (db == NULL)
            printf(_("You are currently not connected to a database.\n"));
        else
        {
            char       *host = PQhost(pset.db);
            char       *hostaddr = PQhostaddr(pset.db);
 
            if (is_unixsock_path(host))
            {
                /* hostaddr overrides host */
                if (hostaddr && *hostaddr)
                    printf(_("You are connected to database \"%s\" as user \"%s\" on address \"%s\" at port \"%s\".\n"),
                           db, PQuser(pset.db), hostaddr, PQport(pset.db));
                else
                    printf(_("You are connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n"),
                           db, PQuser(pset.db), host, PQport(pset.db));
            }
            else
            {
                if (hostaddr && *hostaddr && strcmp(host, hostaddr) != 0)
                    printf(_("You are connected to database \"%s\" as user \"%s\" on host \"%s\" (address \"%s\") at port \"%s\".\n"),
                           db, PQuser(pset.db), host, hostaddr, PQport(pset.db));
                else
                    printf(_("You are connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n"),
                           db, PQuser(pset.db), host, PQport(pset.db));
            }
            printSSLInfo();
            printGSSInfo();
        }
    }
 
    return PSQL_CMD_SKIP_LINE;
}

References _, _psqlSettings::db, is_unixsock_path(), PQdb(), PQhost(), PQhostaddr(), PQport(), PQuser(), printf, printGSSInfo(), printSSLInfo(), pset, and PSQL_CMD_SKIP_LINE.

Referenced by exec_command().

exec_command_copy()

static backslashResult exec_command_copy ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 785 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 807 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 819 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 843 of file command.c.

{
    backslashResult status = PSQL_CMD_SKIP_LINE;
    bool        success = true;
 
    if (active_branch)
    {
        char       *pattern;
        bool        show_verbose,
                    show_system;
 
        /* 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;
 
        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] != '+')
                        pattern2 = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, true);
 
                    switch (cmd[2])
                    {
                        case '\0':
                        case '+':
                            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':
                        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':
                            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 '+':
                        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;
        }
 
        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(), 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(), PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, PSQL_CMD_UNKNOWN, psql_scan_slash_option(), success, 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 1109 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 1363 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 1151 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(fname);
                    /* 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(), copy_previous_query(), do_edit(), expand_tilde(), free, ignore_slash_options(), OT_NORMAL, pg_log_error, 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 1247 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 1858 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 1934 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 1408 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;
                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(), 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 1999 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_errverbose()

static backslashResult exec_command_errverbose ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1446 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 1476 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_g()

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

static

Definition at line 1504 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 (!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 expand_tilde(), printTableOpt::expanded, free, _psqlSettings::gfname, _psqlSettings::gsavepopt, OT_FILEPIPE, pg_strdup(), _psqlSettings::popt, process_command_g_options(), pset, 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 1632 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 1649 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_gexec()

static backslashResult exec_command_gexec ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 1686 of file command.c.

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

References _psqlSettings::gexec_flag, pset, 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 1703 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 (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 _psqlSettings::gset_prefix, ignore_slash_options(), OT_NORMAL, pg_strdup(), pset, 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 1732 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 1752 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 1812 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 1771 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 2039 of file command.c.

{
    bool        success = true;
 
    if (active_branch)
    {
        char       *pattern;
        bool        show_verbose;
 
        pattern = psql_scan_slash_option(scan_state,
                                         OT_NORMAL, NULL, true);
 
        show_verbose = strchr(cmd, '+') ? true : false;
 
        success = listAllDbs(pattern, show_verbose);
 
        free(pattern);
    }
    else
        ignore_slash_options(scan_state);
 
    return success ? PSQL_CMD_SKIP_LINE : PSQL_CMD_ERROR;
}

References free, ignore_slash_options(), listAllDbs(), OT_NORMAL, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, psql_scan_slash_option(), success, 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 2067 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 (strcmp(cmd + 3, "list") == 0)
            success = listLargeObjects(false);
        else if (strcmp(cmd + 3, "list+") == 0)
            success = listLargeObjects(true);
 
        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(), free, ignore_slash_options(), listLargeObjects(), OT_NORMAL, pg_log_error, PSQL_CMD_ERROR, PSQL_CMD_SKIP_LINE, PSQL_CMD_UNKNOWN, psql_scan_slash_option(), and success.

Referenced by exec_command().

exec_command_out()

static backslashResult exec_command_out ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2145 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 2194 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 2228 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(), res, 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 2168 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, fflush(), 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 2304 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, fflush(), 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 2381 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 2436 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 2450 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 2468 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_set()

static backslashResult exec_command_set ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2495 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 2548 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 2596 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 3084 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 3106 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_t()

static backslashResult exec_command_t ( PsqlScanState  scan_state, bool  active_branch  )

static

Definition at line 2679 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 2701 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 2723 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)
        {