2000-01-19 00:30:24 +01:00
|
|
|
/*
|
|
|
|
* psql - the PostgreSQL interactive terminal
|
|
|
|
*
|
2018-01-03 05:30:12 +01:00
|
|
|
* Copyright (c) 2000-2018, PostgreSQL Global Development Group
|
2000-01-19 00:30:24 +01:00
|
|
|
*
|
2010-09-20 22:08:53 +02:00
|
|
|
* src/bin/psql/common.c
|
2000-01-19 00:30:24 +01:00
|
|
|
*/
|
2001-02-10 03:31:31 +01:00
|
|
|
#include "postgres_fe.h"
|
1999-11-04 22:56:02 +01:00
|
|
|
#include "common.h"
|
|
|
|
|
2003-06-28 02:12:40 +02:00
|
|
|
#include <ctype.h>
|
Fix behavior of printTable() and friends with externally-invoked pager.
The formatting modes that depend on knowledge of the terminal window width
did not work right when printing a query result that's been fetched in
sections (as a result of FETCH_SIZE). ExecQueryUsingCursor() would force
use of the pager as soon as there's more than one result section, and then
print.c would see an output file pointer that's not stdout and incorrectly
conclude that the terminal window width isn't relevant.
This has been broken all along for non-expanded "wrapped" output format,
and as of 9.5 the issue affects expanded mode as well. The problem also
caused "\pset expanded auto" mode to invariably *not* switch to expanded
output in a segmented result, which seems to me to be exactly backwards.
To fix, we need to pass down an "is_pager" flag to inform the print.c
subroutines that some calling level has already replaced stdout with a
pager pipe, so they should (a) not do that again and (b) nonetheless honor
the window size. (Notably, this makes the first is_pager test in
print_aligned_text() not be dead code anymore.)
This patch is a bit invasive because there are so many existing calls of
printQuery()/printTable(), but fortunately all but a couple can just pass
"false" for the added parameter.
Back-patch to 9.5 but no further. Given the lack of field complaints,
it's not clear that we should change the behavior in stable branches.
Also, the API change for printQuery()/printTable() might possibly break
third-party code, again something we don't like to do in stable branches.
However, it's not quite too late to do this in 9.5, and with the larger
scope of the problem there, it seems worth doing.
2015-12-03 00:20:33 +01:00
|
|
|
#include <limits.h>
|
2016-09-03 21:29:03 +02:00
|
|
|
#include <math.h>
|
1999-11-04 22:56:02 +01:00
|
|
|
#include <signal.h>
|
|
|
|
#ifndef WIN32
|
1999-11-05 00:14:30 +01:00
|
|
|
#include <unistd.h> /* for write() */
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
#else
|
2000-04-12 19:17:23 +02:00
|
|
|
#include <io.h> /* for _write() */
|
2000-02-08 00:10:11 +01:00
|
|
|
#include <win32.h>
|
1999-11-04 22:56:02 +01:00
|
|
|
#endif
|
|
|
|
|
Fix assorted places in psql to print version numbers >= 10 in new style.
This is somewhat cosmetic, since as long as you know what you are looking
at, "10.0" is a serviceable substitute for "10". But there is a potential
for confusion between version numbers with minor numbers and those without
--- we don't want people asking "why is psql saying 10.0 when my server is
10.2". Therefore, back-patch as far as practical, which turns out to be
9.3. I could have redone the patch to use fprintf(stderr) in place of
psql_error(), but it seems more work than is warranted for branches that
will be EOL or nearly so by the time v10 comes out.
Although only psql seems to contain any code that needs this, I chose
to put the support function into fe_utils, since it seems likely we'll
need it in other client programs in future. (In 9.3-9.5, use dumputils.c,
the predecessor of fe_utils/string_utils.c.)
In HEAD, also fix the backend code that whines about loadable-library
version mismatch. I don't see much need to back-patch that.
2016-08-16 21:58:30 +02:00
|
|
|
#include "fe_utils/string_utils.h"
|
2008-05-14 21:10:29 +02:00
|
|
|
#include "portability/instr_time.h"
|
|
|
|
|
1999-11-04 22:56:02 +01:00
|
|
|
#include "settings.h"
|
2003-06-28 02:12:40 +02:00
|
|
|
#include "command.h"
|
1999-11-04 22:56:02 +01:00
|
|
|
#include "copy.h"
|
2016-04-09 01:23:18 +02:00
|
|
|
#include "crosstabview.h"
|
2016-03-24 23:27:28 +01:00
|
|
|
#include "fe_utils/mbprint.h"
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
|
2017-09-06 00:17:47 +02:00
|
|
|
static bool DescribeQuery(const char *query, double *elapsed_msec);
|
2006-08-30 00:25:08 +02:00
|
|
|
static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
|
2004-09-20 20:51:19 +02:00
|
|
|
static bool command_no_begin(const char *query);
|
2006-08-30 00:25:08 +02:00
|
|
|
static bool is_select_command(const char *query);
|
2003-06-28 02:12:40 +02:00
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
|
1999-11-04 22:56:02 +01:00
|
|
|
/*
|
2015-12-03 20:28:58 +01:00
|
|
|
* openQueryOutputFile --- attempt to open a query output file
|
1999-11-04 22:56:02 +01:00
|
|
|
*
|
2015-12-03 20:28:58 +01:00
|
|
|
* fname == NULL selects stdout, else an initial '|' selects a pipe,
|
|
|
|
* else plain file.
|
|
|
|
*
|
|
|
|
* Returns output file pointer into *fout, and is-a-pipe flag into *is_pipe.
|
|
|
|
* Caller is responsible for adjusting SIGPIPE state if it's a pipe.
|
|
|
|
*
|
2017-08-16 06:22:32 +02:00
|
|
|
* On error, reports suitable error message and returns false.
|
1999-11-04 22:56:02 +01:00
|
|
|
*/
|
|
|
|
bool
|
2015-12-03 20:28:58 +01:00
|
|
|
openQueryOutputFile(const char *fname, FILE **fout, bool *is_pipe)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
1999-11-05 00:14:30 +01:00
|
|
|
if (!fname || fname[0] == '\0')
|
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
*fout = stdout;
|
|
|
|
*is_pipe = false;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
else if (*fname == '|')
|
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
*fout = popen(fname + 1, "w");
|
|
|
|
*is_pipe = true;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
*fout = fopen(fname, "w");
|
|
|
|
*is_pipe = false;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
if (*fout == NULL)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2000-01-19 00:30:24 +01:00
|
|
|
psql_error("%s: %s\n", fname, strerror(errno));
|
2015-12-03 20:28:58 +01:00
|
|
|
return false;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
return true;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
/*
|
|
|
|
* setQFout
|
|
|
|
* -- handler for -o command line option and \o command
|
|
|
|
*
|
|
|
|
* On success, updates pset with the new output file and returns true.
|
|
|
|
* On failure, returns false without changing pset state.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
setQFout(const char *fname)
|
|
|
|
{
|
|
|
|
FILE *fout;
|
|
|
|
bool is_pipe;
|
|
|
|
|
|
|
|
/* First make sure we can open the new output file/pipe */
|
|
|
|
if (!openQueryOutputFile(fname, &fout, &is_pipe))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Close old file/pipe */
|
|
|
|
if (pset.queryFout && pset.queryFout != stdout && pset.queryFout != stderr)
|
|
|
|
{
|
|
|
|
if (pset.queryFoutPipe)
|
|
|
|
pclose(pset.queryFout);
|
|
|
|
else
|
|
|
|
fclose(pset.queryFout);
|
|
|
|
}
|
|
|
|
|
|
|
|
pset.queryFout = fout;
|
|
|
|
pset.queryFoutPipe = is_pipe;
|
|
|
|
|
|
|
|
/* Adjust SIGPIPE handling appropriately: ignore signal if is_pipe */
|
|
|
|
set_sigpipe_trap_state(is_pipe);
|
|
|
|
restore_sigpipe_trap();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
1999-11-04 22:56:02 +01:00
|
|
|
|
|
|
|
|
2016-03-18 20:05:49 +01:00
|
|
|
/*
|
|
|
|
* Variable-fetching callback for flex lexer
|
|
|
|
*
|
|
|
|
* If the specified variable exists, return its value as a string (malloc'd
|
|
|
|
* and expected to be freed by the caller); else return NULL.
|
|
|
|
*
|
Allow psql variable substitution to occur in backtick command strings.
Previously, text between backquotes in a psql metacommand's arguments
was always passed to the shell literally. That considerably hobbles
the usefulness of the feature for scripting, so we'd foreseen for a long
time that we'd someday want to allow substitution of psql variables into
the shell command. IMO the addition of \if metacommands has brought us to
that point, since \if can greatly benefit from some sort of client-side
expression evaluation capability, and psql itself is not going to grow any
such thing in time for v10. Hence, this patch. It allows :VARIABLE to be
replaced by the exact contents of the named variable, while :'VARIABLE'
is replaced by the variable's contents suitably quoted to become a single
shell-command argument. (The quoting rules for that are different from
those for SQL literals, so this is a bit of an abuse of the :'VARIABLE'
notation, but I doubt anyone will be confused.)
As with other situations in psql, no substitution occurs if the word
following a colon is not a known variable name. That limits the risk of
compatibility problems for existing psql scripts; but the risk isn't zero,
so this needs to be called out in the v10 release notes.
Discussion: https://postgr.es/m/9561.1490895211@sss.pgh.pa.us
2017-04-02 03:44:54 +02:00
|
|
|
* If "quote" isn't PQUOTE_PLAIN, then return the value suitably quoted and
|
|
|
|
* escaped for the specified quoting requirement. (Failure in escaping
|
|
|
|
* should lead to printing an error and returning NULL.)
|
2017-03-13 22:14:46 +01:00
|
|
|
*
|
|
|
|
* "passthrough" is the pointer previously given to psql_scan_set_passthrough.
|
Support \if ... \elif ... \else ... \endif in psql scripting.
This patch adds nestable conditional blocks to psql. The control
structure feature per se is complete, but the boolean expressions
understood by \if and \elif are pretty primitive; basically, after
variable substitution and backtick expansion, the result has to be
"true" or "false" or one of the other standard spellings of a boolean
value. But that's enough for many purposes, since you can always
do the heavy lifting on the server side; and we can extend it later.
Along the way, pay down some of the technical debt that had built up
around psql/command.c:
* Refactor exec_command() into a function per command, instead of
being a 1500-line monstrosity. This makes the file noticeably longer
because of repetitive function header/trailer overhead, but it seems
much more readable.
* Teach psql_get_variable() and psqlscanslash.l to suppress variable
substitution and backtick expansion on the basis of the conditional
stack state, thereby allowing removal of the OT_NO_EVAL kluge.
* Fix the no-doubt-once-expedient hack of sometimes silently substituting
mainloop.c's previous_buf for query_buf when calling HandleSlashCmds.
(It's a bit remarkable that commands like \r worked at all with that.)
Recall of a previous query is now done explicitly in the slash commands
where that should happen.
Corey Huinker, reviewed by Fabien Coelho, further hacking by me
Discussion: https://postgr.es/m/CADkLM=c94OSRTnat=LX0ivNq4pxDNeoomFfYvBKM5N_xfmLtAA@mail.gmail.com
2017-03-30 18:59:11 +02:00
|
|
|
* In psql, passthrough points to a ConditionalStack, which we check to
|
|
|
|
* determine whether variable expansion is allowed.
|
2016-03-18 20:05:49 +01:00
|
|
|
*/
|
|
|
|
char *
|
Allow psql variable substitution to occur in backtick command strings.
Previously, text between backquotes in a psql metacommand's arguments
was always passed to the shell literally. That considerably hobbles
the usefulness of the feature for scripting, so we'd foreseen for a long
time that we'd someday want to allow substitution of psql variables into
the shell command. IMO the addition of \if metacommands has brought us to
that point, since \if can greatly benefit from some sort of client-side
expression evaluation capability, and psql itself is not going to grow any
such thing in time for v10. Hence, this patch. It allows :VARIABLE to be
replaced by the exact contents of the named variable, while :'VARIABLE'
is replaced by the variable's contents suitably quoted to become a single
shell-command argument. (The quoting rules for that are different from
those for SQL literals, so this is a bit of an abuse of the :'VARIABLE'
notation, but I doubt anyone will be confused.)
As with other situations in psql, no substitution occurs if the word
following a colon is not a known variable name. That limits the risk of
compatibility problems for existing psql scripts; but the risk isn't zero,
so this needs to be called out in the v10 release notes.
Discussion: https://postgr.es/m/9561.1490895211@sss.pgh.pa.us
2017-04-02 03:44:54 +02:00
|
|
|
psql_get_variable(const char *varname, PsqlScanQuoteType quote,
|
2017-03-13 22:14:46 +01:00
|
|
|
void *passthrough)
|
2016-03-18 20:05:49 +01:00
|
|
|
{
|
Allow psql variable substitution to occur in backtick command strings.
Previously, text between backquotes in a psql metacommand's arguments
was always passed to the shell literally. That considerably hobbles
the usefulness of the feature for scripting, so we'd foreseen for a long
time that we'd someday want to allow substitution of psql variables into
the shell command. IMO the addition of \if metacommands has brought us to
that point, since \if can greatly benefit from some sort of client-side
expression evaluation capability, and psql itself is not going to grow any
such thing in time for v10. Hence, this patch. It allows :VARIABLE to be
replaced by the exact contents of the named variable, while :'VARIABLE'
is replaced by the variable's contents suitably quoted to become a single
shell-command argument. (The quoting rules for that are different from
those for SQL literals, so this is a bit of an abuse of the :'VARIABLE'
notation, but I doubt anyone will be confused.)
As with other situations in psql, no substitution occurs if the word
following a colon is not a known variable name. That limits the risk of
compatibility problems for existing psql scripts; but the risk isn't zero,
so this needs to be called out in the v10 release notes.
Discussion: https://postgr.es/m/9561.1490895211@sss.pgh.pa.us
2017-04-02 03:44:54 +02:00
|
|
|
char *result = NULL;
|
2016-03-18 20:05:49 +01:00
|
|
|
const char *value;
|
|
|
|
|
Support \if ... \elif ... \else ... \endif in psql scripting.
This patch adds nestable conditional blocks to psql. The control
structure feature per se is complete, but the boolean expressions
understood by \if and \elif are pretty primitive; basically, after
variable substitution and backtick expansion, the result has to be
"true" or "false" or one of the other standard spellings of a boolean
value. But that's enough for many purposes, since you can always
do the heavy lifting on the server side; and we can extend it later.
Along the way, pay down some of the technical debt that had built up
around psql/command.c:
* Refactor exec_command() into a function per command, instead of
being a 1500-line monstrosity. This makes the file noticeably longer
because of repetitive function header/trailer overhead, but it seems
much more readable.
* Teach psql_get_variable() and psqlscanslash.l to suppress variable
substitution and backtick expansion on the basis of the conditional
stack state, thereby allowing removal of the OT_NO_EVAL kluge.
* Fix the no-doubt-once-expedient hack of sometimes silently substituting
mainloop.c's previous_buf for query_buf when calling HandleSlashCmds.
(It's a bit remarkable that commands like \r worked at all with that.)
Recall of a previous query is now done explicitly in the slash commands
where that should happen.
Corey Huinker, reviewed by Fabien Coelho, further hacking by me
Discussion: https://postgr.es/m/CADkLM=c94OSRTnat=LX0ivNq4pxDNeoomFfYvBKM5N_xfmLtAA@mail.gmail.com
2017-03-30 18:59:11 +02:00
|
|
|
/* In an inactive \if branch, suppress all variable substitutions */
|
|
|
|
if (passthrough && !conditional_active((ConditionalStack) passthrough))
|
|
|
|
return NULL;
|
|
|
|
|
2016-03-18 20:05:49 +01:00
|
|
|
value = GetVariable(pset.vars, varname);
|
|
|
|
if (!value)
|
|
|
|
return NULL;
|
|
|
|
|
Allow psql variable substitution to occur in backtick command strings.
Previously, text between backquotes in a psql metacommand's arguments
was always passed to the shell literally. That considerably hobbles
the usefulness of the feature for scripting, so we'd foreseen for a long
time that we'd someday want to allow substitution of psql variables into
the shell command. IMO the addition of \if metacommands has brought us to
that point, since \if can greatly benefit from some sort of client-side
expression evaluation capability, and psql itself is not going to grow any
such thing in time for v10. Hence, this patch. It allows :VARIABLE to be
replaced by the exact contents of the named variable, while :'VARIABLE'
is replaced by the variable's contents suitably quoted to become a single
shell-command argument. (The quoting rules for that are different from
those for SQL literals, so this is a bit of an abuse of the :'VARIABLE'
notation, but I doubt anyone will be confused.)
As with other situations in psql, no substitution occurs if the word
following a colon is not a known variable name. That limits the risk of
compatibility problems for existing psql scripts; but the risk isn't zero,
so this needs to be called out in the v10 release notes.
Discussion: https://postgr.es/m/9561.1490895211@sss.pgh.pa.us
2017-04-02 03:44:54 +02:00
|
|
|
switch (quote)
|
2016-03-18 20:05:49 +01:00
|
|
|
{
|
Allow psql variable substitution to occur in backtick command strings.
Previously, text between backquotes in a psql metacommand's arguments
was always passed to the shell literally. That considerably hobbles
the usefulness of the feature for scripting, so we'd foreseen for a long
time that we'd someday want to allow substitution of psql variables into
the shell command. IMO the addition of \if metacommands has brought us to
that point, since \if can greatly benefit from some sort of client-side
expression evaluation capability, and psql itself is not going to grow any
such thing in time for v10. Hence, this patch. It allows :VARIABLE to be
replaced by the exact contents of the named variable, while :'VARIABLE'
is replaced by the variable's contents suitably quoted to become a single
shell-command argument. (The quoting rules for that are different from
those for SQL literals, so this is a bit of an abuse of the :'VARIABLE'
notation, but I doubt anyone will be confused.)
As with other situations in psql, no substitution occurs if the word
following a colon is not a known variable name. That limits the risk of
compatibility problems for existing psql scripts; but the risk isn't zero,
so this needs to be called out in the v10 release notes.
Discussion: https://postgr.es/m/9561.1490895211@sss.pgh.pa.us
2017-04-02 03:44:54 +02:00
|
|
|
case PQUOTE_PLAIN:
|
|
|
|
result = pg_strdup(value);
|
|
|
|
break;
|
|
|
|
case PQUOTE_SQL_LITERAL:
|
|
|
|
case PQUOTE_SQL_IDENT:
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* For these cases, we use libpq's quoting functions, which
|
|
|
|
* assume the string is in the connection's client encoding.
|
|
|
|
*/
|
|
|
|
char *escaped_value;
|
|
|
|
|
|
|
|
if (!pset.db)
|
|
|
|
{
|
|
|
|
psql_error("cannot escape without active connection\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (quote == PQUOTE_SQL_LITERAL)
|
|
|
|
escaped_value =
|
|
|
|
PQescapeLiteral(pset.db, value, strlen(value));
|
|
|
|
else
|
|
|
|
escaped_value =
|
|
|
|
PQescapeIdentifier(pset.db, value, strlen(value));
|
|
|
|
|
|
|
|
if (escaped_value == NULL)
|
|
|
|
{
|
|
|
|
const char *error = PQerrorMessage(pset.db);
|
|
|
|
|
|
|
|
psql_error("%s", error);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rather than complicate the lexer's API with a notion of
|
|
|
|
* which free() routine to use, just pay the price of an extra
|
|
|
|
* strdup().
|
|
|
|
*/
|
|
|
|
result = pg_strdup(escaped_value);
|
|
|
|
PQfreemem(escaped_value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PQUOTE_SHELL_ARG:
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* For this we use appendShellStringNoError, which is
|
|
|
|
* encoding-agnostic, which is fine since the shell probably
|
|
|
|
* is too. In any case, the only special character is "'",
|
|
|
|
* which is not known to appear in valid multibyte characters.
|
|
|
|
*/
|
|
|
|
PQExpBufferData buf;
|
|
|
|
|
|
|
|
initPQExpBuffer(&buf);
|
|
|
|
if (!appendShellStringNoError(&buf, value))
|
|
|
|
{
|
|
|
|
psql_error("shell command argument contains a newline or carriage return: \"%s\"\n",
|
|
|
|
value);
|
|
|
|
free(buf.data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
result = buf.data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No default: we want a compiler warning for missing cases */
|
2016-03-18 20:05:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-01-19 00:30:24 +01:00
|
|
|
/*
|
|
|
|
* Error reporting for scripts. Errors should look like
|
2000-04-12 19:17:23 +02:00
|
|
|
* psql:filename:lineno: message
|
2000-01-19 00:30:24 +01:00
|
|
|
*/
|
|
|
|
void
|
2005-10-15 04:49:52 +02:00
|
|
|
psql_error(const char *fmt,...)
|
2000-01-19 00:30:24 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
va_list ap;
|
2000-01-19 00:30:24 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
fflush(stdout);
|
2012-08-26 04:58:42 +02:00
|
|
|
if (pset.queryFout && pset.queryFout != stdout)
|
2000-04-12 19:17:23 +02:00
|
|
|
fflush(pset.queryFout);
|
2000-01-19 00:30:24 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
if (pset.inputfile)
|
2006-08-11 21:20:59 +02:00
|
|
|
fprintf(stderr, "%s:%s:" UINT64_FORMAT ": ", pset.progname, pset.inputfile, pset.lineno);
|
2000-04-12 19:17:23 +02:00
|
|
|
va_start(ap, fmt);
|
2005-02-22 05:43:23 +01:00
|
|
|
vfprintf(stderr, _(fmt), ap);
|
2000-04-12 19:17:23 +02:00
|
|
|
va_end(ap);
|
2000-01-19 00:30:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-02-08 00:10:11 +01:00
|
|
|
|
|
|
|
/*
|
2003-03-10 23:28:22 +01:00
|
|
|
* for backend Notice messages (INFO, WARNING, etc)
|
2000-02-08 00:10:11 +01:00
|
|
|
*/
|
2000-01-19 00:30:24 +01:00
|
|
|
void
|
2000-04-12 19:17:23 +02:00
|
|
|
NoticeProcessor(void *arg, const char *message)
|
2000-01-19 00:30:24 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
(void) arg; /* not used */
|
|
|
|
psql_error("%s", message);
|
2000-01-19 00:30:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-11-04 22:56:02 +01:00
|
|
|
/*
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
* Code to support query cancellation
|
1999-11-04 22:56:02 +01:00
|
|
|
*
|
2006-06-14 18:49:03 +02:00
|
|
|
* Before we start a query, we enable the SIGINT signal catcher to send a
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
* cancel request to the backend. Note that sending the cancel directly from
|
2004-10-31 01:11:27 +02:00
|
|
|
* the signal handler is safe because PQcancel() is written to make it
|
2006-06-14 18:49:03 +02:00
|
|
|
* so. We use write() to report to stderr because it's better to use simple
|
2000-02-08 00:10:11 +01:00
|
|
|
* facilities in a signal handler.
|
2004-10-31 01:11:27 +02:00
|
|
|
*
|
2011-06-29 08:26:14 +02:00
|
|
|
* On win32, the signal canceling happens on a separate thread, because
|
2004-10-31 01:11:27 +02:00
|
|
|
* that's how SetConsoleCtrlHandler works. The PQcancel function is safe
|
|
|
|
* for this (unlike PQrequestCancel). However, a CRITICAL_SECTION is required
|
2006-06-14 18:49:03 +02:00
|
|
|
* to protect the PGcancel structure against being changed while the signal
|
2004-10-31 01:11:27 +02:00
|
|
|
* thread is using it.
|
2006-06-14 18:49:03 +02:00
|
|
|
*
|
|
|
|
* SIGINT is supposed to abort all long-running psql operations, not only
|
|
|
|
* database queries. In most places, this is accomplished by checking
|
|
|
|
* cancel_pressed during long-running loops. However, that won't work when
|
|
|
|
* blocked on user input (in readline() or fgets()). In those places, we
|
2017-08-16 06:22:32 +02:00
|
|
|
* set sigint_interrupt_enabled true while blocked, instructing the signal
|
2006-06-14 18:49:03 +02:00
|
|
|
* catcher to longjmp through sigint_interrupt_jmp. We assume readline and
|
|
|
|
* fgets are coded to handle possible interruption. (XXX currently this does
|
|
|
|
* not work on win32, so control-C is less useful there)
|
1999-11-04 22:56:02 +01:00
|
|
|
*/
|
2006-06-14 18:49:03 +02:00
|
|
|
volatile bool sigint_interrupt_enabled = false;
|
|
|
|
|
|
|
|
sigjmp_buf sigint_interrupt_jmp;
|
|
|
|
|
2006-10-04 02:30:14 +02:00
|
|
|
static PGcancel *volatile cancelConn = NULL;
|
2005-10-15 04:49:52 +02:00
|
|
|
|
2004-10-31 01:11:27 +02:00
|
|
|
#ifdef WIN32
|
|
|
|
static CRITICAL_SECTION cancelConnLock;
|
|
|
|
#endif
|
2003-03-20 07:00:12 +01:00
|
|
|
|
2016-06-03 17:29:20 +02:00
|
|
|
/*
|
|
|
|
* Write a simple string to stderr --- must be safe in a signal handler.
|
|
|
|
* We ignore the write() result since there's not much we could do about it.
|
|
|
|
* Certain compilers make that harder than it ought to be.
|
|
|
|
*/
|
|
|
|
#define write_stderr(str) \
|
|
|
|
do { \
|
|
|
|
const char *str_ = (str); \
|
|
|
|
int rc_; \
|
|
|
|
rc_ = write(fileno(stderr), str_, strlen(str_)); \
|
|
|
|
(void) rc_; \
|
|
|
|
} while (0)
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2000-03-05 14:30:20 +01:00
|
|
|
|
2004-10-31 01:11:27 +02:00
|
|
|
#ifndef WIN32
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
static void
|
2000-08-29 11:36:51 +02:00
|
|
|
handle_sigint(SIGNAL_ARGS)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
2000-12-18 18:33:42 +01:00
|
|
|
int save_errno = errno;
|
2005-10-15 04:49:52 +02:00
|
|
|
char errbuf[256];
|
2000-12-18 18:33:42 +01:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
/* if we are waiting for input, longjmp out of it */
|
|
|
|
if (sigint_interrupt_enabled)
|
|
|
|
{
|
|
|
|
sigint_interrupt_enabled = false;
|
|
|
|
siglongjmp(sigint_interrupt_jmp, 1);
|
|
|
|
}
|
2000-02-20 15:28:28 +01:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
/* else, set cancel flag to stop any long-running loops */
|
2000-04-12 19:17:23 +02:00
|
|
|
cancel_pressed = true;
|
2000-03-01 22:10:05 +01:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
/* and send QueryCancel if we are processing a database query */
|
|
|
|
if (cancelConn != NULL)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2006-06-14 18:49:03 +02:00
|
|
|
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
|
2016-06-03 17:29:20 +02:00
|
|
|
write_stderr("Cancel request sent\n");
|
2006-06-14 18:49:03 +02:00
|
|
|
else
|
|
|
|
{
|
2016-06-03 17:29:20 +02:00
|
|
|
write_stderr("Could not send cancel request: ");
|
|
|
|
write_stderr(errbuf);
|
2006-06-14 18:49:03 +02:00
|
|
|
}
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
2006-06-14 18:49:03 +02:00
|
|
|
|
2000-12-18 18:33:42 +01:00
|
|
|
errno = save_errno; /* just in case the write changed it */
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
2006-06-14 18:49:03 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
setup_cancel_handler(void)
|
|
|
|
{
|
|
|
|
pqsignal(SIGINT, handle_sigint);
|
|
|
|
}
|
2005-10-15 04:49:52 +02:00
|
|
|
#else /* WIN32 */
|
2004-10-31 01:11:27 +02:00
|
|
|
|
|
|
|
static BOOL WINAPI
|
|
|
|
consoleHandler(DWORD dwCtrlType)
|
|
|
|
{
|
2005-10-15 04:49:52 +02:00
|
|
|
char errbuf[256];
|
2004-10-31 01:11:27 +02:00
|
|
|
|
|
|
|
if (dwCtrlType == CTRL_C_EVENT ||
|
|
|
|
dwCtrlType == CTRL_BREAK_EVENT)
|
|
|
|
{
|
2006-06-14 18:49:03 +02:00
|
|
|
/*
|
|
|
|
* Can't longjmp here, because we are in wrong thread :-(
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* set cancel flag to stop any long-running loops */
|
|
|
|
cancel_pressed = true;
|
2004-10-31 01:11:27 +02:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
/* and send QueryCancel if we are processing a database query */
|
2004-10-31 01:11:27 +02:00
|
|
|
EnterCriticalSection(&cancelConnLock);
|
|
|
|
if (cancelConn != NULL)
|
|
|
|
{
|
|
|
|
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
|
|
|
|
write_stderr("Cancel request sent\n");
|
|
|
|
else
|
|
|
|
{
|
|
|
|
write_stderr("Could not send cancel request: ");
|
|
|
|
write_stderr(errbuf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
LeaveCriticalSection(&cancelConnLock);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
/* Return FALSE for any signals not being handled */
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2004-11-01 20:21:50 +01:00
|
|
|
void
|
|
|
|
setup_cancel_handler(void)
|
|
|
|
{
|
2006-06-14 18:49:03 +02:00
|
|
|
InitializeCriticalSection(&cancelConnLock);
|
2005-11-04 19:35:40 +01:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
SetConsoleCtrlHandler(consoleHandler, TRUE);
|
2004-10-31 01:11:27 +02:00
|
|
|
}
|
Phase 2 of pgindent updates.
Change pg_bsd_indent to follow upstream rules for placement of comments
to the right of code, and remove pgindent hack that caused comments
following #endif to not obey the general rule.
Commit e3860ffa4dd0dad0dd9eea4be9cc1412373a8c89 wasn't actually using
the published version of pg_bsd_indent, but a hacked-up version that
tried to minimize the amount of movement of comments to the right of
code. The situation of interest is where such a comment has to be
moved to the right of its default placement at column 33 because there's
code there. BSD indent has always moved right in units of tab stops
in such cases --- but in the previous incarnation, indent was working
in 8-space tab stops, while now it knows we use 4-space tabs. So the
net result is that in about half the cases, such comments are placed
one tab stop left of before. This is better all around: it leaves
more room on the line for comment text, and it means that in such
cases the comment uniformly starts at the next 4-space tab stop after
the code, rather than sometimes one and sometimes two tabs after.
Also, ensure that comments following #endif are indented the same
as comments following other preprocessor commands such as #else.
That inconsistency turns out to have been self-inflicted damage
from a poorly-thought-through post-indent "fixup" in pgindent.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:18:54 +02:00
|
|
|
#endif /* WIN32 */
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
/* ConnectionUp
|
|
|
|
*
|
|
|
|
* Returns whether our backend connection is still there.
|
|
|
|
*/
|
2003-08-04 02:43:34 +02:00
|
|
|
static bool
|
2004-10-11 01:37:45 +02:00
|
|
|
ConnectionUp(void)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
|
|
|
return PQstatus(pset.db) != CONNECTION_BAD;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* CheckConnection
|
|
|
|
*
|
|
|
|
* Verify that we still have a good connection to the backend, and if not,
|
|
|
|
* see if it can be restored.
|
|
|
|
*
|
|
|
|
* Returns true if either the connection was still there, or it could be
|
2014-05-06 18:12:18 +02:00
|
|
|
* restored successfully; false otherwise. If, however, there was no
|
2003-03-20 07:00:12 +01:00
|
|
|
* connection and the session is non-interactive, this will exit the program
|
|
|
|
* with a code of EXIT_BADCONN.
|
|
|
|
*/
|
|
|
|
static bool
|
2003-08-04 21:10:40 +02:00
|
|
|
CheckConnection(void)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
bool OK;
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
OK = ConnectionUp();
|
|
|
|
if (!OK)
|
|
|
|
{
|
|
|
|
if (!pset.cur_cmd_interactive)
|
|
|
|
{
|
|
|
|
psql_error("connection to server was lost\n");
|
|
|
|
exit(EXIT_BADCONN);
|
|
|
|
}
|
|
|
|
|
2012-08-26 04:58:42 +02:00
|
|
|
psql_error("The connection to the server was lost. Attempting reset: ");
|
2003-03-20 07:00:12 +01:00
|
|
|
PQreset(pset.db);
|
|
|
|
OK = ConnectionUp();
|
|
|
|
if (!OK)
|
|
|
|
{
|
2012-08-26 04:58:42 +02:00
|
|
|
psql_error("Failed.\n");
|
2003-03-20 07:00:12 +01:00
|
|
|
PQfinish(pset.db);
|
|
|
|
pset.db = NULL;
|
|
|
|
ResetCancelConn();
|
2003-06-28 02:12:40 +02:00
|
|
|
UnsyncVariables();
|
2003-03-20 07:00:12 +01:00
|
|
|
}
|
|
|
|
else
|
2012-08-26 04:58:42 +02:00
|
|
|
psql_error("Succeeded.\n");
|
2003-03-20 07:00:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SetCancelConn
|
|
|
|
*
|
|
|
|
* Set cancelConn to point to the current database connection.
|
|
|
|
*/
|
2006-06-14 18:49:03 +02:00
|
|
|
void
|
2003-08-04 02:43:34 +02:00
|
|
|
SetCancelConn(void)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
2006-10-04 02:30:14 +02:00
|
|
|
PGcancel *oldCancelConn;
|
2006-06-14 18:49:03 +02:00
|
|
|
|
2004-10-31 01:11:27 +02:00
|
|
|
#ifdef WIN32
|
|
|
|
EnterCriticalSection(&cancelConnLock);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Free the old one if we have one */
|
2006-06-14 18:49:03 +02:00
|
|
|
oldCancelConn = cancelConn;
|
|
|
|
/* be sure handle_sigint doesn't use pointer while freeing */
|
|
|
|
cancelConn = NULL;
|
|
|
|
|
|
|
|
if (oldCancelConn != NULL)
|
|
|
|
PQfreeCancel(oldCancelConn);
|
2004-10-31 01:11:27 +02:00
|
|
|
|
|
|
|
cancelConn = PQgetCancel(pset.db);
|
|
|
|
|
|
|
|
#ifdef WIN32
|
|
|
|
LeaveCriticalSection(&cancelConnLock);
|
|
|
|
#endif
|
2003-03-20 07:00:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ResetCancelConn
|
|
|
|
*
|
2004-10-31 01:11:27 +02:00
|
|
|
* Free the current cancel connection, if any, and set to NULL.
|
2003-03-20 07:00:12 +01:00
|
|
|
*/
|
2003-08-04 02:43:34 +02:00
|
|
|
void
|
|
|
|
ResetCancelConn(void)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
2006-10-04 02:30:14 +02:00
|
|
|
PGcancel *oldCancelConn;
|
2006-06-14 18:49:03 +02:00
|
|
|
|
2004-10-31 01:11:27 +02:00
|
|
|
#ifdef WIN32
|
|
|
|
EnterCriticalSection(&cancelConnLock);
|
|
|
|
#endif
|
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
oldCancelConn = cancelConn;
|
|
|
|
/* be sure handle_sigint doesn't use pointer while freeing */
|
2003-08-04 02:43:34 +02:00
|
|
|
cancelConn = NULL;
|
2004-10-31 01:11:27 +02:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
if (oldCancelConn != NULL)
|
|
|
|
PQfreeCancel(oldCancelConn);
|
|
|
|
|
2004-10-31 01:11:27 +02:00
|
|
|
#ifdef WIN32
|
|
|
|
LeaveCriticalSection(&cancelConnLock);
|
|
|
|
#endif
|
2003-03-20 07:00:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AcceptResult
|
|
|
|
*
|
|
|
|
* Checks whether a result is valid, giving an error message if necessary;
|
2006-08-30 00:25:08 +02:00
|
|
|
* and ensures that the connection to the backend is still up.
|
2003-03-20 07:00:12 +01:00
|
|
|
*
|
|
|
|
* Returns true for valid result, false for error state.
|
|
|
|
*/
|
|
|
|
static bool
|
2006-08-30 00:25:08 +02:00
|
|
|
AcceptResult(const PGresult *result)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
2012-01-25 22:06:00 +01:00
|
|
|
bool OK;
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
if (!result)
|
2003-08-04 02:43:34 +02:00
|
|
|
OK = false;
|
|
|
|
else
|
|
|
|
switch (PQresultStatus(result))
|
|
|
|
{
|
|
|
|
case PGRES_COMMAND_OK:
|
|
|
|
case PGRES_TUPLES_OK:
|
2003-11-12 23:53:16 +01:00
|
|
|
case PGRES_EMPTY_QUERY:
|
2003-08-04 02:43:34 +02:00
|
|
|
case PGRES_COPY_IN:
|
|
|
|
case PGRES_COPY_OUT:
|
2006-06-14 18:49:03 +02:00
|
|
|
/* Fine, do nothing */
|
2012-01-25 22:06:00 +01:00
|
|
|
OK = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PGRES_BAD_RESPONSE:
|
|
|
|
case PGRES_NONFATAL_ERROR:
|
|
|
|
case PGRES_FATAL_ERROR:
|
|
|
|
OK = false;
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
OK = false;
|
2012-07-02 20:12:46 +02:00
|
|
|
psql_error("unexpected PQresultStatus: %d\n",
|
2012-01-25 22:06:00 +01:00
|
|
|
PQresultStatus(result));
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
if (!OK)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
2005-10-13 22:58:42 +02:00
|
|
|
const char *error = PQerrorMessage(pset.db);
|
2005-10-15 04:49:52 +02:00
|
|
|
|
2005-10-13 22:58:42 +02:00
|
|
|
if (strlen(error))
|
|
|
|
psql_error("%s", error);
|
|
|
|
|
2003-08-04 21:10:40 +02:00
|
|
|
CheckConnection();
|
2003-03-20 07:00:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-09-13 01:27:48 +02:00
|
|
|
/*
|
|
|
|
* Set special variables from a query result
|
|
|
|
* - ERROR: true/false, whether an error occurred on this query
|
|
|
|
* - SQLSTATE: code of error, or "00000" if no error, or "" if unknown
|
|
|
|
* - ROW_COUNT: how many rows were returned or affected, or "0"
|
|
|
|
* - LAST_ERROR_SQLSTATE: same for last error
|
|
|
|
* - LAST_ERROR_MESSAGE: message of last error
|
|
|
|
*
|
|
|
|
* Note: current policy is to apply this only to the results of queries
|
|
|
|
* entered by the user, not queries generated by slash commands.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
SetResultVariables(PGresult *results, bool success)
|
|
|
|
{
|
|
|
|
if (success)
|
|
|
|
{
|
|
|
|
const char *ntuples = PQcmdTuples(results);
|
|
|
|
|
|
|
|
SetVariable(pset.vars, "ERROR", "false");
|
|
|
|
SetVariable(pset.vars, "SQLSTATE", "00000");
|
|
|
|
SetVariable(pset.vars, "ROW_COUNT", *ntuples ? ntuples : "0");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const char *code = PQresultErrorField(results, PG_DIAG_SQLSTATE);
|
|
|
|
const char *mesg = PQresultErrorField(results, PG_DIAG_MESSAGE_PRIMARY);
|
|
|
|
|
|
|
|
SetVariable(pset.vars, "ERROR", "true");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there is no SQLSTATE code, use an empty string. This can happen
|
|
|
|
* for libpq-detected errors (e.g., lost connection, ENOMEM).
|
|
|
|
*/
|
|
|
|
if (code == NULL)
|
|
|
|
code = "";
|
|
|
|
SetVariable(pset.vars, "SQLSTATE", code);
|
|
|
|
SetVariable(pset.vars, "ROW_COUNT", "0");
|
|
|
|
SetVariable(pset.vars, "LAST_ERROR_SQLSTATE", code);
|
|
|
|
SetVariable(pset.vars, "LAST_ERROR_MESSAGE", mesg ? mesg : "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-04-03 18:29:55 +02:00
|
|
|
/*
|
|
|
|
* ClearOrSaveResult
|
|
|
|
*
|
|
|
|
* If the result represents an error, remember it for possible display by
|
|
|
|
* \errverbose. Otherwise, just PQclear() it.
|
2017-09-13 01:27:48 +02:00
|
|
|
*
|
|
|
|
* Note: current policy is to apply this to the results of all queries,
|
|
|
|
* including "back door" queries, for debugging's sake. It's OK to use
|
|
|
|
* PQclear() directly on results known to not be error results, however.
|
2016-04-03 18:29:55 +02:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ClearOrSaveResult(PGresult *result)
|
|
|
|
{
|
|
|
|
if (result)
|
|
|
|
{
|
|
|
|
switch (PQresultStatus(result))
|
|
|
|
{
|
|
|
|
case PGRES_NONFATAL_ERROR:
|
|
|
|
case PGRES_FATAL_ERROR:
|
|
|
|
if (pset.last_error_result)
|
|
|
|
PQclear(pset.last_error_result);
|
|
|
|
pset.last_error_result = result;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
PQclear(result);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
|
2016-09-03 21:29:03 +02:00
|
|
|
/*
|
|
|
|
* Print microtiming output. Always print raw milliseconds; if the interval
|
|
|
|
* is >= 1 second, also break it down into days/hours/minutes/seconds.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
PrintTiming(double elapsed_msec)
|
|
|
|
{
|
|
|
|
double seconds;
|
|
|
|
double minutes;
|
|
|
|
double hours;
|
|
|
|
double days;
|
|
|
|
|
|
|
|
if (elapsed_msec < 1000.0)
|
|
|
|
{
|
|
|
|
/* This is the traditional (pre-v10) output format */
|
|
|
|
printf(_("Time: %.3f ms\n"), elapsed_msec);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: we could print just seconds, in a format like %06.3f, when the
|
|
|
|
* total is less than 1min. But that's hard to interpret unless we tack
|
|
|
|
* on "s" or otherwise annotate it. Forcing the display to include
|
|
|
|
* minutes seems like a better solution.
|
|
|
|
*/
|
|
|
|
seconds = elapsed_msec / 1000.0;
|
|
|
|
minutes = floor(seconds / 60.0);
|
|
|
|
seconds -= 60.0 * minutes;
|
|
|
|
if (minutes < 60.0)
|
|
|
|
{
|
|
|
|
printf(_("Time: %.3f ms (%02d:%06.3f)\n"),
|
|
|
|
elapsed_msec, (int) minutes, seconds);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
hours = floor(minutes / 60.0);
|
|
|
|
minutes -= 60.0 * hours;
|
|
|
|
if (hours < 24.0)
|
|
|
|
{
|
|
|
|
printf(_("Time: %.3f ms (%02d:%02d:%06.3f)\n"),
|
|
|
|
elapsed_msec, (int) hours, (int) minutes, seconds);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
days = floor(hours / 24.0);
|
|
|
|
hours -= 24.0 * days;
|
|
|
|
printf(_("Time: %.3f ms (%.0f d %02d:%02d:%06.3f)\n"),
|
|
|
|
elapsed_msec, days, (int) hours, (int) minutes, seconds);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
/*
|
|
|
|
* PSQLexec
|
1999-11-04 22:56:02 +01:00
|
|
|
*
|
|
|
|
* This is the way to send "backdoor" queries (those not directly entered
|
2000-01-14 23:18:03 +01:00
|
|
|
* by the user). It is subject to -E but not -e.
|
2002-10-15 04:24:16 +02:00
|
|
|
*
|
2006-03-04 00:38:30 +01:00
|
|
|
* Caller is responsible for handling the ensuing processing if a COPY
|
|
|
|
* command is sent.
|
|
|
|
*
|
2003-09-16 19:59:02 +02:00
|
|
|
* Note: we don't bother to check PQclientEncoding; it is assumed that no
|
|
|
|
* caller uses this path to issue "SET CLIENT_ENCODING".
|
1999-11-04 22:56:02 +01:00
|
|
|
*/
|
2001-10-25 07:50:21 +02:00
|
|
|
PGresult *
|
2014-10-23 15:33:56 +02:00
|
|
|
PSQLexec(const char *query)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
2003-06-28 02:12:40 +02:00
|
|
|
PGresult *res;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
if (!pset.db)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
psql_error("You are currently not connected to a database.\n");
|
1999-11-05 00:14:30 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-08-29 17:19:51 +02:00
|
|
|
if (pset.echo_hidden != PSQL_ECHO_HIDDEN_OFF)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2005-10-04 21:01:18 +02:00
|
|
|
printf(_("********* QUERY **********\n"
|
|
|
|
"%s\n"
|
|
|
|
"**************************\n\n"), query);
|
1999-11-05 00:14:30 +01:00
|
|
|
fflush(stdout);
|
2005-06-14 04:57:45 +02:00
|
|
|
if (pset.logfile)
|
|
|
|
{
|
2005-10-04 21:01:18 +02:00
|
|
|
fprintf(pset.logfile,
|
|
|
|
_("********* QUERY **********\n"
|
|
|
|
"%s\n"
|
|
|
|
"**************************\n\n"), query);
|
2005-06-14 04:57:45 +02:00
|
|
|
fflush(pset.logfile);
|
|
|
|
}
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2006-08-29 17:19:51 +02:00
|
|
|
if (pset.echo_hidden == PSQL_ECHO_HIDDEN_NOEXEC)
|
2003-06-28 02:12:40 +02:00
|
|
|
return NULL;
|
2003-03-20 07:43:35 +01:00
|
|
|
}
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
SetCancelConn();
|
|
|
|
|
2003-06-28 02:12:40 +02:00
|
|
|
res = PQexec(pset.db, query);
|
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
ResetCancelConn();
|
|
|
|
|
|
|
|
if (!AcceptResult(res))
|
2003-02-19 04:54:39 +01:00
|
|
|
{
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(res);
|
2003-03-20 07:00:12 +01:00
|
|
|
res = NULL;
|
2003-06-28 02:12:40 +02:00
|
|
|
}
|
2003-02-19 04:54:39 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
return res;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-09-04 05:31:48 +02:00
|
|
|
/*
|
|
|
|
* PSQLexecWatch
|
|
|
|
*
|
|
|
|
* This function is used for \watch command to send the query to
|
|
|
|
* the server and print out the results.
|
|
|
|
*
|
|
|
|
* Returns 1 if the query executed successfully, 0 if it cannot be repeated,
|
|
|
|
* e.g., because of the interrupt, -1 on error.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
PSQLexecWatch(const char *query, const printQueryOpt *opt)
|
|
|
|
{
|
|
|
|
PGresult *res;
|
2015-05-24 03:35:49 +02:00
|
|
|
double elapsed_msec = 0;
|
2014-09-04 05:31:48 +02:00
|
|
|
instr_time before;
|
|
|
|
instr_time after;
|
|
|
|
|
|
|
|
if (!pset.db)
|
|
|
|
{
|
|
|
|
psql_error("You are currently not connected to a database.\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
SetCancelConn();
|
|
|
|
|
|
|
|
if (pset.timing)
|
|
|
|
INSTR_TIME_SET_CURRENT(before);
|
|
|
|
|
|
|
|
res = PQexec(pset.db, query);
|
|
|
|
|
|
|
|
ResetCancelConn();
|
|
|
|
|
|
|
|
if (!AcceptResult(res))
|
|
|
|
{
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(res);
|
2014-09-04 05:31:48 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pset.timing)
|
|
|
|
{
|
|
|
|
INSTR_TIME_SET_CURRENT(after);
|
|
|
|
INSTR_TIME_SUBTRACT(after, before);
|
|
|
|
elapsed_msec = INSTR_TIME_GET_MILLISEC(after);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-05-24 03:35:49 +02:00
|
|
|
* If SIGINT is sent while the query is processing, the interrupt will be
|
|
|
|
* consumed. The user's intention, though, is to cancel the entire watch
|
|
|
|
* process, so detect a sent cancellation request and exit in this case.
|
2014-09-04 05:31:48 +02:00
|
|
|
*/
|
|
|
|
if (cancel_pressed)
|
|
|
|
{
|
|
|
|
PQclear(res);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (PQresultStatus(res))
|
|
|
|
{
|
|
|
|
case PGRES_TUPLES_OK:
|
Fix behavior of printTable() and friends with externally-invoked pager.
The formatting modes that depend on knowledge of the terminal window width
did not work right when printing a query result that's been fetched in
sections (as a result of FETCH_SIZE). ExecQueryUsingCursor() would force
use of the pager as soon as there's more than one result section, and then
print.c would see an output file pointer that's not stdout and incorrectly
conclude that the terminal window width isn't relevant.
This has been broken all along for non-expanded "wrapped" output format,
and as of 9.5 the issue affects expanded mode as well. The problem also
caused "\pset expanded auto" mode to invariably *not* switch to expanded
output in a segmented result, which seems to me to be exactly backwards.
To fix, we need to pass down an "is_pager" flag to inform the print.c
subroutines that some calling level has already replaced stdout with a
pager pipe, so they should (a) not do that again and (b) nonetheless honor
the window size. (Notably, this makes the first is_pager test in
print_aligned_text() not be dead code anymore.)
This patch is a bit invasive because there are so many existing calls of
printQuery()/printTable(), but fortunately all but a couple can just pass
"false" for the added parameter.
Back-patch to 9.5 but no further. Given the lack of field complaints,
it's not clear that we should change the behavior in stable branches.
Also, the API change for printQuery()/printTable() might possibly break
third-party code, again something we don't like to do in stable branches.
However, it's not quite too late to do this in 9.5, and with the larger
scope of the problem there, it seems worth doing.
2015-12-03 00:20:33 +01:00
|
|
|
printQuery(res, opt, pset.queryFout, false, pset.logfile);
|
2014-09-04 05:31:48 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PGRES_COMMAND_OK:
|
|
|
|
fprintf(pset.queryFout, "%s\n%s\n\n", opt->title, PQcmdStatus(res));
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PGRES_EMPTY_QUERY:
|
2018-12-29 12:50:59 +01:00
|
|
|
psql_error("\\watch cannot be used with an empty query\n");
|
2014-09-04 05:31:48 +02:00
|
|
|
PQclear(res);
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
case PGRES_COPY_OUT:
|
|
|
|
case PGRES_COPY_IN:
|
|
|
|
case PGRES_COPY_BOTH:
|
2018-12-29 12:50:59 +01:00
|
|
|
psql_error("\\watch cannot be used with COPY\n");
|
2014-09-04 05:31:48 +02:00
|
|
|
PQclear(res);
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
default:
|
2018-12-29 12:50:59 +01:00
|
|
|
psql_error("unexpected result status for \\watch\n");
|
2014-09-04 05:31:48 +02:00
|
|
|
PQclear(res);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
fflush(pset.queryFout);
|
|
|
|
|
|
|
|
/* Possible microtiming output */
|
|
|
|
if (pset.timing)
|
2016-09-03 21:29:03 +02:00
|
|
|
PrintTiming(elapsed_msec);
|
2014-09-04 05:31:48 +02:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
1999-11-04 22:56:02 +01:00
|
|
|
|
|
|
|
/*
|
2003-03-20 07:00:12 +01:00
|
|
|
* PrintNotifications: check for asynchronous notifications, and print them out
|
1999-11-04 22:56:02 +01:00
|
|
|
*/
|
2003-03-20 07:00:12 +01:00
|
|
|
static void
|
|
|
|
PrintNotifications(void)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
2003-02-21 22:34:27 +01:00
|
|
|
PGnotify *notify;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2018-10-20 04:22:57 +02:00
|
|
|
PQconsumeInput(pset.db);
|
|
|
|
while ((notify = PQnotifies(pset.db)) != NULL)
|
2000-04-12 19:17:23 +02:00
|
|
|
{
|
2010-02-16 23:34:57 +01:00
|
|
|
/* for backward compatibility, only show payload if nonempty */
|
|
|
|
if (notify->extra[0])
|
|
|
|
fprintf(pset.queryFout, _("Asynchronous notification \"%s\" with payload \"%s\" received from server process with PID %d.\n"),
|
|
|
|
notify->relname, notify->extra, notify->be_pid);
|
|
|
|
else
|
|
|
|
fprintf(pset.queryFout, _("Asynchronous notification \"%s\" received from server process with PID %d.\n"),
|
|
|
|
notify->relname, notify->be_pid);
|
2003-03-20 07:00:12 +01:00
|
|
|
fflush(pset.queryFout);
|
2003-09-16 19:59:02 +02:00
|
|
|
PQfreemem(notify);
|
2018-10-20 04:22:57 +02:00
|
|
|
PQconsumeInput(pset.db);
|
2000-04-12 19:17:23 +02:00
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
}
|
1999-11-04 22:56:02 +01:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
/*
|
|
|
|
* PrintQueryTuples: assuming query result is OK, print its tuples
|
|
|
|
*
|
|
|
|
* Returns true if successful, false otherwise.
|
|
|
|
*/
|
2003-08-04 02:43:34 +02:00
|
|
|
static bool
|
2003-03-20 07:00:12 +01:00
|
|
|
PrintQueryTuples(const PGresult *results)
|
|
|
|
{
|
2005-06-13 08:36:22 +02:00
|
|
|
printQueryOpt my_popt = pset.popt;
|
|
|
|
|
2017-03-07 15:31:52 +01:00
|
|
|
/* one-shot expanded output requested via \gx */
|
|
|
|
if (pset.g_expanded)
|
|
|
|
my_popt.topt.expanded = 1;
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
/* write output to \g argument, if any */
|
|
|
|
if (pset.gfname)
|
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
FILE *fout;
|
|
|
|
bool is_pipe;
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
if (!openQueryOutputFile(pset.gfname, &fout, &is_pipe))
|
2003-03-20 07:00:12 +01:00
|
|
|
return false;
|
2015-12-03 20:28:58 +01:00
|
|
|
if (is_pipe)
|
|
|
|
disable_sigpipe_trap();
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
printQuery(results, &my_popt, fout, false, pset.logfile);
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
if (is_pipe)
|
|
|
|
{
|
|
|
|
pclose(fout);
|
|
|
|
restore_sigpipe_trap();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fclose(fout);
|
2003-08-04 02:43:34 +02:00
|
|
|
}
|
|
|
|
else
|
Fix behavior of printTable() and friends with externally-invoked pager.
The formatting modes that depend on knowledge of the terminal window width
did not work right when printing a query result that's been fetched in
sections (as a result of FETCH_SIZE). ExecQueryUsingCursor() would force
use of the pager as soon as there's more than one result section, and then
print.c would see an output file pointer that's not stdout and incorrectly
conclude that the terminal window width isn't relevant.
This has been broken all along for non-expanded "wrapped" output format,
and as of 9.5 the issue affects expanded mode as well. The problem also
caused "\pset expanded auto" mode to invariably *not* switch to expanded
output in a segmented result, which seems to me to be exactly backwards.
To fix, we need to pass down an "is_pager" flag to inform the print.c
subroutines that some calling level has already replaced stdout with a
pager pipe, so they should (a) not do that again and (b) nonetheless honor
the window size. (Notably, this makes the first is_pager test in
print_aligned_text() not be dead code anymore.)
This patch is a bit invasive because there are so many existing calls of
printQuery()/printTable(), but fortunately all but a couple can just pass
"false" for the added parameter.
Back-patch to 9.5 but no further. Given the lack of field complaints,
it's not clear that we should change the behavior in stable branches.
Also, the API change for printQuery()/printTable() might possibly break
third-party code, again something we don't like to do in stable branches.
However, it's not quite too late to do this in 9.5, and with the larger
scope of the problem there, it seems worth doing.
2015-12-03 00:20:33 +01:00
|
|
|
printQuery(results, &my_popt, pset.queryFout, false, pset.logfile);
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-02 23:06:38 +01:00
|
|
|
/*
|
|
|
|
* StoreQueryTuple: assuming query result is OK, save data into variables
|
|
|
|
*
|
|
|
|
* Returns true if successful, false otherwise.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
StoreQueryTuple(const PGresult *result)
|
|
|
|
{
|
|
|
|
bool success = true;
|
|
|
|
|
|
|
|
if (PQntuples(result) < 1)
|
|
|
|
{
|
|
|
|
psql_error("no rows returned for \\gset\n");
|
|
|
|
success = false;
|
|
|
|
}
|
|
|
|
else if (PQntuples(result) > 1)
|
|
|
|
{
|
|
|
|
psql_error("more than one row returned for \\gset\n");
|
|
|
|
success = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < PQnfields(result); i++)
|
|
|
|
{
|
|
|
|
char *colname = PQfname(result, i);
|
|
|
|
char *varname;
|
|
|
|
char *value;
|
|
|
|
|
2017-02-06 10:33:58 +01:00
|
|
|
/* concatenate prefix and column name */
|
2013-10-23 01:40:26 +02:00
|
|
|
varname = psprintf("%s%s", pset.gset_prefix, colname);
|
2013-02-02 23:06:38 +01:00
|
|
|
|
|
|
|
if (!PQgetisnull(result, 0, i))
|
|
|
|
value = PQgetvalue(result, 0, i);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* for NULL value, unset rather than set the variable */
|
|
|
|
value = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!SetVariable(pset.vars, varname, value))
|
|
|
|
{
|
|
|
|
free(varname);
|
|
|
|
success = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(varname);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
/*
|
|
|
|
* ExecQueryTuples: assuming query result is OK, execute each query
|
|
|
|
* result field as a SQL statement
|
|
|
|
*
|
|
|
|
* Returns true if successful, false otherwise.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
ExecQueryTuples(const PGresult *result)
|
|
|
|
{
|
|
|
|
bool success = true;
|
|
|
|
int nrows = PQntuples(result);
|
|
|
|
int ncolumns = PQnfields(result);
|
|
|
|
int r,
|
|
|
|
c;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We must turn off gexec_flag to avoid infinite recursion. Note that
|
|
|
|
* this allows ExecQueryUsingCursor to be applied to the individual query
|
|
|
|
* results. SendQuery prevents it from being applied when fetching the
|
|
|
|
* queries-to-execute, because it can't handle recursion either.
|
|
|
|
*/
|
|
|
|
pset.gexec_flag = false;
|
|
|
|
|
|
|
|
for (r = 0; r < nrows; r++)
|
|
|
|
{
|
|
|
|
for (c = 0; c < ncolumns; c++)
|
|
|
|
{
|
|
|
|
if (!PQgetisnull(result, r, c))
|
|
|
|
{
|
|
|
|
const char *query = PQgetvalue(result, r, c);
|
|
|
|
|
|
|
|
/* Abandon execution if cancel_pressed */
|
|
|
|
if (cancel_pressed)
|
|
|
|
goto loop_exit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ECHO_ALL mode should echo these queries, but SendQuery
|
|
|
|
* assumes that MainLoop did that, so we have to do it here.
|
|
|
|
*/
|
|
|
|
if (pset.echo == PSQL_ECHO_ALL && !pset.singlestep)
|
|
|
|
{
|
|
|
|
puts(query);
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!SendQuery(query))
|
|
|
|
{
|
|
|
|
/* Error - abandon execution if ON_ERROR_STOP */
|
|
|
|
success = false;
|
|
|
|
if (pset.on_error_stop)
|
|
|
|
goto loop_exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
loop_exit:
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Restore state. We know gexec_flag was on, else we'd not be here. (We
|
|
|
|
* also know it'll get turned off at end of command, but that's not ours
|
|
|
|
* to do here.)
|
|
|
|
*/
|
|
|
|
pset.gexec_flag = true;
|
|
|
|
|
|
|
|
/* Return true if all queries were successful */
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
/*
|
2012-01-25 22:06:00 +01:00
|
|
|
* ProcessResult: utility function for use by SendQuery() only
|
2003-03-20 07:00:12 +01:00
|
|
|
*
|
2012-01-25 22:06:00 +01:00
|
|
|
* When our command string contained a COPY FROM STDIN or COPY TO STDOUT,
|
|
|
|
* PQexec() has stopped at the PGresult associated with the first such
|
|
|
|
* command. In that event, we'll marshal data for the COPY and then cycle
|
|
|
|
* through any subsequent PGresult objects.
|
2003-03-20 07:00:12 +01:00
|
|
|
*
|
2014-03-10 20:47:06 +01:00
|
|
|
* When the command string contained no such COPY command, this function
|
2012-01-25 22:06:00 +01:00
|
|
|
* degenerates to an AcceptResult() call.
|
|
|
|
*
|
|
|
|
* Changes its argument to point to the last PGresult of the command string,
|
2014-03-13 18:49:03 +01:00
|
|
|
* or NULL if that result was for a COPY TO STDOUT. (Returning NULL prevents
|
|
|
|
* the command status from being printed, which we want in that case so that
|
|
|
|
* the status line doesn't get taken as part of the COPY data.)
|
2012-01-25 22:06:00 +01:00
|
|
|
*
|
|
|
|
* Returns true on complete success, false otherwise. Possible failure modes
|
|
|
|
* include purely client-side problems; check the transaction status for the
|
|
|
|
* server-side opinion.
|
2003-03-20 07:00:12 +01:00
|
|
|
*/
|
|
|
|
static bool
|
2012-01-25 22:06:00 +01:00
|
|
|
ProcessResult(PGresult **results)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
2012-01-25 22:06:00 +01:00
|
|
|
bool success = true;
|
|
|
|
bool first_cycle = true;
|
2003-03-20 07:00:12 +01:00
|
|
|
|
2014-03-13 18:49:03 +01:00
|
|
|
for (;;)
|
2003-03-20 07:00:12 +01:00
|
|
|
{
|
2012-01-25 22:06:00 +01:00
|
|
|
ExecStatusType result_status;
|
|
|
|
bool is_copy;
|
2014-03-13 18:49:03 +01:00
|
|
|
PGresult *next_result;
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2012-01-25 22:06:00 +01:00
|
|
|
if (!AcceptResult(*results))
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Failure at this point is always a server-side failure or a
|
|
|
|
* failure to submit the command string. Either way, we're
|
|
|
|
* finished with this command string.
|
|
|
|
*/
|
|
|
|
success = false;
|
2003-10-06 03:11:12 +02:00
|
|
|
break;
|
2012-01-25 22:06:00 +01:00
|
|
|
}
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2012-01-25 22:06:00 +01:00
|
|
|
result_status = PQresultStatus(*results);
|
|
|
|
switch (result_status)
|
|
|
|
{
|
|
|
|
case PGRES_EMPTY_QUERY:
|
|
|
|
case PGRES_COMMAND_OK:
|
|
|
|
case PGRES_TUPLES_OK:
|
|
|
|
is_copy = false;
|
|
|
|
break;
|
|
|
|
|
2012-04-04 22:15:04 +02:00
|
|
|
case PGRES_COPY_OUT:
|
|
|
|
case PGRES_COPY_IN:
|
|
|
|
is_copy = true;
|
|
|
|
break;
|
|
|
|
|
2012-01-25 22:06:00 +01:00
|
|
|
default:
|
|
|
|
/* AcceptResult() should have caught anything else. */
|
|
|
|
is_copy = false;
|
2012-07-02 20:12:46 +02:00
|
|
|
psql_error("unexpected PQresultStatus: %d\n", result_status);
|
2012-01-25 22:06:00 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_copy)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Marshal the COPY data. Either subroutine will get the
|
|
|
|
* connection out of its COPY state, then call PQresultStatus()
|
|
|
|
* once and report any error.
|
2014-03-10 20:47:06 +01:00
|
|
|
*
|
|
|
|
* If pset.copyStream is set, use that as data source/sink,
|
|
|
|
* otherwise use queryFout or cur_cmd_source as appropriate.
|
2012-01-25 22:06:00 +01:00
|
|
|
*/
|
2014-03-10 20:47:06 +01:00
|
|
|
FILE *copystream = pset.copyStream;
|
2014-03-13 18:49:03 +01:00
|
|
|
PGresult *copy_result;
|
2014-03-10 20:47:06 +01:00
|
|
|
|
2006-06-14 18:49:03 +02:00
|
|
|
SetCancelConn();
|
2012-01-25 22:06:00 +01:00
|
|
|
if (result_status == PGRES_COPY_OUT)
|
2014-03-10 20:47:06 +01:00
|
|
|
{
|
|
|
|
if (!copystream)
|
|
|
|
copystream = pset.queryFout;
|
|
|
|
success = handleCopyOut(pset.db,
|
2014-03-13 18:49:03 +01:00
|
|
|
copystream,
|
|
|
|
©_result) && success;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Suppress status printing if the report would go to the same
|
|
|
|
* place as the COPY data just went. Note this doesn't
|
|
|
|
* prevent error reporting, since handleCopyOut did that.
|
|
|
|
*/
|
|
|
|
if (copystream == pset.queryFout)
|
|
|
|
{
|
|
|
|
PQclear(copy_result);
|
|
|
|
copy_result = NULL;
|
|
|
|
}
|
2014-03-10 20:47:06 +01:00
|
|
|
}
|
2012-01-25 22:06:00 +01:00
|
|
|
else
|
2014-03-10 20:47:06 +01:00
|
|
|
{
|
|
|
|
if (!copystream)
|
|
|
|
copystream = pset.cur_cmd_source;
|
|
|
|
success = handleCopyIn(pset.db,
|
|
|
|
copystream,
|
2014-03-13 18:49:03 +01:00
|
|
|
PQbinaryTuples(*results),
|
|
|
|
©_result) && success;
|
2014-03-10 20:47:06 +01:00
|
|
|
}
|
2006-06-14 18:49:03 +02:00
|
|
|
ResetCancelConn();
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2012-01-25 22:06:00 +01:00
|
|
|
/*
|
2014-03-13 18:49:03 +01:00
|
|
|
* Replace the PGRES_COPY_OUT/IN result with COPY command's exit
|
|
|
|
* status, or with NULL if we want to suppress printing anything.
|
2012-01-25 22:06:00 +01:00
|
|
|
*/
|
|
|
|
PQclear(*results);
|
2014-03-13 18:49:03 +01:00
|
|
|
*results = copy_result;
|
2012-01-25 22:06:00 +01:00
|
|
|
}
|
|
|
|
else if (first_cycle)
|
2014-03-13 18:49:03 +01:00
|
|
|
{
|
2012-01-25 22:06:00 +01:00
|
|
|
/* fast path: no COPY commands; PQexec visited all results */
|
2003-10-06 03:11:12 +02:00
|
|
|
break;
|
2012-01-25 22:06:00 +01:00
|
|
|
}
|
|
|
|
|
2014-03-13 18:49:03 +01:00
|
|
|
/*
|
|
|
|
* Check PQgetResult() again. In the typical case of a single-command
|
|
|
|
* string, it will return NULL. Otherwise, we'll have other results
|
|
|
|
* to process that may include other COPYs. We keep the last result.
|
|
|
|
*/
|
|
|
|
next_result = PQgetResult(pset.db);
|
|
|
|
if (!next_result)
|
|
|
|
break;
|
|
|
|
|
|
|
|
PQclear(*results);
|
|
|
|
*results = next_result;
|
2012-01-25 22:06:00 +01:00
|
|
|
first_cycle = false;
|
2014-03-13 18:49:03 +01:00
|
|
|
}
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2017-09-13 01:27:48 +02:00
|
|
|
SetResultVariables(*results, success);
|
|
|
|
|
2003-10-06 03:11:12 +02:00
|
|
|
/* may need this to recover from conn loss during COPY */
|
2012-03-07 22:56:42 +01:00
|
|
|
if (!first_cycle && !CheckConnection())
|
2003-10-06 03:11:12 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-08-13 23:10:04 +02:00
|
|
|
/*
|
|
|
|
* PrintQueryStatus: report command status as required
|
|
|
|
*
|
|
|
|
* Note: Utility function for use by PrintQueryResults() only.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
PrintQueryStatus(PGresult *results)
|
|
|
|
{
|
|
|
|
char buf[16];
|
|
|
|
|
2006-08-29 17:19:51 +02:00
|
|
|
if (!pset.quiet)
|
2006-08-13 23:10:04 +02:00
|
|
|
{
|
|
|
|
if (pset.popt.topt.format == PRINT_HTML)
|
|
|
|
{
|
|
|
|
fputs("<p>", pset.queryFout);
|
|
|
|
html_escaped_print(PQcmdStatus(results), pset.queryFout);
|
|
|
|
fputs("</p>\n", pset.queryFout);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fprintf(pset.queryFout, "%s\n", PQcmdStatus(results));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pset.logfile)
|
|
|
|
fprintf(pset.logfile, "%s\n", PQcmdStatus(results));
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "%u", (unsigned int) PQoidValue(results));
|
|
|
|
SetVariable(pset.vars, "LASTOID", buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-06 03:11:12 +02:00
|
|
|
/*
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
* PrintQueryResults: print out (or store or execute) query results as required
|
2003-10-06 03:11:12 +02:00
|
|
|
*
|
|
|
|
* Note: Utility function for use by SendQuery() only.
|
|
|
|
*
|
|
|
|
* Returns true if the query executed successfully, false otherwise.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
PrintQueryResults(PGresult *results)
|
|
|
|
{
|
2012-01-25 22:06:00 +01:00
|
|
|
bool success;
|
2006-08-13 23:10:04 +02:00
|
|
|
const char *cmdstatus;
|
2003-10-06 03:11:12 +02:00
|
|
|
|
|
|
|
if (!results)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (PQresultStatus(results))
|
|
|
|
{
|
|
|
|
case PGRES_TUPLES_OK:
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
/* store or execute or print the data ... */
|
2013-02-02 23:06:38 +01:00
|
|
|
if (pset.gset_prefix)
|
|
|
|
success = StoreQueryTuple(results);
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
else if (pset.gexec_flag)
|
|
|
|
success = ExecQueryTuples(results);
|
2016-04-09 01:23:18 +02:00
|
|
|
else if (pset.crosstab_flag)
|
|
|
|
success = PrintResultsInCrosstab(results);
|
2013-02-02 23:06:38 +01:00
|
|
|
else
|
|
|
|
success = PrintQueryTuples(results);
|
2015-05-23 00:49:27 +02:00
|
|
|
/* if it's INSERT/UPDATE/DELETE RETURNING, also print status */
|
2006-08-13 23:10:04 +02:00
|
|
|
cmdstatus = PQcmdStatus(results);
|
|
|
|
if (strncmp(cmdstatus, "INSERT", 6) == 0 ||
|
|
|
|
strncmp(cmdstatus, "UPDATE", 6) == 0 ||
|
|
|
|
strncmp(cmdstatus, "DELETE", 6) == 0)
|
|
|
|
PrintQueryStatus(results);
|
2003-10-06 03:11:12 +02:00
|
|
|
break;
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
case PGRES_COMMAND_OK:
|
2006-08-13 23:10:04 +02:00
|
|
|
PrintQueryStatus(results);
|
|
|
|
success = true;
|
|
|
|
break;
|
2003-10-06 03:11:12 +02:00
|
|
|
|
|
|
|
case PGRES_EMPTY_QUERY:
|
|
|
|
success = true;
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
2002-03-05 01:01:03 +01:00
|
|
|
|
2003-10-06 03:11:12 +02:00
|
|
|
case PGRES_COPY_OUT:
|
2003-08-04 02:43:34 +02:00
|
|
|
case PGRES_COPY_IN:
|
2003-10-06 03:11:12 +02:00
|
|
|
/* nothing to do here */
|
|
|
|
success = true;
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2012-01-25 22:06:00 +01:00
|
|
|
case PGRES_BAD_RESPONSE:
|
|
|
|
case PGRES_NONFATAL_ERROR:
|
|
|
|
case PGRES_FATAL_ERROR:
|
|
|
|
success = false;
|
|
|
|
break;
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
default:
|
2012-01-25 22:06:00 +01:00
|
|
|
success = false;
|
2012-07-02 20:12:46 +02:00
|
|
|
psql_error("unexpected PQresultStatus: %d\n",
|
2012-01-25 22:06:00 +01:00
|
|
|
PQresultStatus(results));
|
2003-08-04 02:43:34 +02:00
|
|
|
break;
|
|
|
|
}
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
fflush(pset.queryFout);
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SendQuery: send the query string to the backend
|
|
|
|
* (and print out results)
|
|
|
|
*
|
|
|
|
* Note: This is the "front door" way to send a query. That is, use it to
|
|
|
|
* send queries actually entered by the user. These queries will be subject to
|
|
|
|
* single step mode.
|
|
|
|
* To send "back door" queries (generated by slash commands, etc.) in a
|
|
|
|
* controlled way, use PSQLexec().
|
|
|
|
*
|
|
|
|
* Returns true if the query executed successfully, false otherwise.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
SendQuery(const char *query)
|
|
|
|
{
|
2005-10-15 04:49:52 +02:00
|
|
|
PGresult *results;
|
2006-08-30 00:25:08 +02:00
|
|
|
PGTransactionStatusType transaction_status;
|
|
|
|
double elapsed_msec = 0;
|
2013-02-02 20:21:24 +01:00
|
|
|
bool OK = false;
|
2016-04-15 04:54:26 +02:00
|
|
|
int i;
|
2013-02-02 20:21:24 +01:00
|
|
|
bool on_error_rollback_savepoint = false;
|
2005-10-15 04:49:52 +02:00
|
|
|
static bool on_error_rollback_warning = false;
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
if (!pset.db)
|
2003-03-20 07:43:35 +01:00
|
|
|
{
|
2003-03-20 07:00:12 +01:00
|
|
|
psql_error("You are currently not connected to a database.\n");
|
2013-02-02 20:21:24 +01:00
|
|
|
goto sendquery_cleanup;
|
2003-03-20 07:43:35 +01:00
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
|
2006-08-29 17:19:51 +02:00
|
|
|
if (pset.singlestep)
|
2003-03-20 07:43:35 +01:00
|
|
|
{
|
2003-03-20 07:00:12 +01:00
|
|
|
char buf[3];
|
|
|
|
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
fflush(stderr);
|
2005-02-22 05:43:23 +01:00
|
|
|
printf(_("***(Single step mode: verify command)*******************************************\n"
|
2005-10-15 04:49:52 +02:00
|
|
|
"%s\n"
|
|
|
|
"***(press return to proceed or enter x and return to cancel)********************\n"),
|
2003-03-20 07:00:12 +01:00
|
|
|
query);
|
|
|
|
fflush(stdout);
|
|
|
|
if (fgets(buf, sizeof(buf), stdin) != NULL)
|
|
|
|
if (buf[0] == 'x')
|
2013-02-02 20:21:24 +01:00
|
|
|
goto sendquery_cleanup;
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
if (cancel_pressed)
|
|
|
|
goto sendquery_cleanup;
|
2003-02-21 22:34:27 +01:00
|
|
|
}
|
2006-08-29 17:19:51 +02:00
|
|
|
else if (pset.echo == PSQL_ECHO_QUERIES)
|
2003-07-31 06:23:40 +02:00
|
|
|
{
|
2003-03-20 07:43:35 +01:00
|
|
|
puts(query);
|
2003-07-31 06:23:40 +02:00
|
|
|
fflush(stdout);
|
|
|
|
}
|
2003-08-04 02:43:34 +02:00
|
|
|
|
2005-06-14 04:57:45 +02:00
|
|
|
if (pset.logfile)
|
|
|
|
{
|
2005-10-04 21:01:18 +02:00
|
|
|
fprintf(pset.logfile,
|
|
|
|
_("********* QUERY **********\n"
|
|
|
|
"%s\n"
|
|
|
|
"**************************\n\n"), query);
|
2005-06-14 04:57:45 +02:00
|
|
|
fflush(pset.logfile);
|
|
|
|
}
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
SetCancelConn();
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2005-04-28 15:09:59 +02:00
|
|
|
transaction_status = PQtransactionStatus(pset.db);
|
|
|
|
|
|
|
|
if (transaction_status == PQTRANS_IDLE &&
|
2006-08-29 17:19:51 +02:00
|
|
|
!pset.autocommit &&
|
2004-09-20 20:51:19 +02:00
|
|
|
!command_no_begin(query))
|
2003-06-28 02:12:40 +02:00
|
|
|
{
|
|
|
|
results = PQexec(pset.db, "BEGIN");
|
|
|
|
if (PQresultStatus(results) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2003-06-28 02:12:40 +02:00
|
|
|
ResetCancelConn();
|
2013-02-02 20:21:24 +01:00
|
|
|
goto sendquery_cleanup;
|
2003-06-28 02:12:40 +02:00
|
|
|
}
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2005-09-20 23:43:08 +02:00
|
|
|
transaction_status = PQtransactionStatus(pset.db);
|
2003-06-28 02:12:40 +02:00
|
|
|
}
|
2005-09-20 23:43:08 +02:00
|
|
|
|
|
|
|
if (transaction_status == PQTRANS_INTRANS &&
|
2006-08-29 17:19:51 +02:00
|
|
|
pset.on_error_rollback != PSQL_ERROR_ROLLBACK_OFF &&
|
2005-09-20 23:43:08 +02:00
|
|
|
(pset.cur_cmd_interactive ||
|
2006-08-29 17:19:51 +02:00
|
|
|
pset.on_error_rollback == PSQL_ERROR_ROLLBACK_ON))
|
2005-04-28 15:09:59 +02:00
|
|
|
{
|
|
|
|
if (on_error_rollback_warning == false && pset.sversion < 80000)
|
|
|
|
{
|
Fix assorted places in psql to print version numbers >= 10 in new style.
This is somewhat cosmetic, since as long as you know what you are looking
at, "10.0" is a serviceable substitute for "10". But there is a potential
for confusion between version numbers with minor numbers and those without
--- we don't want people asking "why is psql saying 10.0 when my server is
10.2". Therefore, back-patch as far as practical, which turns out to be
9.3. I could have redone the patch to use fprintf(stderr) in place of
psql_error(), but it seems more work than is warranted for branches that
will be EOL or nearly so by the time v10 comes out.
Although only psql seems to contain any code that needs this, I chose
to put the support function into fe_utils, since it seems likely we'll
need it in other client programs in future. (In 9.3-9.5, use dumputils.c,
the predecessor of fe_utils/string_utils.c.)
In HEAD, also fix the backend code that whines about loadable-library
version mismatch. I don't see much need to back-patch that.
2016-08-16 21:58:30 +02:00
|
|
|
char sverbuf[32];
|
|
|
|
|
|
|
|
psql_error("The server (version %s) does not support savepoints for ON_ERROR_ROLLBACK.\n",
|
|
|
|
formatPGVersionNumber(pset.sversion, false,
|
|
|
|
sverbuf, sizeof(sverbuf)));
|
2005-04-28 15:09:59 +02:00
|
|
|
on_error_rollback_warning = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
results = PQexec(pset.db, "SAVEPOINT pg_psql_temporary_savepoint");
|
|
|
|
if (PQresultStatus(results) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2005-04-28 15:09:59 +02:00
|
|
|
ResetCancelConn();
|
2013-02-02 20:21:24 +01:00
|
|
|
goto sendquery_cleanup;
|
2005-04-28 15:09:59 +02:00
|
|
|
}
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2005-04-28 15:09:59 +02:00
|
|
|
on_error_rollback_savepoint = true;
|
|
|
|
}
|
|
|
|
}
|
2003-06-28 02:12:40 +02:00
|
|
|
|
2017-09-06 00:17:47 +02:00
|
|
|
if (pset.gdesc_flag)
|
|
|
|
{
|
|
|
|
/* Describe query's result columns, without executing it */
|
|
|
|
OK = DescribeQuery(query, &elapsed_msec);
|
|
|
|
ResetCancelConn();
|
|
|
|
results = NULL; /* PQclear(NULL) does nothing */
|
|
|
|
}
|
|
|
|
else if (pset.fetch_count <= 0 || pset.gexec_flag ||
|
|
|
|
pset.crosstab_flag || !is_select_command(query))
|
2006-08-30 00:25:08 +02:00
|
|
|
{
|
|
|
|
/* Default fetch-it-all-and-print mode */
|
2008-05-14 21:10:29 +02:00
|
|
|
instr_time before,
|
2006-10-04 02:30:14 +02:00
|
|
|
after;
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
if (pset.timing)
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(before);
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
results = PQexec(pset.db, query);
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
/* these operations are included in the timing result: */
|
|
|
|
ResetCancelConn();
|
2012-01-25 22:06:00 +01:00
|
|
|
OK = ProcessResult(&results);
|
2003-03-20 07:00:12 +01:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
if (pset.timing)
|
|
|
|
{
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(after);
|
|
|
|
INSTR_TIME_SUBTRACT(after, before);
|
|
|
|
elapsed_msec = INSTR_TIME_GET_MILLISEC(after);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* but printing results isn't: */
|
2012-01-25 22:06:00 +01:00
|
|
|
if (OK && results)
|
2006-08-30 00:25:08 +02:00
|
|
|
OK = PrintQueryResults(results);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Fetch-in-segments mode */
|
|
|
|
OK = ExecQueryUsingCursor(query, &elapsed_msec);
|
|
|
|
ResetCancelConn();
|
|
|
|
results = NULL; /* PQclear(NULL) does nothing */
|
|
|
|
}
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2014-07-10 07:27:54 +02:00
|
|
|
if (!OK && pset.echo == PSQL_ECHO_ERRORS)
|
|
|
|
psql_error("STATEMENT: %s\n", query);
|
|
|
|
|
2005-04-28 15:09:59 +02:00
|
|
|
/* If we made a temporary savepoint, possibly release/rollback */
|
|
|
|
if (on_error_rollback_savepoint)
|
|
|
|
{
|
2012-01-25 22:06:00 +01:00
|
|
|
const char *svptcmd = NULL;
|
2006-06-30 17:06:05 +02:00
|
|
|
|
2005-04-28 15:09:59 +02:00
|
|
|
transaction_status = PQtransactionStatus(pset.db);
|
|
|
|
|
2012-01-25 22:06:00 +01:00
|
|
|
switch (transaction_status)
|
2008-08-16 03:36:35 +02:00
|
|
|
{
|
2012-01-25 22:06:00 +01:00
|
|
|
case PQTRANS_INERROR:
|
|
|
|
/* We always rollback on an error */
|
|
|
|
svptcmd = "ROLLBACK TO pg_psql_temporary_savepoint";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PQTRANS_IDLE:
|
|
|
|
/* If they are no longer in a transaction, then do nothing */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PQTRANS_INTRANS:
|
2012-06-10 21:20:04 +02:00
|
|
|
|
2012-01-25 22:06:00 +01:00
|
|
|
/*
|
|
|
|
* Do nothing if they are messing with savepoints themselves:
|
2012-06-10 21:20:04 +02:00
|
|
|
* If the user did RELEASE or ROLLBACK, our savepoint is gone.
|
|
|
|
* If they issued a SAVEPOINT, releasing ours would remove
|
|
|
|
* theirs.
|
2012-01-25 22:06:00 +01:00
|
|
|
*/
|
|
|
|
if (results &&
|
|
|
|
(strcmp(PQcmdStatus(results), "SAVEPOINT") == 0 ||
|
|
|
|
strcmp(PQcmdStatus(results), "RELEASE") == 0 ||
|
|
|
|
strcmp(PQcmdStatus(results), "ROLLBACK") == 0))
|
|
|
|
svptcmd = NULL;
|
|
|
|
else
|
|
|
|
svptcmd = "RELEASE pg_psql_temporary_savepoint";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PQTRANS_ACTIVE:
|
|
|
|
case PQTRANS_UNKNOWN:
|
|
|
|
default:
|
|
|
|
OK = false;
|
2012-03-07 22:56:42 +01:00
|
|
|
/* PQTRANS_UNKNOWN is expected given a broken connection. */
|
|
|
|
if (transaction_status != PQTRANS_UNKNOWN || ConnectionUp())
|
|
|
|
psql_error("unexpected transaction status (%d)\n",
|
|
|
|
transaction_status);
|
2012-01-25 22:06:00 +01:00
|
|
|
break;
|
2005-04-28 15:09:59 +02:00
|
|
|
}
|
2008-08-16 03:36:35 +02:00
|
|
|
|
|
|
|
if (svptcmd)
|
2005-04-28 15:09:59 +02:00
|
|
|
{
|
2008-08-16 03:36:35 +02:00
|
|
|
PGresult *svptres;
|
|
|
|
|
|
|
|
svptres = PQexec(pset.db, svptcmd);
|
|
|
|
if (PQresultStatus(svptres) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(svptres);
|
2013-02-02 20:21:24 +01:00
|
|
|
OK = false;
|
2008-08-16 03:36:35 +02:00
|
|
|
|
|
|
|
PQclear(results);
|
|
|
|
ResetCancelConn();
|
2013-02-02 20:21:24 +01:00
|
|
|
goto sendquery_cleanup;
|
2008-08-16 03:36:35 +02:00
|
|
|
}
|
2006-06-30 17:06:05 +02:00
|
|
|
PQclear(svptres);
|
2005-04-28 15:09:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2006-06-30 17:06:05 +02:00
|
|
|
|
2003-10-06 03:11:12 +02:00
|
|
|
/* Possible microtiming output */
|
2012-01-18 10:32:54 +01:00
|
|
|
if (pset.timing)
|
2016-09-03 21:29:03 +02:00
|
|
|
PrintTiming(elapsed_msec);
|
2003-10-06 03:11:12 +02:00
|
|
|
|
2003-09-16 19:59:02 +02:00
|
|
|
/* check for events that may occur during query execution */
|
|
|
|
|
|
|
|
if (pset.encoding != PQclientEncoding(pset.db) &&
|
|
|
|
PQclientEncoding(pset.db) >= 0)
|
|
|
|
{
|
|
|
|
/* track effects of SET CLIENT_ENCODING */
|
|
|
|
pset.encoding = PQclientEncoding(pset.db);
|
|
|
|
pset.popt.topt.encoding = pset.encoding;
|
|
|
|
SetVariable(pset.vars, "ENCODING",
|
|
|
|
pg_encoding_to_char(pset.encoding));
|
|
|
|
}
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
PrintNotifications();
|
2003-09-16 19:59:02 +02:00
|
|
|
|
2013-02-02 20:21:24 +01:00
|
|
|
/* perform cleanup that should occur after any attempted query */
|
|
|
|
|
|
|
|
sendquery_cleanup:
|
|
|
|
|
|
|
|
/* reset \g's output-to-filename trigger */
|
|
|
|
if (pset.gfname)
|
|
|
|
{
|
|
|
|
free(pset.gfname);
|
|
|
|
pset.gfname = NULL;
|
|
|
|
}
|
|
|
|
|
2017-03-07 15:31:52 +01:00
|
|
|
/* reset \gx's expanded-mode flag */
|
|
|
|
pset.g_expanded = false;
|
|
|
|
|
2013-02-02 23:06:38 +01:00
|
|
|
/* reset \gset trigger */
|
|
|
|
if (pset.gset_prefix)
|
|
|
|
{
|
|
|
|
free(pset.gset_prefix);
|
|
|
|
pset.gset_prefix = NULL;
|
|
|
|
}
|
|
|
|
|
2017-09-06 00:17:47 +02:00
|
|
|
/* reset \gdesc trigger */
|
|
|
|
pset.gdesc_flag = false;
|
|
|
|
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
/* reset \gexec trigger */
|
|
|
|
pset.gexec_flag = false;
|
|
|
|
|
2016-04-09 01:23:18 +02:00
|
|
|
/* reset \crosstabview trigger */
|
|
|
|
pset.crosstab_flag = false;
|
2016-04-15 04:54:26 +02:00
|
|
|
for (i = 0; i < lengthof(pset.ctv_args); i++)
|
2016-04-09 01:23:18 +02:00
|
|
|
{
|
2016-04-15 04:54:26 +02:00
|
|
|
pg_free(pset.ctv_args[i]);
|
|
|
|
pset.ctv_args[i] = NULL;
|
2016-04-09 01:23:18 +02:00
|
|
|
}
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
return OK;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
2003-03-20 07:43:35 +01:00
|
|
|
|
2004-09-20 20:51:19 +02:00
|
|
|
|
2017-09-06 00:17:47 +02:00
|
|
|
/*
|
|
|
|
* DescribeQuery: describe the result columns of a query, without executing it
|
|
|
|
*
|
|
|
|
* Returns true if the operation executed successfully, false otherwise.
|
|
|
|
*
|
|
|
|
* If pset.timing is on, total query time (exclusive of result-printing) is
|
|
|
|
* stored into *elapsed_msec.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
DescribeQuery(const char *query, double *elapsed_msec)
|
|
|
|
{
|
|
|
|
PGresult *results;
|
|
|
|
bool OK;
|
|
|
|
instr_time before,
|
|
|
|
after;
|
|
|
|
|
|
|
|
*elapsed_msec = 0;
|
|
|
|
|
|
|
|
if (pset.timing)
|
|
|
|
INSTR_TIME_SET_CURRENT(before);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To parse the query but not execute it, we prepare it, using the unnamed
|
|
|
|
* prepared statement. This is invisible to psql users, since there's no
|
|
|
|
* way to access the unnamed prepared statement from psql user space. The
|
|
|
|
* next Parse or Query protocol message would overwrite the statement
|
|
|
|
* anyway. (So there's no great need to clear it when done, which is a
|
|
|
|
* good thing because libpq provides no easy way to do that.)
|
|
|
|
*/
|
|
|
|
results = PQprepare(pset.db, "", query, 0, NULL);
|
|
|
|
if (PQresultStatus(results) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
2017-09-13 01:27:48 +02:00
|
|
|
SetResultVariables(results, false);
|
2017-09-06 00:17:47 +02:00
|
|
|
ClearOrSaveResult(results);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
PQclear(results);
|
|
|
|
|
|
|
|
results = PQdescribePrepared(pset.db, "");
|
|
|
|
OK = AcceptResult(results) &&
|
|
|
|
(PQresultStatus(results) == PGRES_COMMAND_OK);
|
|
|
|
if (OK && results)
|
|
|
|
{
|
|
|
|
if (PQnfields(results) > 0)
|
|
|
|
{
|
|
|
|
PQExpBufferData buf;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
initPQExpBuffer(&buf);
|
|
|
|
|
|
|
|
printfPQExpBuffer(&buf,
|
|
|
|
"SELECT name AS \"%s\", pg_catalog.format_type(tp, tpm) AS \"%s\"\n"
|
|
|
|
"FROM (VALUES ",
|
|
|
|
gettext_noop("Column"),
|
|
|
|
gettext_noop("Type"));
|
|
|
|
|
|
|
|
for (i = 0; i < PQnfields(results); i++)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
char *escname;
|
|
|
|
|
|
|
|
if (i > 0)
|
|
|
|
appendPQExpBufferStr(&buf, ",");
|
|
|
|
|
|
|
|
name = PQfname(results, i);
|
|
|
|
escname = PQescapeLiteral(pset.db, name, strlen(name));
|
|
|
|
|
|
|
|
if (escname == NULL)
|
|
|
|
{
|
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
|
|
|
PQclear(results);
|
|
|
|
termPQExpBuffer(&buf);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
appendPQExpBuffer(&buf, "(%s, '%u'::pg_catalog.oid, %d)",
|
|
|
|
escname,
|
|
|
|
PQftype(results, i),
|
|
|
|
PQfmod(results, i));
|
|
|
|
|
|
|
|
PQfreemem(escname);
|
|
|
|
}
|
|
|
|
|
|
|
|
appendPQExpBufferStr(&buf, ") s(name, tp, tpm)");
|
|
|
|
PQclear(results);
|
|
|
|
|
|
|
|
results = PQexec(pset.db, buf.data);
|
|
|
|
OK = AcceptResult(results);
|
|
|
|
|
|
|
|
if (pset.timing)
|
|
|
|
{
|
|
|
|
INSTR_TIME_SET_CURRENT(after);
|
|
|
|
INSTR_TIME_SUBTRACT(after, before);
|
|
|
|
*elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (OK && results)
|
|
|
|
OK = PrintQueryResults(results);
|
|
|
|
|
|
|
|
termPQExpBuffer(&buf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fprintf(pset.queryFout,
|
|
|
|
_("The command has no result, or the result has no columns.\n"));
|
|
|
|
}
|
|
|
|
|
2017-09-13 01:27:48 +02:00
|
|
|
SetResultVariables(results, OK);
|
2017-09-06 00:17:47 +02:00
|
|
|
ClearOrSaveResult(results);
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
/*
|
|
|
|
* ExecQueryUsingCursor: run a SELECT-like query using a cursor
|
|
|
|
*
|
|
|
|
* This feature allows result sets larger than RAM to be dealt with.
|
|
|
|
*
|
|
|
|
* Returns true if the query executed successfully, false otherwise.
|
|
|
|
*
|
|
|
|
* If pset.timing is on, total query time (exclusive of result-printing) is
|
|
|
|
* stored into *elapsed_msec.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
ExecQueryUsingCursor(const char *query, double *elapsed_msec)
|
|
|
|
{
|
|
|
|
bool OK = true;
|
2006-10-04 02:30:14 +02:00
|
|
|
PGresult *results;
|
|
|
|
PQExpBufferData buf;
|
2006-08-30 00:25:08 +02:00
|
|
|
printQueryOpt my_popt = pset.popt;
|
2015-12-03 20:28:58 +01:00
|
|
|
FILE *fout;
|
|
|
|
bool is_pipe;
|
|
|
|
bool is_pager = false;
|
2006-10-04 02:30:14 +02:00
|
|
|
bool started_txn = false;
|
2017-09-13 01:27:48 +02:00
|
|
|
int64 total_tuples = 0;
|
2006-10-04 02:30:14 +02:00
|
|
|
int ntuples;
|
2013-02-02 23:06:38 +01:00
|
|
|
int fetch_count;
|
2006-10-04 02:30:14 +02:00
|
|
|
char fetch_cmd[64];
|
2008-05-14 21:10:29 +02:00
|
|
|
instr_time before,
|
2006-10-04 02:30:14 +02:00
|
|
|
after;
|
2010-05-28 22:02:32 +02:00
|
|
|
int flush_error;
|
2006-08-30 00:25:08 +02:00
|
|
|
|
|
|
|
*elapsed_msec = 0;
|
|
|
|
|
|
|
|
/* initialize print options for partial table output */
|
|
|
|
my_popt.topt.start_table = true;
|
|
|
|
my_popt.topt.stop_table = false;
|
|
|
|
my_popt.topt.prior_records = 0;
|
|
|
|
|
|
|
|
if (pset.timing)
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(before);
|
2006-08-30 00:25:08 +02:00
|
|
|
|
|
|
|
/* if we're not in a transaction, start one */
|
|
|
|
if (PQtransactionStatus(pset.db) == PQTRANS_IDLE)
|
|
|
|
{
|
|
|
|
results = PQexec(pset.db, "BEGIN");
|
|
|
|
OK = AcceptResult(results) &&
|
|
|
|
(PQresultStatus(results) == PGRES_COMMAND_OK);
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2006-08-30 00:25:08 +02:00
|
|
|
if (!OK)
|
|
|
|
return false;
|
|
|
|
started_txn = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send DECLARE CURSOR */
|
|
|
|
initPQExpBuffer(&buf);
|
|
|
|
appendPQExpBuffer(&buf, "DECLARE _psql_cursor NO SCROLL CURSOR FOR\n%s",
|
|
|
|
query);
|
|
|
|
|
|
|
|
results = PQexec(pset.db, buf.data);
|
|
|
|
OK = AcceptResult(results) &&
|
|
|
|
(PQresultStatus(results) == PGRES_COMMAND_OK);
|
2017-09-13 01:27:48 +02:00
|
|
|
if (!OK)
|
|
|
|
SetResultVariables(results, OK);
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2006-08-30 00:25:08 +02:00
|
|
|
termPQExpBuffer(&buf);
|
|
|
|
if (!OK)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (pset.timing)
|
|
|
|
{
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(after);
|
|
|
|
INSTR_TIME_SUBTRACT(after, before);
|
|
|
|
*elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
2013-02-02 23:06:38 +01:00
|
|
|
/*
|
|
|
|
* In \gset mode, we force the fetch count to be 2, so that we will throw
|
|
|
|
* the appropriate error if the query returns more than one row.
|
|
|
|
*/
|
|
|
|
if (pset.gset_prefix)
|
|
|
|
fetch_count = 2;
|
|
|
|
else
|
|
|
|
fetch_count = pset.fetch_count;
|
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
snprintf(fetch_cmd, sizeof(fetch_cmd),
|
|
|
|
"FETCH FORWARD %d FROM _psql_cursor",
|
2013-02-02 23:06:38 +01:00
|
|
|
fetch_count);
|
2006-08-30 00:25:08 +02:00
|
|
|
|
2017-08-24 22:20:50 +02:00
|
|
|
/* one-shot expanded output requested via \gx */
|
|
|
|
if (pset.g_expanded)
|
|
|
|
my_popt.topt.expanded = 1;
|
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
/* prepare to write output to \g argument, if any */
|
|
|
|
if (pset.gfname)
|
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
if (!openQueryOutputFile(pset.gfname, &fout, &is_pipe))
|
2006-08-30 00:25:08 +02:00
|
|
|
{
|
|
|
|
OK = false;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2015-12-03 20:28:58 +01:00
|
|
|
if (is_pipe)
|
|
|
|
disable_sigpipe_trap();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fout = pset.queryFout;
|
|
|
|
is_pipe = false; /* doesn't matter */
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
2010-05-28 22:02:32 +02:00
|
|
|
/* clear any pre-existing error indication on the output stream */
|
2015-12-03 20:28:58 +01:00
|
|
|
clearerr(fout);
|
2010-05-28 22:02:32 +02:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
if (pset.timing)
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(before);
|
2006-08-30 00:25:08 +02:00
|
|
|
|
2013-02-02 23:06:38 +01:00
|
|
|
/* get fetch_count tuples at a time */
|
2006-08-30 00:25:08 +02:00
|
|
|
results = PQexec(pset.db, fetch_cmd);
|
|
|
|
|
|
|
|
if (pset.timing)
|
|
|
|
{
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(after);
|
|
|
|
INSTR_TIME_SUBTRACT(after, before);
|
|
|
|
*elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
2006-08-30 00:48:55 +02:00
|
|
|
if (PQresultStatus(results) != PGRES_TUPLES_OK)
|
2006-08-30 00:25:08 +02:00
|
|
|
{
|
2006-08-30 00:48:55 +02:00
|
|
|
/* shut down pager before printing error message */
|
2015-12-03 20:28:58 +01:00
|
|
|
if (is_pager)
|
2006-08-30 00:48:55 +02:00
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
ClosePager(fout);
|
|
|
|
is_pager = false;
|
2006-08-30 00:48:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
OK = AcceptResult(results);
|
2012-12-15 00:03:07 +01:00
|
|
|
Assert(!OK);
|
2017-09-13 01:27:48 +02:00
|
|
|
SetResultVariables(results, OK);
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2006-08-30 00:25:08 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-02-02 23:06:38 +01:00
|
|
|
if (pset.gset_prefix)
|
|
|
|
{
|
|
|
|
/* StoreQueryTuple will complain if not exactly one row */
|
|
|
|
OK = StoreQueryTuple(results);
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2013-02-02 23:06:38 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-09-06 00:17:47 +02:00
|
|
|
/*
|
|
|
|
* Note we do not deal with \gdesc, \gexec or \crosstabview modes here
|
|
|
|
*/
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
ntuples = PQntuples(results);
|
2017-09-13 01:27:48 +02:00
|
|
|
total_tuples += ntuples;
|
2006-08-30 00:25:08 +02:00
|
|
|
|
2013-02-02 23:06:38 +01:00
|
|
|
if (ntuples < fetch_count)
|
2006-08-30 00:25:08 +02:00
|
|
|
{
|
|
|
|
/* this is the last result set, so allow footer decoration */
|
|
|
|
my_popt.topt.stop_table = true;
|
|
|
|
}
|
2015-12-03 20:28:58 +01:00
|
|
|
else if (fout == stdout && !is_pager)
|
2006-08-30 00:25:08 +02:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If query requires multiple result sets, hack to ensure that
|
|
|
|
* only one pager instance is used for the whole mess
|
|
|
|
*/
|
2015-12-03 20:28:58 +01:00
|
|
|
fout = PageOutput(INT_MAX, &(my_popt.topt));
|
|
|
|
is_pager = true;
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
2015-12-03 20:28:58 +01:00
|
|
|
printQuery(results, &my_popt, fout, is_pager, pset.logfile);
|
2006-08-30 00:25:08 +02:00
|
|
|
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2007-06-22 03:09:28 +02:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
/* after the first result set, disallow header decoration */
|
|
|
|
my_popt.topt.start_table = false;
|
|
|
|
my_popt.topt.prior_records += ntuples;
|
|
|
|
|
2010-05-28 22:02:32 +02:00
|
|
|
/*
|
|
|
|
* Make sure to flush the output stream, so intermediate results are
|
2010-07-06 21:19:02 +02:00
|
|
|
* visible to the client immediately. We check the results because if
|
|
|
|
* the pager dies/exits/etc, there's no sense throwing more data at
|
|
|
|
* it.
|
2010-05-28 22:02:32 +02:00
|
|
|
*/
|
2015-12-03 20:28:58 +01:00
|
|
|
flush_error = fflush(fout);
|
2006-08-30 00:25:08 +02:00
|
|
|
|
2010-05-28 22:02:32 +02:00
|
|
|
/*
|
2010-07-06 21:19:02 +02:00
|
|
|
* Check if we are at the end, if a cancel was pressed, or if there
|
|
|
|
* were any errors either trying to flush out the results, or more
|
|
|
|
* generally on the output stream at all. If we hit any errors
|
|
|
|
* writing things to the stream, we presume $PAGER has disappeared and
|
|
|
|
* stop bothering to pull down more data.
|
2010-05-28 22:02:32 +02:00
|
|
|
*/
|
2013-02-02 23:06:38 +01:00
|
|
|
if (ntuples < fetch_count || cancel_pressed || flush_error ||
|
2015-12-03 20:28:58 +01:00
|
|
|
ferror(fout))
|
2006-08-30 00:25:08 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pset.gfname)
|
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
/* close \g argument file/pipe */
|
|
|
|
if (is_pipe)
|
|
|
|
{
|
|
|
|
pclose(fout);
|
|
|
|
restore_sigpipe_trap();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fclose(fout);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
2015-12-03 20:28:58 +01:00
|
|
|
else if (is_pager)
|
2006-08-30 00:25:08 +02:00
|
|
|
{
|
2015-12-03 20:28:58 +01:00
|
|
|
/* close transient pager */
|
|
|
|
ClosePager(fout);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
2017-09-13 01:27:48 +02:00
|
|
|
if (OK)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We don't have a PGresult here, and even if we did it wouldn't have
|
|
|
|
* the right row count, so fake SetResultVariables(). In error cases,
|
|
|
|
* we already set the result variables above.
|
|
|
|
*/
|
|
|
|
char buf[32];
|
|
|
|
|
|
|
|
SetVariable(pset.vars, "ERROR", "false");
|
|
|
|
SetVariable(pset.vars, "SQLSTATE", "00000");
|
|
|
|
snprintf(buf, sizeof(buf), INT64_FORMAT, total_tuples);
|
|
|
|
SetVariable(pset.vars, "ROW_COUNT", buf);
|
|
|
|
}
|
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
cleanup:
|
|
|
|
if (pset.timing)
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(before);
|
2006-08-30 00:25:08 +02:00
|
|
|
|
|
|
|
/*
|
2006-10-04 02:30:14 +02:00
|
|
|
* We try to close the cursor on either success or failure, but on failure
|
|
|
|
* ignore the result (it's probably just a bleat about being in an aborted
|
|
|
|
* transaction)
|
2006-08-30 00:25:08 +02:00
|
|
|
*/
|
|
|
|
results = PQexec(pset.db, "CLOSE _psql_cursor");
|
|
|
|
if (OK)
|
|
|
|
{
|
|
|
|
OK = AcceptResult(results) &&
|
|
|
|
(PQresultStatus(results) == PGRES_COMMAND_OK);
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
ClearOrSaveResult(results);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
Add a \gexec command to psql for evaluation of computed queries.
\gexec executes the just-entered query, like \g, but instead of printing
the results it takes each field as a SQL command to send to the server.
Computing a series of queries to be executed is a fairly common thing,
but up to now you always had to resort to kluges like writing the queries
to a file and then inputting the file. Now it can be done with no
intermediate step.
The implementation is fairly straightforward except for its interaction
with FETCH_COUNT. ExecQueryUsingCursor isn't capable of being called
recursively, and even if it were, its need to create a transaction
block interferes unpleasantly with the desired behavior of \gexec after
a failure of a generated query (i.e., that it can continue). Therefore,
disable use of ExecQueryUsingCursor when doing the master \gexec query.
We can still apply it to individual generated queries, however, and there
might be some value in doing so.
While testing this feature's interaction with single-step mode, I (tgl) was
led to conclude that SendQuery needs to recognize SIGINT (cancel_pressed)
as a negative response to the single-step prompt. Perhaps that's a
back-patchable bug fix, but for now I just included it here.
Corey Huinker, reviewed by Jim Nasby, Daniel Vérité, and myself
2016-04-04 21:25:16 +02:00
|
|
|
else
|
|
|
|
PQclear(results);
|
2006-08-30 00:25:08 +02:00
|
|
|
|
|
|
|
if (started_txn)
|
|
|
|
{
|
|
|
|
results = PQexec(pset.db, OK ? "COMMIT" : "ROLLBACK");
|
|
|
|
OK &= AcceptResult(results) &&
|
|
|
|
(PQresultStatus(results) == PGRES_COMMAND_OK);
|
2016-04-03 18:29:55 +02:00
|
|
|
ClearOrSaveResult(results);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (pset.timing)
|
|
|
|
{
|
2008-05-14 21:10:29 +02:00
|
|
|
INSTR_TIME_SET_CURRENT(after);
|
|
|
|
INSTR_TIME_SUBTRACT(after, before);
|
|
|
|
*elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
|
2006-08-30 00:25:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-06-28 02:12:40 +02:00
|
|
|
/*
|
2004-09-20 20:51:19 +02:00
|
|
|
* Advance the given char pointer over white space and SQL comments.
|
2003-06-28 02:12:40 +02:00
|
|
|
*/
|
2004-09-20 20:51:19 +02:00
|
|
|
static const char *
|
|
|
|
skip_white_space(const char *query)
|
2003-06-28 02:12:40 +02:00
|
|
|
{
|
2005-10-15 04:49:52 +02:00
|
|
|
int cnestlevel = 0; /* slash-star comment nest level */
|
2003-06-28 02:12:40 +02:00
|
|
|
|
|
|
|
while (*query)
|
|
|
|
{
|
2005-10-15 04:49:52 +02:00
|
|
|
int mblen = PQmblen(query, pset.encoding);
|
2004-09-20 20:51:19 +02:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Note: we assume the encoding is a superset of ASCII, so that for
|
|
|
|
* example "query[0] == '/'" is meaningful. However, we do NOT assume
|
|
|
|
* that the second and subsequent bytes of a multibyte character
|
|
|
|
* couldn't look like ASCII characters; so it is critical to advance
|
|
|
|
* by mblen, not 1, whenever we haven't exactly identified the
|
|
|
|
* character we are skipping over.
|
2004-09-20 20:51:19 +02:00
|
|
|
*/
|
2003-06-28 02:12:40 +02:00
|
|
|
if (isspace((unsigned char) *query))
|
2004-09-20 20:51:19 +02:00
|
|
|
query += mblen;
|
|
|
|
else if (query[0] == '/' && query[1] == '*')
|
2003-06-28 02:12:40 +02:00
|
|
|
{
|
2004-09-20 20:51:19 +02:00
|
|
|
cnestlevel++;
|
2003-06-28 02:12:40 +02:00
|
|
|
query += 2;
|
|
|
|
}
|
2004-09-20 20:51:19 +02:00
|
|
|
else if (cnestlevel > 0 && query[0] == '*' && query[1] == '/')
|
|
|
|
{
|
|
|
|
cnestlevel--;
|
|
|
|
query += 2;
|
|
|
|
}
|
|
|
|
else if (cnestlevel == 0 && query[0] == '-' && query[1] == '-')
|
2003-06-28 02:12:40 +02:00
|
|
|
{
|
|
|
|
query += 2;
|
2005-10-15 04:49:52 +02:00
|
|
|
|
2004-09-20 20:51:19 +02:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* We have to skip to end of line since any slash-star inside the
|
|
|
|
* -- comment does NOT start a slash-star comment.
|
2004-09-20 20:51:19 +02:00
|
|
|
*/
|
2003-06-28 02:12:40 +02:00
|
|
|
while (*query)
|
|
|
|
{
|
2004-09-20 20:51:19 +02:00
|
|
|
if (*query == '\n')
|
2003-06-28 02:12:40 +02:00
|
|
|
{
|
2004-09-20 20:51:19 +02:00
|
|
|
query++;
|
2003-06-28 02:12:40 +02:00
|
|
|
break;
|
|
|
|
}
|
2004-09-20 20:51:19 +02:00
|
|
|
query += PQmblen(query, pset.encoding);
|
2003-06-28 02:12:40 +02:00
|
|
|
}
|
|
|
|
}
|
2004-09-20 20:51:19 +02:00
|
|
|
else if (cnestlevel > 0)
|
|
|
|
query += mblen;
|
2003-06-28 02:12:40 +02:00
|
|
|
else
|
|
|
|
break; /* found first token */
|
|
|
|
}
|
|
|
|
|
2004-09-20 20:51:19 +02:00
|
|
|
return query;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether a command is one of those for which we should NOT start
|
|
|
|
* a new transaction block (ie, send a preceding BEGIN).
|
|
|
|
*
|
|
|
|
* These include the transaction control statements themselves, plus
|
|
|
|
* certain statements that the backend disallows inside transaction blocks.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
command_no_begin(const char *query)
|
|
|
|
{
|
|
|
|
int wordlen;
|
|
|
|
|
2003-06-28 02:12:40 +02:00
|
|
|
/*
|
2004-09-20 20:51:19 +02:00
|
|
|
* First we must advance over any whitespace and comments.
|
|
|
|
*/
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check word length (since "beginx" is not "begin").
|
2003-06-28 02:12:40 +02:00
|
|
|
*/
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
2004-09-20 20:51:19 +02:00
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
2003-06-28 02:12:40 +02:00
|
|
|
|
2004-09-20 20:51:19 +02:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Transaction control commands. These should include every keyword that
|
|
|
|
* gives rise to a TransactionStmt in the backend grammar, except for the
|
|
|
|
* savepoint-related commands.
|
2004-09-20 20:51:19 +02:00
|
|
|
*
|
2005-11-22 19:17:34 +01:00
|
|
|
* (We assume that START must be START TRANSACTION, since there is
|
|
|
|
* presently no other "START foo" command.)
|
2004-09-20 20:51:19 +02:00
|
|
|
*/
|
|
|
|
if (wordlen == 5 && pg_strncasecmp(query, "abort", 5) == 0)
|
|
|
|
return true;
|
2004-05-07 02:24:59 +02:00
|
|
|
if (wordlen == 5 && pg_strncasecmp(query, "begin", 5) == 0)
|
2003-06-28 02:12:40 +02:00
|
|
|
return true;
|
2004-09-20 20:51:19 +02:00
|
|
|
if (wordlen == 5 && pg_strncasecmp(query, "start", 5) == 0)
|
|
|
|
return true;
|
2004-05-07 02:24:59 +02:00
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "commit", 6) == 0)
|
2003-06-28 02:12:40 +02:00
|
|
|
return true;
|
2004-09-20 20:51:19 +02:00
|
|
|
if (wordlen == 3 && pg_strncasecmp(query, "end", 3) == 0)
|
2003-06-28 02:12:40 +02:00
|
|
|
return true;
|
2004-09-20 20:51:19 +02:00
|
|
|
if (wordlen == 8 && pg_strncasecmp(query, "rollback", 8) == 0)
|
2003-06-28 02:12:40 +02:00
|
|
|
return true;
|
2005-06-18 00:32:51 +02:00
|
|
|
if (wordlen == 7 && pg_strncasecmp(query, "prepare", 7) == 0)
|
|
|
|
{
|
|
|
|
/* PREPARE TRANSACTION is a TC command, PREPARE foo is not */
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
if (wordlen == 11 && pg_strncasecmp(query, "transaction", 11) == 0)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2004-09-20 20:51:19 +02:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* Commands not allowed within transactions. The statements checked for
|
2018-04-26 20:47:16 +02:00
|
|
|
* here should be exactly those that call PreventInTransactionBlock() in
|
|
|
|
* the backend.
|
2004-09-20 20:51:19 +02:00
|
|
|
*/
|
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "vacuum", 6) == 0)
|
2003-06-28 02:12:40 +02:00
|
|
|
return true;
|
2004-09-20 20:51:19 +02:00
|
|
|
if (wordlen == 7 && pg_strncasecmp(query, "cluster", 7) == 0)
|
2006-08-25 06:06:58 +02:00
|
|
|
{
|
|
|
|
/* CLUSTER with any arguments is allowed in transactions */
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
if (isalpha((unsigned char) query[0]))
|
|
|
|
return false; /* has additional words */
|
|
|
|
return true; /* it's CLUSTER without arguments */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "create", 6) == 0)
|
|
|
|
{
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
|
|
|
|
return true;
|
|
|
|
if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* CREATE [UNIQUE] INDEX CONCURRENTLY isn't allowed in xacts */
|
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "unique", 6) == 0)
|
|
|
|
{
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wordlen == 5 && pg_strncasecmp(query, "index", 5) == 0)
|
|
|
|
{
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2003-06-28 02:12:40 +02:00
|
|
|
|
2014-07-02 05:42:20 +02:00
|
|
|
if (wordlen == 5 && pg_strncasecmp(query, "alter", 5) == 0)
|
|
|
|
{
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
/* ALTER SYSTEM isn't allowed in xacts */
|
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2004-09-20 20:51:19 +02:00
|
|
|
/*
|
2006-10-04 02:30:14 +02:00
|
|
|
* Note: these tests will match DROP SYSTEM and REINDEX TABLESPACE, which
|
|
|
|
* aren't really valid commands so we don't care much. The other four
|
|
|
|
* possible matches are correct.
|
2004-09-20 20:51:19 +02:00
|
|
|
*/
|
2006-08-25 06:06:58 +02:00
|
|
|
if ((wordlen == 4 && pg_strncasecmp(query, "drop", 4) == 0) ||
|
2004-09-20 20:51:19 +02:00
|
|
|
(wordlen == 7 && pg_strncasecmp(query, "reindex", 7) == 0))
|
|
|
|
{
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
|
|
|
|
return true;
|
2005-06-22 23:14:31 +02:00
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
|
|
|
|
return true;
|
2004-09-20 20:51:19 +02:00
|
|
|
if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
|
|
|
|
return true;
|
2015-03-20 02:16:42 +01:00
|
|
|
|
|
|
|
/* DROP INDEX CONCURRENTLY isn't allowed in xacts */
|
|
|
|
if (wordlen == 5 && pg_strncasecmp(query, "index", 5) == 0)
|
|
|
|
{
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-09-28 20:47:25 +02:00
|
|
|
return false;
|
2004-09-20 20:51:19 +02:00
|
|
|
}
|
|
|
|
|
2010-09-28 08:55:25 +02:00
|
|
|
/* DISCARD ALL isn't allowed in xacts, but other variants are allowed. */
|
2010-09-28 07:20:17 +02:00
|
|
|
if (wordlen == 7 && pg_strncasecmp(query, "discard", 7) == 0)
|
2010-09-28 08:55:25 +02:00
|
|
|
{
|
|
|
|
query += wordlen;
|
|
|
|
|
|
|
|
query = skip_white_space(query);
|
|
|
|
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
if (wordlen == 3 && pg_strncasecmp(query, "all", 3) == 0)
|
|
|
|
return true;
|
2010-09-28 20:47:25 +02:00
|
|
|
return false;
|
2010-09-28 08:55:25 +02:00
|
|
|
}
|
2010-09-28 07:20:17 +02:00
|
|
|
|
2003-06-28 02:12:40 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2003-03-20 07:43:35 +01:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
/*
|
|
|
|
* Check whether the specified command is a SELECT (or VALUES).
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
is_select_command(const char *query)
|
|
|
|
{
|
|
|
|
int wordlen;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First advance over any whitespace, comments and left parentheses.
|
|
|
|
*/
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
query = skip_white_space(query);
|
|
|
|
if (query[0] == '(')
|
|
|
|
query++;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check word length (since "selectx" is not "select").
|
|
|
|
*/
|
|
|
|
wordlen = 0;
|
|
|
|
while (isalpha((unsigned char) query[wordlen]))
|
|
|
|
wordlen += PQmblen(&query[wordlen], pset.encoding);
|
|
|
|
|
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "select", 6) == 0)
|
|
|
|
return true;
|
2006-10-04 02:30:14 +02:00
|
|
|
|
2006-08-30 00:25:08 +02:00
|
|
|
if (wordlen == 6 && pg_strncasecmp(query, "values", 6) == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-06-28 02:12:40 +02:00
|
|
|
/*
|
|
|
|
* Test if the current user is a database superuser.
|
|
|
|
*
|
|
|
|
* Note: this will correctly detect superuserness only with a protocol-3.0
|
|
|
|
* or newer backend; otherwise it will always say "false".
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
is_superuser(void)
|
|
|
|
{
|
|
|
|
const char *val;
|
|
|
|
|
|
|
|
if (!pset.db)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
val = PQparameterStatus(pset.db, "is_superuser");
|
|
|
|
|
|
|
|
if (val && strcmp(val, "on") == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2003-09-04 00:05:09 +02:00
|
|
|
|
|
|
|
|
2006-03-06 20:49:20 +01:00
|
|
|
/*
|
|
|
|
* Test if the current session uses standard string literals.
|
|
|
|
*
|
2006-05-11 21:15:36 +02:00
|
|
|
* Note: With a pre-protocol-3.0 connection this will always say "false",
|
|
|
|
* which should be the right answer.
|
2006-03-06 20:49:20 +01:00
|
|
|
*/
|
|
|
|
bool
|
|
|
|
standard_strings(void)
|
|
|
|
{
|
|
|
|
const char *val;
|
|
|
|
|
|
|
|
if (!pset.db)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
val = PQparameterStatus(pset.db, "standard_conforming_strings");
|
|
|
|
|
|
|
|
if (val && strcmp(val, "on") == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-09-04 00:05:09 +02:00
|
|
|
/*
|
|
|
|
* Return the session user of the current connection.
|
|
|
|
*
|
|
|
|
* Note: this will correctly detect the session user only with a
|
|
|
|
* protocol-3.0 or newer backend; otherwise it will return the
|
|
|
|
* connection user.
|
|
|
|
*/
|
|
|
|
const char *
|
|
|
|
session_username(void)
|
|
|
|
{
|
|
|
|
const char *val;
|
|
|
|
|
|
|
|
if (!pset.db)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
val = PQparameterStatus(pset.db, "session_authorization");
|
|
|
|
if (val)
|
|
|
|
return val;
|
|
|
|
else
|
|
|
|
return PQuser(pset.db);
|
|
|
|
}
|
2004-01-09 22:12:20 +01:00
|
|
|
|
|
|
|
|
|
|
|
/* expand_tilde
|
|
|
|
*
|
|
|
|
* substitute '~' with HOME or '~username' with username's home dir
|
|
|
|
*
|
|
|
|
*/
|
2013-04-04 18:56:21 +02:00
|
|
|
void
|
2004-01-09 22:12:20 +01:00
|
|
|
expand_tilde(char **filename)
|
|
|
|
{
|
|
|
|
if (!filename || !(*filename))
|
2013-04-04 18:56:21 +02:00
|
|
|
return;
|
2004-01-09 22:12:20 +01:00
|
|
|
|
2005-06-10 16:49:31 +02:00
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* WIN32 doesn't use tilde expansion for file names. Also, it uses tilde
|
|
|
|
* for short versions of long file names, though the tilde is usually
|
|
|
|
* toward the end, not at the beginning.
|
2005-06-10 16:49:31 +02:00
|
|
|
*/
|
2004-01-09 22:12:20 +01:00
|
|
|
#ifndef WIN32
|
|
|
|
|
|
|
|
/* try tilde expansion */
|
|
|
|
if (**filename == '~')
|
|
|
|
{
|
|
|
|
char *fn;
|
|
|
|
char oldp,
|
|
|
|
*p;
|
|
|
|
struct passwd *pw;
|
2004-08-18 04:59:12 +02:00
|
|
|
char home[MAXPGPATH];
|
2004-01-09 22:12:20 +01:00
|
|
|
|
|
|
|
fn = *filename;
|
2004-08-18 04:59:12 +02:00
|
|
|
*home = '\0';
|
2004-01-09 22:12:20 +01:00
|
|
|
|
|
|
|
p = fn + 1;
|
|
|
|
while (*p != '/' && *p != '\0')
|
|
|
|
p++;
|
|
|
|
|
|
|
|
oldp = *p;
|
|
|
|
*p = '\0';
|
|
|
|
|
|
|
|
if (*(fn + 1) == '\0')
|
2005-06-10 16:41:32 +02:00
|
|
|
get_home_path(home); /* ~ or ~/ only */
|
2004-01-09 22:12:20 +01:00
|
|
|
else if ((pw = getpwnam(fn + 1)) != NULL)
|
2007-11-15 22:14:46 +01:00
|
|
|
strlcpy(home, pw->pw_dir, sizeof(home)); /* ~user */
|
2004-01-09 22:12:20 +01:00
|
|
|
|
|
|
|
*p = oldp;
|
2004-08-18 04:59:12 +02:00
|
|
|
if (strlen(home) != 0)
|
2004-01-09 22:12:20 +01:00
|
|
|
{
|
|
|
|
char *newfn;
|
|
|
|
|
2013-10-23 01:40:26 +02:00
|
|
|
newfn = psprintf("%s%s", home, p);
|
2004-01-09 22:12:20 +01:00
|
|
|
free(fn);
|
|
|
|
*filename = newfn;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-04-04 18:56:21 +02:00
|
|
|
return;
|
2004-01-09 22:12:20 +01:00
|
|
|
}
|
psql: fix \connect with URIs and conninfo strings
This is the second try at this, after fcef1617295 failed miserably and
had to be reverted: as it turns out, libpq cannot depend on libpgcommon
after all. Instead of shuffling code in the master branch, make that one
just like 9.4 and accept the duplication. (This was all my own mistake,
not the patch submitter's).
psql was already accepting conninfo strings as the first parameter in
\connect, but the way it worked wasn't sane; some of the other
parameters would get the previous connection's values, causing it to
connect to a completely unexpected server or, more likely, not finding
any server at all because of completely wrong combinations of
parameters.
Fix by explicitely checking for a conninfo-looking parameter in the
dbname position; if one is found, use its complete specification rather
than mix with the other arguments. Also, change tab-completion to not
try to complete conninfo/URI-looking "dbnames" and document that
conninfos are accepted as first argument.
There was a weak consensus to backpatch this, because while the behavior
of using the dbname as a conninfo is nowhere documented for \connect, it
is reasonable to expect that it works because it does work in many other
contexts. Therefore this is backpatched all the way back to 9.0.
Author: David Fetter, Andrew Dunstan. Some editorialization by me
(probably earning a Gierth's "Sloppy" badge in the process.)
Reviewers: Andrew Gierth, Erik Rijkers, Pavel Stěhule, Stephen Frost,
Robert Haas, Andrew Dunstan.
2015-04-02 17:30:57 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Checks if connection string starts with either of the valid URI prefix
|
|
|
|
* designators.
|
|
|
|
*
|
|
|
|
* Returns the URI prefix length, 0 if the string doesn't contain a URI prefix.
|
|
|
|
*
|
|
|
|
* XXX This is a duplicate of the eponymous libpq function.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
uri_prefix_length(const char *connstr)
|
|
|
|
{
|
|
|
|
/* The connection URI must start with either of the following designators: */
|
|
|
|
static const char uri_designator[] = "postgresql://";
|
|
|
|
static const char short_uri_designator[] = "postgres://";
|
|
|
|
|
|
|
|
if (strncmp(connstr, uri_designator,
|
|
|
|
sizeof(uri_designator) - 1) == 0)
|
|
|
|
return sizeof(uri_designator) - 1;
|
|
|
|
|
|
|
|
if (strncmp(connstr, short_uri_designator,
|
|
|
|
sizeof(short_uri_designator) - 1) == 0)
|
|
|
|
return sizeof(short_uri_designator) - 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Recognized connection string either starts with a valid URI prefix or
|
|
|
|
* contains a "=" in it.
|
|
|
|
*
|
|
|
|
* Must be consistent with parse_connection_string: anything for which this
|
|
|
|
* returns true should at least look like it's parseable by that routine.
|
|
|
|
*
|
|
|
|
* XXX This is a duplicate of the eponymous libpq function.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
recognized_connection_string(const char *connstr)
|
|
|
|
{
|
|
|
|
return uri_prefix_length(connstr) != 0 || strchr(connstr, '=') != NULL;
|
|
|
|
}
|