psql is a regular
PostgreSQL
- client application. In order to connect to a database you need to determin e
- name of you target database, the hostname and port number of the server
+ client application. In order to connect to a database you need to know th e
+ name of your target database, the hostname and port number of the server
and what user name you want to connect as.
psql can be
told about those parameters via command line options, namely -d ,
-h , -p , and -U respectively.
Ordinarily, input lines are sent to the backend when a query-terminating
semicolon is reached. An end of line does not terminate a query! Thus queries
can be spread over serveral lines for clarity. If the query was sent and without
- error the query results are displayed on the screen.
+ error, the query results are displayed on the screen.
- To include whitespace into an argument you must quote it with either single
- or double quotes. Anything contained in single quotes (except for a
- backslash-escaped single quote itself) is taken literally as the argument.
- Anything contained in double quotes is furthermore subject to C-like
- substitutions for \n (new line), \t (tab),
- \ digits ,
+ To include whitespace into an argument you must quote it with a single
+ quote. To include a single quote into such an argument, preceed it by
+ a backslash. Anything contained in single quotes is furthermore subject to
+ C-like substitutions for \n (new line), \t
+ (tab), \ digits ,
\0 digits , and
\0x digits
(the character with the given decimal, octal, or hexadecimal code).
- If an unquoted argument begins with a dollar sign ($ ),
+ If an unquoted argument begins with a colon (: ),
it is taken as a variable and the value of the variable is taken as the
- argument instead. Inside double quotes, variable values can be substituted
- by enclosing the name in a ${...} sequence. See also under
-
.
+ argument instead.
- Arguments that are quoted in back-ticks
(` )
- are taken as a command line
- that is passed to the shell. The output of the command (with a trailing
- newline removed) is taken as the argument value. Back-ticks are subject to
- the same substitution rules as double-quotes.
+ Arguments that are quoted in backticks
(` )
+ are taken as a command line that is passed to the shell. The output of the
+ command (with a trailing newline removed) is taken as the argument value.
+ The above escape sequences also apply in backticks.
+
+
+ Some commands take the name of an
SQL identifier (such as
+ a table name) as argument. These arguments follow the syntax rules of
+
SQL regarding double quotes: an identifier without
+ double quotes is coerced to lower-case. For all other commands
+ double quotes are not special and will become part of the argument.
(two backslashes) marks the end of arguments and continues parsing
SQL queries, if any. That way
SQL and
psql commands can be freely mixed on a line.
- I n any case, the arguments of a meta-command cannot continue beyond the end
+ But i n any case, the arguments of a meta-command cannot continue beyond the end
of the line.
If the connection attempt failed (wrong username, access denied, etc.) the
- previous connection will be kept
, if and only if
psql is
+ previous connection will be kept if and only if
psql is
in interactive mode. When executing a non-interactive script, processing
will immediately stop with an error. This distinction was chosen as a user
convenience against typos on the one hand, and a safety mechanism that
This operation is not as efficient as the
SQL COPY command because all data must pass through the
- client/server IP or socket connection. For large amounts of data this other
+ client/server IP or socket connection. For large amounts of data the other
technique may be preferable.
\echo text [ ... ]
- Prints the arguments to the standard output. This can be useful to
+ Prints the arguments to the standard output, separated by one space and
+ followed by a newline. This can be useful to
intersperse information in the output of scripts. For example:
=> \echo `date`
Tue Oct 26 21:40:57 CEST 1999
+ If the first argument is an unquoted -n the the trailing
+ newline is not written.
If you want to see the lines on the screen as they are read you must set
- the variable echo>.
+ the variable ECHO full>.
Stores the file into a
PostgreSQL large object
.
Optionally, it associates the given comment with the object. Example:
-foo=> \lo_import '/home/me /pictures/photo.xcf' 'a picture of me'
+foo=> \lo_import '/home/peter /pictures/photo.xcf' 'a picture of me'
lo_import 152801
The response indicates that the large object received object id 152801
- \set [ name [ value ]]
+ \set [ name [ value [ ... ] ]]
Sets the internal variable name
- to value. If no second argument
+ to value or, if more than one
+ value is given, to the concatenation of all of them. If no second argument
is given, the variable is just set with not value. To unset a variable, use
the \unset command.
Escapes to a separate Unix shell or executes the Unix command
command. The arguments
- are not further interpreted, the shell will see them as is. If you wish
- to capture the output of a shell command and/or use
psql 's
- variable substitution features, use the backticks (` ).
+ are not further interpreted, the shell will see them as is.
is to execute one query string, query,
- and then exit. This is useful for shell scripts.
+ and then exit. This is useful in shell scripts.
query must be either a query string
specific features), or it is a single backslash command. Thus
you cannot mix
SQL and
psql meta-commands. To achieve this you could pipe the string into
-
psql and finish it with a a \q , - like so: echo "select * from foo; \q " | psql.
+ echo "\x \\ select * from foo;
After the file is processed,
psql terminates.
This in many ways equivalent to the internal command \i .
+ Using this option is subtly different from writing
+ psql < filename .
+ In general, both will do what you expect, but using -f
+ enables some nice features such as error messages with line numbers.
+ There is also a slight chance that using this option will reduce
+ the startup overhead. On the other hand, the variant using the shell's
+ input redirection is (in theory) guaranteed to yield exactly the same
+ output that you would have gotten had you entered everything by hand.
+
-
- -n, --no-readline
-
- Do not use readline for line editing and do not use the history.
-
-
-
-
-
-o, --output filename
+
+
+ -R, --record-separator separator
+
+ Use separator as the record separator.
+ This is equivalent to the \pset recordsep command.
+
+
+
+
-s, --single-step
As of version 7.0,
psql automatically issues a
password prompt whenever the backend requests password authentication.
- Because this is currently based on a hack
the automatic
+ Because this is currently based on a hack
, the automatic
recognition might mysteriously fail, hence this option to force a prompt.
If no password prompt is issued and the backend requires password authentication
the connection attempt will fail.
psql provides variable substitution features
- similar to common Unix command shells. Variables are simply name/value
+ similar to common Unix command shells. This feature is new and not very
+ sophisticated, yet, but there are plans to expand it in the future.
+ Variables are simply name/value
pairs, where the value can be any string of any length. To set variables,
use the
psql meta-command
\set :
testdb=> \set foo bar
sets the variable foo
to the value bar
. To retrieve
- the content of the variable, precede the name with a dollar-sig n and use it
+ the content of the variable, precede the name with a colo n and use it
as the argument of any slash command:
-testdb=> \echo $ foo
+testdb=> \echo : foo
bar
- Alternatively, the value can also be interpolated into a double-quoted (or backtick-quoted)
- string, like so:
-testdb=> \echo "foo is now ${foo}."
-foo is now bar.
-
- (The curly braces are required.) No variable substitution
- will be performed in single-quoted strings or in any of the backslash commands
- that have special parsing rules (e.g., \copy ).
The arguments of \set are subject to the same substitution
rules as with other commands. Thus you can construct interesting references
- such as \set "${foo}bar" 'something' and get soft
+ such as \set :foo 'something' and get soft
links or
variable variables
of
Perl or
PHP fame, respectively.
Unfortunately (or fortunately?), there is not way to do anything useful
- with these constructs. (\echo ${${foo}} doesn't work.) On the
- other hand, \set bar $ foo is a perfectly valid way to copy
+ with these constructs. On the
+ other hand, \set bar : foo is a perfectly valid way to copy
a variable.
- If you call \set without an argument, the variable is simply
+ If you call \set without a second argument, the variable is simply
set, but has no value. To unset (or delete) a variable, use the command
\unset .
An additional useful feature of
psql variables
is that you can substitute (interpolate
) them into
- regular
SQL statements. The syntax for this is to prepend
+ regular
SQL statements. The syntax for this is
again to prepend
the variable name with a colon (: ).
testdb=> \set foo 'my_table'
Another possible use of this mechanism is to copy the contents of a file
into a field. First load the file into a variable and then proceed as above.
-testdb=> \set content `cat my_file.txt`
-testdb=> \set content "'${content}'"
+testdb=> \set content '\'' `cat my_file.txt` '\''
testdb=> INSERT INTO my_table VALUES (:content);
One possible problem with this approach is that my_file.txt
Since colons may legally appear in queries, the following rule applies: If the variable
- is not set, the character sequence colon- name
is not changed. In any
+ is not set, the character sequence colon name
is not changed. In any
case you can escape a colon with a backslash to protect it from interpretation.
(The colon syntax for variables is standard
SQL for embedded
query languages, such as
ecpg . The colon syntax for
- array slices and type casts are
PostgreSQL extensions.)
+ array slices and type casts are
PostgreSQL extensions,
+ hence the conflict.)
- %$ name$
+ %: name:
The value of the
psql ,
magic
, or environment
variable name. See the section
psql supports the readline and history libraries for
- convenienen t line editing and retrieval. The command history is stored in a file
+ convenient line editing and retrieval. The command history is stored in a file
named .psql_history in your home directory and is reloaded when
Tab-completion is also supported, although
the completion logic makes no claim to be an
SQL parser.
When available,
psql is automatically built to use these
- features.
+ features. If for some reason you do not like the tab completion, you can turn if off
+ by putting this in a file named .inputrc in your
+ home directory:
+$if psql
+set disable-completion on
+$endif
+
+ (This is not a
psql but a
readline + feature. Read its documentation for further details.)
you have the library and header files installed in an obscure place you
must tell configure about them, for example:
-$ ./configure --with-includes=/opt/gnu/include --with-librarie s=/opt/gnu/lib ...
+$ ./configure --with-includes=/opt/gnu/include --with-libs=/opt/gnu/lib ...
Then you have to recompile
psql (not necessarily
the entire code tree).
At this point you decide to change the prompt to something more
interesting:
-testdb=> \set prompt 1 '%n@%m %~%R%# '
+testdb=> \set PROMPT 1 '%n@%m %~%R%# '
peter@localhost testdb=>
Let's assume you have filled the table with data and want to take a look at it:
-
- The number of options for a backslash command is limited, probably to 16.
- You can easily change this in the source code, and perhaps I will get around
- to fixing this one day. Not that there is any command
- that actually uses that many options though.
-
-
*
* Copyright 2000 by PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/command.c,v 1.17 2000/02/05 12:27:56 ishii Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/command.c,v 1.18 2000/02/07 23:10:04 petere Exp $
*/
#include
#include "command.h"
#include
#include
#include
#include
#include /* for umask() */
#include /* for umask(), stat() */
#include /* for geteuid(), getpid(), stat() */
+#else
+#include
#endif
#include
-#include "stringutils.h"
-#include "mainloop.h"
+#include "common.h"
#include "copy.h"
+#include "describe.h"
#include "help.h"
-#include "settings.h"
-#include "common.h"
+#include "input.h"
#include "large_obj.h"
+#include "mainloop.h"
#include "print.h"
-#include "describe.h"
-#include "input.h"
+#include "settings.h"
#include "variables.h"
-#ifdef WIN32
-#include "../../interfaces/libpq/win32.h"
-#define popen(x,y) _popen(x,y)
-#define pclose(x) _pclose(x)
-#endif
-
/* functions for use in this file */
static backslashResult exec_command(const char *cmd,
- char *const * options,
const char *options_string,
+ const char ** continue_parse,
PQExpBuffer query_buf);
-static bool do_edit(const char *filename_arg, PQExpBuffer query_buf);
-
-static char * unescape(const char *source);
-
-static bool do_connect(const char *new_dbname,
- const char *new_user);
-
+enum option_type { OT_NORMAL, OT_SQLID };
+static char * scan_option(char ** string, enum option_type type, char * quote);
+static char * unescape(const unsigned char *source, size_t len);
+static bool do_edit(const char *filename_arg, PQExpBuffer query_buf);
+static bool do_connect(const char *new_dbname, const char *new_user);
static bool do_shell(const char *command);
-/*
- * Perhaps this should be changed to "infinity",
- * but there is no convincing reason to bother
- * at this point.
- */
-#define NR_OPTIONS 16
/*----------
*
* 'query_buf' contains the query-so-far, which may be modified by
* execution of the backslash command (for example, \r clears it)
- * query_buf can be NULL if there is no query-so- far.
+ * query_buf can be NULL if there is no query so far.
*
* Returns a status code indicating what action is desired, see command.h.
*----------
{
backslashResult status = CMD_SKIP_LINE;
char *my_line;
- char *options[NR_OPTIONS+1];
- char *token;
- const char *options_string = NULL;
- const char *cmd;
+ char *options_string = NULL;
size_t blank_loc;
- int i;
const char *continue_parse = NULL; /* tell the mainloop where the
* backslash command ended */
#ifdef USE_ASSERT_CHECKING
assert(line);
- assert(query_buf);
assert(end_of_cmd);
#endif
my_line[blank_loc] = '\0';
}
- options[0] = NULL;
-
- if (options_string)
- {
- char quote;
- unsigned int pos;
-
- options_string = &options_string[strspn(options_string, " \t")]; /* skip leading
- * whitespace */
-
- i = 0;
- token = strtokx(options_string, " \t", "\"'`", '\\', "e, &pos, pset.encoding);
-
- for (i = 0; token && i < NR_OPTIONS; i++)
- {
- switch (quote)
- {
- case '"':
- options[i] = unescape(token);
- break;
- case '\'':
- options[i] = xstrdup(token);
- break;
- case '`':
- {
- bool error = false;
- FILE *fd = NULL;
- char *file = unescape(token);
- PQExpBufferData output;
- char buf[512];
- size_t result;
-
- fd = popen(file, "r");
- if (!fd)
- {
- psql_error("%s: %s\n", file, strerror(errno));
- error = true;
- }
-
- if (!error)
- {
- initPQExpBuffer(&output);
-
- do
- {
- result = fread(buf, 1, 512, fd);
- if (ferror(fd))
- {
- psql_error("%s: %s\n", file, strerror(errno));
- error = true;
- break;
- }
- appendBinaryPQExpBuffer(&output, buf, result);
- } while (!feof(fd));
- appendPQExpBufferChar(&output, '\0');
-
- if (pclose(fd) == -1)
- {
- psql_error("%s: %s\n", file, strerror(errno));
- error = true;
- }
- }
-
- if (!error)
- {
- if (output.data[strlen(output.data) - 1] == '\n')
- output.data[strlen(output.data) - 1] = '\0';
- }
-
- free(file);
- if (!error)
- options[i] = output.data;
- else
- {
- options[i] = xstrdup("");
- termPQExpBuffer(&output);
- }
- break;
- }
- case 0:
- default:
- if (token[0] == '\\')
- continue_parse = options_string + pos;
- else if (token[0] == '$')
- {
- const char * value = GetVariable(pset.vars, token+1);
- if (!value)
- value = "";
- options[i] = xstrdup(value);
- }
- else
- options[i] = xstrdup(token);
- }
-
- if (continue_parse)
- break;
-
- token = strtokx(NULL, " \t", "\"'`", '\\', "e, &pos, pset.encoding);
- } /* for */
-
- options[i] = NULL;
- }
-
- cmd = my_line;
- status = exec_command(cmd, options, options_string, query_buf);
+ status = exec_command(my_line, options_string, &continue_parse, query_buf);
if (status == CMD_UNKNOWN)
{
-
/*
- * If the command was not recognized, try inserting a space after
- * the first letter and call again. The one letter commands allow
- * arguments to start immediately after the command, but that is
- * no longer encouraged.
+ * If the command was not recognized, try inserting a space after the
+ * first letter and call again. The one letter commands allow arguments
+ * to start immediately after the command, but that is no longer
+ * encouraged.
*/
- const char *new_options[NR_OPTIONS+1];
char new_cmd[2];
- int i;
-
- for (i = 1; i < NR_OPTIONS+1; i++)
- new_options[i] = options[i - 1];
- new_options[0] = cmd + 1;
- new_cmd[0] = cmd [0];
+ new_cmd[0] = my_line [0];
new_cmd[1] = '\0';
- status = exec_command(new_cmd, (char *const *) new_options, my_line + 2, query_buf);
+ status = exec_command(new_cmd, my_line + 1, &continue_parse, query_buf);
+
+ if (status != CMD_UNKNOWN && isalpha(new_cmd[0]))
+ psql_error("Warning: this syntax is deprecated\n");
}
if (status == CMD_UNKNOWN)
{
if (pset.cur_cmd_interactive)
- fprintf(stderr, "Invalid command \\%s. Try \\? for help.\n", cmd );
+ fprintf(stderr, "Invalid command \\%s. Try \\? for help.\n", my_line );
else
- psql_error("invalid command \\%s\n", cmd );
+ psql_error("invalid command \\%s\n", my_line );
status = CMD_ERROR;
}
- if (continue_parse && *(continue_parse + 1) == '\\')
+ if (continue_parse && *continue_parse && * (continue_parse + 1) == '\\')
continue_parse += 2;
else
*end_of_cmd = line + strlen(line);
- /* clean up */
- for (i = 0; i < NR_OPTIONS && options[i]; i++)
- free(options[i]);
-
free(my_line);
return status;
-
static backslashResult
exec_command(const char *cmd,
- char *const * options,
const char *options_string,
+ const char ** continue_parse,
PQExpBuffer query_buf)
{
bool success = true; /* indicate here if the command ran ok or
* failed */
bool quiet = QUIET();
-
backslashResult status = CMD_SKIP_LINE;
+ char *string, *string_cpy;
+ /*
+ * The 'string' variable will be overwritten to point to the next token,
+ * hence we need an extra pointer so we can free this at the end.
+ */
+ if (options_string)
+ string = string_cpy = xstrdup(options_string);
+ else
+ string = string_cpy = NULL;
/* \a -- toggle field alignment This makes little sense but we keep it around. */
if (strcmp(cmd, "a") == 0)
success = do_pset("format", "unaligned", &pset.popt, quiet);
}
-
/* \C -- override table title (formerly change HTML caption) */
else if (strcmp(cmd, "C") == 0)
- success = do_pset("title", options[0], &pset.popt, quiet);
-
+ {
+ char * opt = scan_option(&string, OT_NORMAL, NULL);
+ success = do_pset("title", opt, &pset.popt, quiet);
+ free(opt);
+ }
/*----------
* \c or \connect -- connect to new database or as different user
*
- * \c foo bar: connect to db "foo" as user "bar"
- * \c foo [-]: connect to db "foo" as current user
- * \c - bar: connect to current db as user "bar"
- * \c: connect to default db as default user
+ * \c foo bar connect to db "foo" as user "bar"
+ * \c foo [-] connect to db "foo" as current user
+ * \c - bar connect to current db as user "bar"
+ * \c connect to default db as default user
*----------
*/
else if (strcmp(cmd, "c") == 0 || strcmp(cmd, "connect") == 0)
{
- if (options[1])
+ char *opt1, *opt2;
+ char opt1q, opt2q;
+
+ opt1 = scan_option(&string, OT_NORMAL, &opt1q);
+ opt2 = scan_option(&string, OT_NORMAL, &opt2q);
+
+ if (opt2)
/* gave username */
- success = do_connect(options[0], options[1]);
- else
- {
- if (options[0])
- /* gave database name */
- success = do_connect(options[0], ""); /* empty string is same
- * username as before,
- * NULL would mean libpq
- * default */
- else
- /* connect to default db as default user */
- success = do_connect(NULL, NULL);
- }
- }
+ success = do_connect(!opt1q && (strcmp(opt1, "-")==0 || strcmp(opt1, "")==0) ? "" : opt1,
+ !opt2q && (strcmp(opt2, "-")==0 || strcmp(opt2, "")==0) ? "" : opt2);
+ else if (opt1)
+ /* gave database name */
+ success = do_connect(!opt1q && (strcmp(opt1, "-")==0 || strcmp(opt1, "")==0) ? "" : opt1, "");
+ else
+ /* connect to default db as default user */
+ success = do_connect(NULL, NULL);
+ free(opt1);
+ free(opt2);
+ }
/* \copy */
else if (strcasecmp(cmd, "copy") == 0)
+ {
success = do_copy(options_string);
+ if (options_string)
+ string += strlen(string);
+ }
/* \copyright */
else if (strcmp(cmd, "copyright") == 0)
/* \d* commands */
else if (cmd[0] == 'd')
{
- bool show_verbose = strchr(cmd, '+') ? true : false;
+ char * name;
+ bool show_verbose;
+
+ name = scan_option(&string, OT_SQLID, NULL);
+ show_verbose = strchr(cmd, '+') ? true : false;
switch (cmd[1])
{
case '\0':
case '+':
- if (options[0] )
- success = describeTableDetails(options[0] , show_verbose);
+ if (name )
+ success = describeTableDetails(name , show_verbose);
else
/* standard listing of interesting things */
success = listTables("tvs", NULL, show_verbose);
break;
case 'a':
- success = describeAggregates(options[0] );
+ success = describeAggregates(name );
break;
case 'd':
- success = objectDescription(options[0] );
+ success = objectDescription(name );
break;
case 'f':
- success = describeFunctions(options[0] , show_verbose);
+ success = describeFunctions(name , show_verbose);
break;
case 'l':
success = do_lo_list();
break;
case 'o':
- success = describeOperators(options[0] );
+ success = describeOperators(name );
break;
case 'p':
- success = permissionsList(options[0] );
+ success = permissionsList(name );
break;
case 'T':
- success = describeTypes(options[0] , show_verbose);
+ success = describeTypes(name , show_verbose);
break;
case 't':
case 'v':
if (cmd[1] == 'S' && cmd[2] == '\0')
success = listTables("Stvs", NULL, show_verbose);
else
- success = listTables(&cmd[1], options[0] , show_verbose);
+ success = listTables(&cmd[1], name , show_verbose);
break;
default:
status = CMD_UNKNOWN;
}
+ free(name);
}
* the query buffer
*/
else if (strcmp(cmd, "e") == 0 || strcmp(cmd, "edit") == 0)
- status = do_edit(options[0], query_buf) ? CMD_NEWEDIT : CMD_ERROR;
+ {
+ char * fname;
+ if (!query_buf)
+ {
+ psql_error("no query buffer");
+ status = CMD_ERROR;
+ }
+ else
+ {
+ fname = scan_option(&string, OT_NORMAL, NULL);
+ status = do_edit(fname, query_buf) ? CMD_NEWEDIT : CMD_ERROR;
+ free(fname);
+ }
+ }
- /* \echo */
- else if (strcmp(cmd, "echo") == 0)
+ /* \echo and \qecho */
+ else if (strcmp(cmd, "echo") == 0 || strcmp(cmd, "qecho")==0 )
{
- int i;
+ char * value;
+ char quoted;
+ bool no_newline = false;
+ bool first = true;
+ FILE * fout;
+
+ if (strcmp(cmd, "qecho")==0)
+ fout = pset.queryFout;
+ else
+ fout = stdout;
- for (i = 0; i < 16 && options[i]; i++)
- fputs(options[i], stdout);
- fputs("\n", stdout);
+ while((value = scan_option(&string, OT_NORMAL, "ed)))
+ {
+ if (!quoted && strcmp(value, "-n")==0)
+ no_newline = true;
+ else
+ {
+ if (first)
+ first = false;
+ else
+ fputc(' ', fout);
+ fputs(value, fout);
+ }
+ free(value);
+ }
+ if (!no_newline)
+ fputs("\n", fout);
}
/* \f -- change field separator */
else if (strcmp(cmd, "f") == 0)
- success = do_pset("fieldsep", options[0], &pset.popt, quiet);
+ {
+ char * fname = scan_option(&string, OT_NORMAL, NULL);
+ success = do_pset("fieldsep", fname, &pset.popt, quiet);
+ free(fname);
+ }
/* \g means send query */
else if (strcmp(cmd, "g") == 0)
{
- if (!options[0])
+ char * fname = scan_option(&string, OT_NORMAL, NULL);
+ if (!fname)
pset.gfname = NULL;
else
- pset.gfname = xstrdup(options[0]);
+ pset.gfname = xstrdup(fname);
+ free(fname);
status = CMD_SEND;
}
/* help */
else if (strcmp(cmd, "h") == 0 || strcmp(cmd, "help") == 0)
{
- char buf[256] = "";
- int i;
- for (i=0; options && options[i] && strlen(buf)<255; i++)
- {
- strncat(buf, options[i], 255 - strlen(buf));
- if (strlen(buf)<255 && options[i+1])
- strcat(buf, " ");
- }
- buf[255] = '\0';
- helpSQL(buf);
+ helpSQL(options_string ? &options_string[strspn(options_string, " \t")] : NULL);
+ /* set pointer to end of line */
+ if (string)
+ string += strlen(string);
}
/* HTML mode */
/* \i is include file */
else if (strcmp(cmd, "i") == 0 || strcmp(cmd, "include") == 0)
{
- if (!options[0])
+ char * fname = scan_option(&string, OT_NORMAL, NULL);
+ if (!fname)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
- success = process_file(options[0]);
+ {
+ success = process_file(fname);
+ free (fname);
+ }
}
-
/* \l is list databases */
else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0)
success = listAllDbs(false);
else if (strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
success = listAllDbs(true);
-
- /* large object things */
+ /*
+ * large object things
+ */
else if (strncmp(cmd, "lo_", 3) == 0)
{
+ char *opt1, *opt2;
+
+ opt1 = scan_option(&string, OT_NORMAL, NULL);
+ opt2 = scan_option(&string, OT_NORMAL, NULL);
+
if (strcmp(cmd + 3, "export") == 0)
{
- if (!options[1] )
+ if (!opt2 )
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
- success = do_lo_export(options[0], options[1] );
+ success = do_lo_export(opt1, opt2 );
}
else if (strcmp(cmd + 3, "import") == 0)
{
- if (!options[0] )
+ if (!opt1 )
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
- success = do_lo_import(options[0], options[1] );
+ success = do_lo_import(opt1, opt2 );
}
else if (strcmp(cmd + 3, "list") == 0)
else if (strcmp(cmd + 3, "unlink") == 0)
{
- if (!options[0] )
+ if (!opt1 )
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
- success = do_lo_unlink(options[0] );
+ success = do_lo_unlink(opt1 );
}
else
status = CMD_UNKNOWN;
+
+ free(opt1);
+ free(opt2);
}
+
/* \o -- set query output */
else if (strcmp(cmd, "o") == 0 || strcmp(cmd, "out") == 0)
- success = setQFout(options[0]);
-
+ {
+ char * fname = scan_option(&string, OT_NORMAL, NULL);
+ success = setQFout(fname);
+ free(fname);
+ }
/* \p prints the current query buffer */
else if (strcmp(cmd, "p") == 0 || strcmp(cmd, "print") == 0)
/* \pset -- set printing parameters */
else if (strcmp(cmd, "pset") == 0)
{
- if (!options[0])
+ char * opt0 = scan_option(&string, OT_NORMAL, NULL);
+ char * opt1 = scan_option(&string, OT_NORMAL, NULL);
+ if (!opt0)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
- success = do_pset(options[0], options[1], &pset.popt, quiet);
+ success = do_pset(opt0, opt1, &pset.popt, quiet);
+
+ free(opt0);
+ free(opt1);
}
/* \q or \quit */
else if (strcmp(cmd, "q") == 0 || strcmp(cmd, "quit") == 0)
status = CMD_TERMINATE;
- /* \qecho */
- else if (strcmp(cmd, "qecho") == 0)
- {
- int i;
-
- for (i = 0; i < 16 && options[i]; i++)
- fputs(options[i], pset.queryFout);
- fputs("\n", pset.queryFout);
- }
-
/* reset(clear) the buffer */
else if (strcmp(cmd, "r") == 0 || strcmp(cmd, "reset") == 0)
{
puts("Query buffer reset (cleared).");
}
-
/* \s save history in a file or show it on the screen */
else if (strcmp(cmd, "s") == 0)
{
- const char *fname ;
+ char *fname = scan_option(&string, OT_NORMAL, NULL) ;
- if (!options[0])
- fname = "/dev/tty";
- else
- fname = options[0];
-
- success = saveHistory(fname);
+ success = saveHistory(fname ? fname : "/dev/tty");
- if (success && !quiet && options[0] )
+ if (success && !quiet && fname )
printf("Wrote history to %s.\n", fname);
+ free(fname);
}
-
- /* \set -- generalized set option command */
+ /* \set -- generalized set variable/option command */
else if (strcmp(cmd, "set") == 0)
{
- if (!options[0])
+ char * opt0 = scan_option(&string, OT_NORMAL, NULL);
+
+ if (!opt0)
{
/* list all variables */
/*
- * (This is in utter violation of the GetVariable abstraction,
- * but I have not dreamt up a better way.)
+ * XXX
+ * This is in utter violation of the GetVariable abstraction, but I
+ * have not bothered to do it better.
*/
struct _variable *ptr;
}
else
{
- const char * val = options[1];
- if (!val)
- val = "";
- if (!SetVariable(pset.vars, options[0], val))
+ /*
+ * Set variable to the concatenation of the arguments.
+ */
+ char * newval = NULL;
+ char * opt;
+
+ opt = scan_option(&string, OT_NORMAL, NULL);
+ newval = xstrdup(opt ? opt : "");
+ free(opt);
+
+ while ((opt = scan_option(&string, OT_NORMAL, NULL)))
+ {
+ newval = realloc(newval, strlen(newval) + strlen(opt) + 1);
+ if (!newval)
+ {
+ psql_error("out of memory");
+ exit(EXIT_FAILURE);
+ }
+ strcat(newval, opt);
+ free(opt);
+ }
+
+ if (!SetVariable(pset.vars, opt0, newval))
{
psql_error("\\%s: error\n", cmd);
success = false;
}
+ free(newval);
}
+ free(opt0);
}
/* \t -- turn off headers and row count */
/* \T -- define html
attributes */ else if (strcmp(cmd, "T") == 0)
- success = do_pset("tableattr", options[0], &pset.popt, quiet);
+ {
+ char * value = scan_option(&string, OT_NORMAL, NULL);
+ success = do_pset("tableattr", value, &pset.popt, quiet);
+ free(value);
+ }
/* \unset */
else if (strcmp(cmd, "unset") == 0)
{
- if (!SetVariable(pset.vars, options[0], NULL))
+ char * opt = scan_option(&string, OT_NORMAL, NULL);
+ if (!opt)
+ {
+ psql_error("\\%s: missing required argument", cmd);
+ success = false;
+ }
+ if (!SetVariable(pset.vars, opt, NULL))
{
psql_error("\\%s: error\n", cmd);
-
success = false;
- }
+ }
+ free(opt);
}
/* \w -- write query buffer to file */
else if (strcmp(cmd, "w") == 0 || strcmp(cmd, "write") == 0)
{
FILE *fd = NULL;
- bool pipe = false;
+ bool is_pipe = false;
+ char *fname = NULL;
- if (!options[0])
- {
- psql_error("\\%s: missing required argument\n", cmd);
- success = false;
- }
- else
- {
- if (options[0][0] == '|')
- {
- pipe = true;
- fd = popen(&options[0][1], "w");
- }
- else
- {
- fd = fopen(options[0], "w");
- }
+ if (!query_buf)
+ {
+ psql_error("no query buffer");
+ status = CMD_ERROR;
+ }
+ else
+ {
+ fname = scan_option(&string, OT_NORMAL, NULL);
- if (!fd)
- {
- psql_error("%s: %s\n", options[0], strerror(errno));
- success = false;
- }
- }
+ if (!fname)
+ {
+ psql_error("\\%s: missing required argument\n", cmd);
+ success = false;
+ }
+ else
+ {
+ if (fname[0] == '|')
+ {
+ is_pipe = true;
+ fd = popen(&fname[1], "w");
+ }
+ else
+ fd = fopen(fname, "w");
+
+ if (!fd)
+ {
+ psql_error("%s: %s\n", fname, strerror(errno));
+ success = false;
+ }
+ }
+ }
if (fd)
{
if (query_buf && query_buf->len > 0)
fprintf(fd, "%s\n", query_buf->data);
- if (pipe)
+ if (is_ pipe)
result = pclose(fd);
else
result = fclose(fd);
if (result == EOF)
{
- psql_error("%s: %s\n", options[0] , strerror(errno));
+ psql_error("%s: %s\n", fname , strerror(errno));
success = false;
}
}
+
+ free(fname);
}
/* \x -- toggle expanded table representation */
success = do_pset("expanded", NULL, &pset.popt, quiet);
- /* list table rights (grant/revoke) */
+ /* \z -- list table rights (grant/revoke) */
else if (strcmp(cmd, "z") == 0)
- success = permissionsList(options[0]);
-
+ {
+ char * opt = scan_option(&string, OT_SQLID, NULL);
+ success = permissionsList(opt);
+ free(opt);
+ }
+ /* \! -- shell escape */
else if (strcmp(cmd, "!") == 0)
+ {
success = do_shell(options_string);
+ /* wind pointer to end of line */
+ if (string)
+ string += strlen(string);
+ }
+ /* \? -- slash command help */
else if (strcmp(cmd, "?") == 0)
slashUsage();
-
-#if 0
+#if 1
/*
* These commands don't do anything. I just use them to test the
* parser.
*/
else if (strcmp(cmd, "void") == 0 || strcmp(cmd, "#") == 0)
{
- int i;
+ int i = 0;
+ char *value;
- fprintf(stderr, "+ optline = |%s|\n", options_string);
- for (i = 0; options[i]; i++)
- fprintf(stderr, "+ opt%d = |%s|\n", i, options[i]);
+ fprintf(stderr, "+ optstr = |%s|\n", options_string);
+ while((value = scan_option(&string, OT_NORMAL, NULL)))
+ {
+ fprintf(stderr, "+ opt(%d) = |%s|\n", i++, value);
+ free(value);
+ }
}
#endif
if (!success)
status = CMD_ERROR;
+
+ /* eat the rest of the options string */
+ while(scan_option(&string, OT_NORMAL, NULL)) ;
+
+ if (options_string && continue_parse)
+ *continue_parse = options_string + (string - string_cpy);
+ free(string_cpy);
+
return status;
}
+/*
+ * scan_option()
+ */
+static char *
+scan_option(char ** string, enum option_type type, char * quote)
+{
+ unsigned int pos = 0;
+ char * options_string;
+ char * return_val;
+
+ if (quote)
+ *quote = 0;
+
+ if (!string || !(*string))
+ return NULL;
+
+ options_string = *string;
+ /* skip leading whitespace */
+ pos += strspn(options_string+pos, " \t");
+
+ switch (options_string[pos])
+ {
+ /*
+ * Double quoted string
+ */
+ case '"':
+ {
+ unsigned int jj;
+ unsigned short int bslash_count = 0;
+
+ /* scan for end of quote */
+ for (jj = pos+1; options_string[jj]; jj += PQmblen(&options_string[jj], pset.encoding))
+ {
+ if (options_string[jj] == '"' && bslash_count % 2 == 0)
+ break;
+
+ if (options_string[jj] == '\\')
+ bslash_count++;
+ else
+ bslash_count=0;
+ }
+
+ if (options_string[jj] == 0)
+ {
+ psql_error("parse error at end of line\n");
+ *string = &options_string[jj];
+ return NULL;
+ }
+
+ return_val = malloc(jj-pos+2);
+ if (!return_val)
+ {
+ psql_error("out of memory\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (type == OT_NORMAL)
+ {
+ strncpy(return_val, &options_string[pos], jj-pos+1);
+ return_val[jj-pos+1] = '\0';
+ }
+ /*
+ * If this is expected to be an SQL identifier like option
+ * then we strip out the double quotes
+ */
+ else if (type == OT_SQLID)
+ {
+ unsigned int k, cc;
+
+ bslash_count = 0;
+ cc = 0;
+ for (k = pos+1; options_string[k]; k += PQmblen(&options_string[k], pset.encoding))
+ {
+ if (options_string[k] == '"' && bslash_count % 2 == 0)
+ break;
+
+ if (options_string[jj] == '\\')
+ bslash_count++;
+ else
+ bslash_count=0;
+
+ return_val[cc++] = options_string[k];
+ }
+ return_val[cc] = '\0';
+ }
+
+ *string = options_string + jj+1;
+ if (quote)
+ *quote = '"';
+
+ return return_val;
+ }
+
+ /*
+ * A single quote has a psql internal meaning, such as
+ * for delimiting file names, and it also allows for such
+ * escape sequences as \t.
+ */
+ case '\'':
+ {
+ unsigned int jj;
+ unsigned short int bslash_count = 0;
+
+ for (jj = pos+1; options_string[jj]; jj += PQmblen(&options_string[jj], pset.encoding))
+ {
+ if (options_string[jj] == '\'' && bslash_count % 2 == 0)
+ break;
+
+ if (options_string[jj] == '\\')
+ bslash_count++;
+ else
+ bslash_count=0;
+ }
+
+ if (options_string[jj] == 0)
+ {
+ psql_error("parse error at end of line\n");
+ *string = &options_string[jj];
+ return NULL;
+ }
+
+ return_val = unescape(&options_string[pos+1], jj-pos-1);
+ *string = &options_string[jj + 1];
+ if (quote)
+ *quote = '\'';
+ return return_val;
+ }
+
+ /*
+ * Backticks are for command substitution, like in shells
+ */
+ case '`':
+ {
+ bool error = false;
+ FILE *fd = NULL;
+ char *file;
+ PQExpBufferData output;
+ char buf[512];
+ size_t result, len;
+
+ len = strcspn(options_string + pos + 1, "`");
+ if (options_string[pos + 1 + len] == 0)
+ {
+ psql_error("parse error at end of line\n");
+ *string = &options_string[pos + 1 + len];
+ return NULL;
+ }
+
+ options_string[pos + 1 + len] = '\0';
+ file = options_string + pos + 1;
+
+ fd = popen(file, "r");
+ if (!fd)
+ {
+ psql_error("%s: %s\n", file, strerror(errno));
+ error = true;
+ }
+
+ if (!error)
+ {
+ initPQExpBuffer(&output);
+
+ do
+ {
+ result = fread(buf, 1, 512, fd);
+ if (ferror(fd))
+ {
+ psql_error("%s: %s\n", file, strerror(errno));
+ error = true;
+ break;
+ }
+ appendBinaryPQExpBuffer(&output, buf, result);
+ } while (!feof(fd));
+ appendPQExpBufferChar(&output, '\0');
+
+ if (pclose(fd) == -1)
+ {
+ psql_error("%s: %s\n", file, strerror(errno));
+ error = true;
+ }
+ }
+
+ if (!error)
+ {
+ if (output.data[strlen(output.data) - 1] == '\n')
+ output.data[strlen(output.data) - 1] = '\0';
+ }
+
+ if (!error)
+ return_val = output.data;
+ else
+ {
+ return_val = xstrdup("");
+ termPQExpBuffer(&output);
+ }
+ options_string[pos + 1 + len] = '`';
+ *string = options_string + pos + len + 2;
+ if (quote)
+ *quote = '`';
+ return return_val;
+ }
+
+ /*
+ * end of line
+ */
+ case 0:
+ *string = &options_string[pos];
+ return NULL;
+
+ /*
+ * Variable substitution
+ */
+ case ':':
+ {
+ size_t token_end;
+ const char * value;
+ char save_char;
+
+ token_end = strcspn(&options_string[pos+1], " \t");
+ save_char = options_string[pos+token_end+1];
+ options_string[pos+token_end+1] = '\0';
+ value = GetVariable(pset.vars, options_string+pos+1);
+ if (!value)
+ value = "";
+ return_val = xstrdup(value);
+ options_string[pos+token_end+1] = save_char;
+ *string = &options_string[pos + token_end+1];
+ return return_val;
+ }
+
+ /*
+ * Next command
+ */
+ case '\\':
+ *string = options_string + pos;
+ return NULL;
+ break;
+
+ /*
+ * A normal word
+ */
+ default:
+ {
+ size_t token_end;
+ char * cp;
+
+ token_end = strcspn(&options_string[pos], " \t");
+ return_val = malloc(token_end + 1);
+ if (!return_val)
+ {
+ psql_error("out of memory\n");
+ exit(EXIT_FAILURE);
+ }
+ strncpy(return_val, &options_string[pos], token_end);
+ return_val[token_end] = 0;
+
+ if (type == OT_SQLID)
+ for (cp = return_val; *cp; cp += PQmblen(cp, pset.encoding))
+ if (isascii(*cp))
+ *cp = tolower(*cp);
+
+ *string = &options_string[pos+token_end];
+ return return_val;
+ }
+
+ }
+}
+
+
+
/*
* unescape
*
* Replaces \n, \t, and the like.
- * Also interpolates ${variables}.
*
* The return value is malloc()'ed.
*/
static char *
-unescape(const char *source )
+unescape(const unsigned char *source, size_t len )
{
- unsigned char *p;
+ const unsigned char *p;
bool esc = false; /* Last character we saw was the escape
* character */
char *destination,
assert(source);
#endif
- length = strlen(source ) + 1;
+ length = Min(len, strlen(source) ) + 1;
- tmp = destination = (char *) malloc(length);
+ tmp = destination = malloc(length);
if (!tmp)
{
psql_error("out of memory\n");
exit(EXIT_FAILURE);
}
- for (p = (char *) source; *p; p += PQmblen(p, pset.encoding))
+ for (p = source; p-source < len && *p; p += PQmblen(p, pset.encoding))
{
if (esc)
{
case 'n':
c = '\n';
break;
- case 'r':
- c = '\r';
- break;
case 't':
c = '\t';
break;
+ case 'b':
+ c = '\b';
+ break;
+ case 'r':
+ c = '\r';
+ break;
case 'f':
c = '\f';
break;
else if (*p == '\\')
esc = true;
- else if (*p == '$')
- {
- if (*(p + 1) == '{')
- {
- unsigned int len;
- char *copy;
- const char *value;
-#ifndef WIN32
- void *new;
-#else
- char *new;
-#endif
-
- len = strcspn(p + 2, "}");
- copy = xstrdup(p + 2);
- copy[len] = '\0';
- value = GetVariable(pset.vars, copy);
- if (!value)
- value = "";
- length += strlen(value) - (len + 3);
- new = realloc(destination, length);
- if (!new)
- {
- psql_error("out of memory\n");
- exit(EXIT_FAILURE);
- }
- tmp = new + (tmp - destination);
- destination = new;
-
- strcpy(tmp, value);
- tmp += strlen(value);
- p += len + 2;
- free(copy);
- }
- else
- *tmp++ = '$';
- }
-
else
{
*tmp++ = *p;
-
/* do_connect
* -- handler for \connect
*
SetVariable(pset.vars, "HOST", NULL);
SetVariable(pset.vars, "PORT", NULL);
- /* If dbname is "- " then use old name, else new one (even if NULL) */
- if (oldconn && new_dbname && PQdb(oldconn) && strcmp(new_dbname, "- ") == 0)
+ /* If dbname is "" then use old name, else new one (even if NULL) */
+ if (oldconn && new_dbname && PQdb(oldconn) && strcmp(new_dbname, "") == 0)
dbparam = PQdb(oldconn);
else
dbparam = new_dbname;
/*
* Test if the given user is a database superuser.
- * (U sed to set up the prompt right.)
+ * (Is u sed to set up the prompt right.)
*/
bool
test_superuser(const char * username)
static bool
editFile(const char *fname)
{
- char *editorName;
+ const char *editorName;
char *sys;
int result;
sprintf(sys, "exec %s %s", editorName, fname);
result = system(sys);
if (result == -1)
- psql_error("could not start editor\n" );
+ psql_error("could not start editor %s\n", editorName );
else if (result == 127)
psql_error("could not start /bin/sh\n");
free(sys);
#endif
-#ifdef USE_ASSERT_CHECKING
- assert(query_buf);
-#else
- if (!query_buf)
- return false;
-#endif
-
-
if (filename_arg)
fname = filename_arg;
if (!filename)
return false;
-#ifdef __CYGWIN32__
- fd = fopen(filename, "rb");
-#else
fd = fopen(filename, "r");
-#endif
if (!fd)
{
-#define DEFAULT_SHELL "/bin/sh"
+#define DEFAULT_SHELL "/bin/sh"
static bool
do_shell(const char *command)
if (!command)
{
char *sys;
- char *shellName;
+ const char *shellName;
shellName = getenv("SHELL");
if (shellName == NULL)
*
* Copyright 2000 by PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/describe.c,v 1.15 2000/01/29 16:58:48 petere Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/describe.c,v 1.16 2000/02/07 23:10:06 petere Exp $
*/
#include
#include "describe.h"
if (name)
{
- strcat(buf, " AND a.aggname ~* '");
+ strcat(buf, " AND a.aggname ~* '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
if (name)
{
- strcat(buf, " AND a.aggname ~* '");
+ strcat(buf, " AND a.aggname ~* '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
if (name)
{
- strcat(buf, " AND p.proname ~* '");
+ strcat(buf, " AND p.proname ~* '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
if (name)
{
- strcat(buf, " AND t.typname ~* '");
+ strcat(buf, " AND t.typname ~* '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "' ");
}
" o.oprright = t2.oid\n");
if (name)
{
- strcat(buf, " AND o.oprname ~ '");
+ strcat(buf, " AND o.oprname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
" o.oprright = t1.oid\n");
if (name)
{
- strcat(buf, "AND o.oprname ~ '");
+ strcat(buf, "AND o.oprname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
" o.oprleft = t1.oid\n");
if (name)
{
- strcat(buf, "AND o.oprname ~ '");
+ strcat(buf, "AND o.oprname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
" relname !~ '^pg_'\n");
if (name)
{
- strcat(descbuf, " AND relname ~ '");
+ strcat(descbuf, " AND relname ~ '^ ");
strncat(descbuf, name, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
"WHERE a.oid = d.objoid\n");
if (object)
{
- strcat(descbuf, " AND a.aggname ~* '");
+ strcat(descbuf, " AND a.aggname ~* '^ ");
strncat(descbuf, object, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
"WHERE p.oid = d.objoid AND (p.pronargs = 0 or oidvectortypes(p.proargtypes) != '')\n");
if (object)
{
- strcat(descbuf, " AND p.proname ~* '");
+ strcat(descbuf, " AND p.proname ~* '^ ");
strncat(descbuf, object, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
"WHERE RegprocToOid(o.oprcode) = d.objoid\n");
if (object)
{
- strcat(descbuf, " AND o.oprname ~ '");
+ strcat(descbuf, " AND o.oprname ~ '^ ");
strncat(descbuf, object, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
"WHERE t.oid = d.objoid\n");
if (object)
{
- strcat(descbuf, " AND t.typname ~* '");
+ strcat(descbuf, " AND t.typname ~* '^ ");
strncat(descbuf, object, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
"WHERE c.oid = d.objoid\n");
if (object)
{
- strcat(descbuf, " AND c.relname ~* '");
+ strcat(descbuf, " AND c.relname ~* '^ ");
strncat(descbuf, object, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
"WHERE r.oid = d.objoid AND r.rulename !~ '^_RET'\n");
if (object)
{
- strcat(descbuf, " AND r.rulename ~* '");
+ strcat(descbuf, " AND r.rulename ~* '^ ");
strncat(descbuf, object, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
"WHERE t.oid = d.objoid\n");
if (object)
{
- strcat(descbuf, " AND t.tgname ~* '");
+ strcat(descbuf, " AND t.tgname ~* '^ ");
strncat(descbuf, object, REGEXP_CUTOFF);
strcat(descbuf, "'\n");
}
tmp = malloc(size);
if (!tmp)
{
- psql_error("out of memory");
+ psql_error("out of memory\n ");
exit(EXIT_FAILURE);
}
return tmp;
bool isarray = false;
/* Name */
- cells[i * cols + 0] = (char *) PQgetvalue(res, i, 0); /* don't free this afterwards */
+ cells[i * cols + 0] = PQgetvalue(res, i, 0); /* don't free this afterwards */
/* Type */
if (attype[0] == '_')
/* Description */
if (desc)
- cells[i * cols + cols-1] = (char*) PQgetvalue(res, i, 7);
+ cells[i * cols + cols-1] = PQgetvalue(res, i, 7);
}
/* Make title */
strcat(buf, showSystem ? " AND c.relname ~ '^pg_'\n" : " AND c.relname !~ '^pg_'\n");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
strcat(buf, showSystem ? " AND c.relname ~ '^pg_'\n" : " AND c.relname !~ '^pg_'\n");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
strcat(buf, showSystem ? " AND c.relname ~ '^pg_'\n" : " AND c.relname !~ '^pg_'\n");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
strcat(buf, showSystem ? " AND c.relname ~ '^pg_'\n" : " AND c.relname !~ '^pg_'\n");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
strcat(buf, showSystem ? " AND c.relname ~ '^pg_'\n" : " AND c.relname !~ '^pg_'\n");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
strcat(buf, showSystem ? " AND c.relname ~ '^pg_'\n" : " AND c.relname !~ '^pg_'\n");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
"WHERE c.relowner = u.usesysid AND c.relkind = 's'\n");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
" AND not exists (select 1 from pg_user where usesysid = c.relowner)");
if (name)
{
- strcat(buf, " AND c.relname ~ '");
+ strcat(buf, " AND c.relname ~ '^ ");
strncat(buf, name, REGEXP_CUTOFF);
strcat(buf, "'\n");
}
if (PQntuples(res) == 0 && !QUIET())
{
- if (name)
- fprintf(pset.queryFout, "No matching relations found.\n");
- else
- fprintf(pset.queryFout, "No relations found.\n");
+ if (name)
+ fprintf(pset.queryFout, "No matching relations found.\n");
+ else
+ fprintf(pset.queryFout, "No relations found.\n");
}
else
{
projects / postgresql.git / commitdiff