<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v 1.20 2000/01/14 22:18:01 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v 1.21 2000/01/18 23:30:19 petere Exp $
Postgres documentation
-->
</varlistentry>
<varlistentry>
+ <term><literal>recordsep</literal></term>
+ <listitem>
+ <para>
+ Specifies the record (line) separator to use in unaligned output mode. The default
+ is a newline character.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
<term><literal>tuples_only</literal> (or <literal>t</literal>)</term>
<listitem>
<para>
<variablelist>
<varlistentry>
<term><literal>%M</literal></term>
- <listitem><para>The hostname of the database server (or <quote>.</quote> if Unix domain socket).</para></listitem>
+ <listitem><para>The hostname of the database server (or <quote>.</quote>
+ if Unix domain socket).</para></listitem>
</varlistentry>
<varlistentry>
<term><literal>%m</literal></term>
- <listitem><para>The hostname of the database server truncated after the first dot.</para></listitem>
+ <listitem><para>The hostname of the database server truncated after the
+ first dot.</para></listitem>
</varlistentry>
<varlistentry>
<varlistentry>
<term><literal>%n</literal></term>
- <listitem><para>The username you are connected as (not your local system user name).</para></listitem>
+ <listitem><para>The username you are connected as (not your local system
+ user name).</para></listitem>
</varlistentry>
<varlistentry>
<varlistentry>
<term><literal>%~</literal></term>
- <listitem><para>Like <literal>%/</literal>, but the output is <quote>~</quote> (tilde) if the database
- is your default database.</para></listitem>
+ <listitem><para>Like <literal>%/</literal>, but the output is <quote>~</quote>
+ (tilde) if the database is your default database.</para></listitem>
</varlistentry>
<varlistentry>
<term><literal>%#</literal></term>
- <listitem><para>If the username is <literal>postgres</literal>, a <quote>#</quote>, otherwise a <quote>></quote>.</para></listitem>
+ <listitem><para>If the username is <literal>postgres</literal>, a
+ <quote>#</quote>, otherwise a <quote>></quote>.</para></listitem>
</varlistentry>
<varlistentry>
<term><literal>%R</literal></term>
<listitem><para>
- In prompt 1 normally <quote>=</quote>, but <quote>^</quote> if in single-line mode, and
- <quote>!</quote> if the session is disconnected from the database (which can only
- happen if <command>\connect</command> fails).
- In prompt 2 the sequence is replaced by <quote>-</quote>, <quote>*</quote>, a single quote,
- or a double quote, depending on whether <application>psql</application> expects more input
- because the query wasn't terminated yet, because you are inside a <literal>/* ... */</literal>
- comment, or because you are inside a quote.
- In prompt 3 the sequence doesn't resolve to anything.</para>
+ In prompt 1 normally <quote>=</quote>, but <quote>^</quote> if in single-line
+ mode, and <quote>!</quote> if the session is disconnected from the database
+ (which can happen if <command>\connect</command> fails). In prompt 2 the
+ sequence is replaced by <quote>-</quote>, <quote>*</quote>, a single quote,
+ or a double quote, depending on whether <application>psql</application>
+ expects more input because the query wasn't terminated yet, because you are
+ inside a <literal>/* ... */</literal> comment, or because you are inside
+ a quote. In prompt 3 the sequence doesn't resolve to anything.</para>
</listitem>
</varlistentry>
<varlistentry>
<term><literal>%</literal><replaceable class="parameter">digits</replaceable></term>
<listitem><para>
- If <replaceable class="parameter">digits</replaceable> starts with <literal>0x</literal>
- the rest of the characters are interpreted at a hexadecimal digit and the
- character with the corresponding code is subsituted. If the first digit is <literal>0</literal>
- the characters are interpreted as on octal number and the corresponding character
- is substituted. Otherwise a decimal number is assumed.</para>
+ If <replaceable class="parameter">digits</replaceable> starts with
+ <literal>0x</literal> the rest of the characters are interpreted at a
+ hexadecimal digit and the character with the corresponding code is
+ subsituted. If the first digit is <literal>0</literal> the characters are
+ interpreted as on octal number and the corresponding character is
+ substituted. Otherwise a decimal number is assumed.</para>
</listitem>
</varlistentry>
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.130 2000/01/18 19:08:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.131 2000/01/18 23:30:20 petere Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
| ALTER TABLE relation_name opt_inh_star DROP CONSTRAINT name drop_behavior
{
AlterTableStmt *n = makeNode(AlterTableStmt);
+ n->subtype = 'X';
n->relname = $3;
n->inh = $4;
n->name = $7;
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/command.c,v 1.13 2000/01/18 23:30:22 petere Exp $
+ */
#include <c.h>
#include "command.h"
+#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
static backslashResult exec_command(const char *cmd,
char *const * options,
const char *options_string,
- PQExpBuffer query_buf,
- int encoding);
+ PQExpBuffer query_buf);
static bool do_edit(const char *filename_arg, PQExpBuffer query_buf);
-static char * unescape(const char *source, int encoding);
+static char * unescape(const char *source);
static bool do_connect(const char *new_dbname,
const char *new_user);
backslashResult
HandleSlashCmds(const char *line,
PQExpBuffer query_buf,
- const char **end_of_cmd,
- int encoding)
+ const char **end_of_cmd)
{
backslashResult status = CMD_SKIP_LINE;
char *my_line;
* whitespace */
i = 0;
- token = strtokx(options_string, " \t", "\"'`", '\\', "e, &pos, encoding);
+ token = strtokx(options_string, " \t", "\"'`", '\\', "e, &pos, pset.encoding);
for (i = 0; token && i < NR_OPTIONS; i++)
{
switch (quote)
{
case '"':
- options[i] = unescape(token, encoding);
+ options[i] = unescape(token);
break;
case '\'':
options[i] = xstrdup(token);
{
bool error = false;
FILE *fd = NULL;
- char *file = unescape(token, encoding);
+ char *file = unescape(token);
PQExpBufferData output;
char buf[512];
size_t result;
fd = popen(file, "r");
if (!fd)
{
- perror(file);
+ psql_error("%s: %s\n", file, strerror(errno));
error = true;
}
result = fread(buf, 1, 512, fd);
if (ferror(fd))
{
- perror(file);
+ psql_error("%s: %s\n", file, strerror(errno));
error = true;
break;
}
if (pclose(fd) == -1)
{
- perror(file);
+ psql_error("%s: %s\n", file, strerror(errno));
error = true;
}
}
if (continue_parse)
break;
- token = strtokx(NULL, " \t", "\"'`", '\\', "e, &pos, encoding);
+ token = strtokx(NULL, " \t", "\"'`", '\\', "e, &pos, pset.encoding);
} /* for */
options[i] = NULL;
}
cmd = my_line;
- status = exec_command(cmd, options, options_string, query_buf, encoding);
+ status = exec_command(cmd, options, options_string, query_buf);
if (status == CMD_UNKNOWN)
{
new_cmd[0] = cmd[0];
new_cmd[1] = '\0';
- status = exec_command(new_cmd, (char *const *) new_options, my_line + 2, query_buf, encoding);
+ status = exec_command(new_cmd, (char *const *) new_options, my_line + 2, query_buf);
}
if (status == CMD_UNKNOWN)
if (pset.cur_cmd_interactive)
fprintf(stderr, "Invalid command \\%s. Try \\? for help.\n", cmd);
else
- fprintf(stderr, "%s: invalid command \\%s", pset.progname, cmd);
+ psql_error("invalid command \\%s\n", cmd);
status = CMD_ERROR;
}
exec_command(const char *cmd,
char *const * options,
const char *options_string,
- PQExpBuffer query_buf,
- int encoding)
+ PQExpBuffer query_buf)
{
bool success = true; /* indicate here if the command ran ok or
* failed */
/* \copy */
else if (strcasecmp(cmd, "copy") == 0)
- success = do_copy(options_string, encoding);
+ success = do_copy(options_string);
/* \copyright */
else if (strcmp(cmd, "copyright") == 0)
else if (strcmp(cmd, "i") == 0 || strcmp(cmd, "include") == 0)
{
if (!options[0])
- {
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: missing required argument\n", cmd);
- else
- fprintf(stderr, "%s: \\%s: missing required argument", pset.progname, cmd);
+ {
+ psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
- success = process_file(options[0], encoding);
+ success = process_file(options[0]);
}
{
if (!options[1])
{
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: missing required argument", cmd);
- else
- fprintf(stderr, "%s: \\%s: missing required argument", pset.progname, cmd);
+ psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
if (!options[0])
{
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: missing required argument", cmd);
- else
- fprintf(stderr, "%s: \\%s: missing required argument", pset.progname, cmd);
+ psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
if (!options[0])
{
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: missing required argument", cmd);
- else
- fprintf(stderr, "%s: \\%s: missing required argument", pset.progname, cmd);
+ psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
if (!options[0])
{
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: missing required argument", cmd);
- else
- fprintf(stderr, "%s: \\%s: missing required argument", pset.progname, cmd);
+ psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
val = "";
if (!SetVariable(pset.vars, options[0], val))
{
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: error\n", cmd);
- else
- fprintf(stderr, "%s: \\%s: error\n", pset.progname, cmd);
-
+ psql_error("\\%s: error\n", cmd);
success = false;
}
}
{
if (!SetVariable(pset.vars, options[0], NULL))
{
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: error\n", cmd);
- else
- fprintf(stderr, "%s: \\%s: error\n", pset.progname, cmd);
+ psql_error("\\%s: error\n", cmd);
success = false;
}
if (!options[0])
{
- if (pset.cur_cmd_interactive)
- fprintf(stderr, "\\%s: missing required argument", cmd);
- else
- fprintf(stderr, "%s: \\%s: missing required argument", pset.progname, cmd);
+ psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
if (options[0][0] == '|')
{
pipe = true;
-#ifndef __CYGWIN32__
fd = popen(&options[0][1], "w");
-#else
- fd = popen(&options[0][1], "wb");
-#endif
}
else
{
-#ifndef __CYGWIN32__
fd = fopen(options[0], "w");
-#else
- fd = fopen(options[0], "wb");
-#endif
}
if (!fd)
{
- perror(options[0]);
+ psql_error("%s: %s\n", options[0], strerror(errno));
success = false;
}
}
if (result == EOF)
{
- perror("close");
+ psql_error("%s: %s\n", options[0], strerror(errno));
success = false;
}
}
slashUsage();
-#ifdef NOT_USED
-
- /*
+#if 0
+ /*
* These commands don't do anything. I just use them to test the
* parser.
*/
* The return value is malloc()'ed.
*/
static char *
-unescape(const char *source, int encoding)
+unescape(const char *source)
{
unsigned char *p;
bool esc = false; /* Last character we saw was the escape
tmp = destination = (char *) malloc(length);
if (!tmp)
{
- perror("malloc");
+ psql_error("out of memory\n");
exit(EXIT_FAILURE);
}
- for (p = (char *) source; *p; p += PQmblen(p, encoding))
+ for (p = (char *) source; *p; p += PQmblen(p, pset.encoding))
{
if (esc)
{
new = realloc(destination, length);
if (!new)
{
- perror("realloc");
+ psql_error("out of memory\n");
exit(EXIT_FAILURE);
}
tmp = new + (tmp - destination);
if (!pwparam && oldconn)
pwparam = PQpass(oldconn);
-
-#ifdef MULTIBYTE
-
- /*
- * PGCLIENTENCODING may be set by the previous connection. if a user
- * does not explicitly set PGCLIENTENCODING, we should discard
- * PGCLIENTENCODING so that libpq could get the backend encoding as
- * the default PGCLIENTENCODING value. -- 1998/12/12 Tatsuo Ishii
- */
-
- if (!pset.has_client_encoding)
- putenv("PGCLIENTENCODING=");
-#endif
-
do
{
need_pass = false;
{
if (pset.cur_cmd_interactive)
{
- fprintf(stderr, "%s", PQerrorMessage(pset.db));
+ psql_error("%s", PQerrorMessage(pset.db));
PQfinish(pset.db);
if (oldconn)
{
{
/* we don't want unpredictable things to
* happen in scripting mode */
- fprintf(stderr, "%s: \\connect: %s", pset.progname, PQerrorMessage(pset.db));
+ psql_error("\\connect: %s", PQerrorMessage(pset.db));
PQfinish(pset.db);
if (oldconn)
PQfinish(oldconn);
success = true;
}
+ PQsetNoticeProcessor(pset.db, NoticeProcessor, NULL);
+ pset.encoding = PQclientencoding(pset.db);
+
/* Update variables */
SetVariable(pset.vars, "DBNAME", PQdb(pset.db));
SetVariable(pset.vars, "USER", PQuser(pset.db));
return false;
sprintf(sys, "exec %s %s", editorName, fname);
result = system(sys);
- if (result == -1 || result == 127)
- perror(sys);
+ if (result == -1)
+ psql_error("could not start editor\n");
+ else if (result == 127)
+ psql_error("could not start /bin/sh\n");
free(sys);
return result == 0;
if (!stream)
{
- perror(fname);
+ psql_error("couldn't open temp file %s: %s\n", fname, strerror(errno));
error = true;
}
else
if (fwrite(query_buf->data, 1, ql, stream) != ql)
{
- perror(fname);
+ psql_error("%s: %s\n", fname, strerror(errno));
fclose(stream);
remove(fname);
error = true;
#ifndef WIN32
if (!error && stat(fname, &before) != 0)
{
- perror(fname);
+ psql_error("%s: %s\n", fname, strerror(errno));
error = true;
}
#endif
#ifndef WIN32
if (!error && stat(fname, &after) != 0)
{
- perror(fname);
+ psql_error("%s: %s\n", fname, strerror(errno));
error = true;
}
stream = fopen(fname, "r");
if (!stream)
{
- perror(fname);
+ psql_error("%s: %s\n", fname, strerror(errno));
error = true;
}
else
result = fread(line, 1, 1024, stream);
if (ferror(stream))
{
- perror(fname);
+ psql_error("%s: %s\n", fname, strerror(errno));
error = true;
break;
}
/* remove temp file */
if (!filename_arg)
- remove(fname);
- }
-
+ {
+ if (remove(fname)==-1)
+ {
+ psql_error("%s: %s\n", fname, strerror(errno));
+ error=true;
+ }
+ }
+ }
return !error;
}
* Handler for \i, but can be used for other things as well.
*/
bool
-process_file(const char *filename, int encoding)
+process_file(char *filename)
{
FILE *fd;
int result;
if (!fd)
{
- if (!pset.cur_cmd_interactive)
- fprintf(stderr, "%s: ", pset.progname);
- perror(filename);
+ psql_error("%s: %s\n", filename, strerror(errno));
return false;
}
- result = MainLoop(fd, encoding);
+ pset.inputfile = filename;
+ result = MainLoop(fd);
fclose(fd);
return (result == EXIT_SUCCESS);
}
popt->topt.format = PRINT_LATEX;
else
{
- fprintf(stderr, "Allowed formats are unaligned, aligned, html, latex.\n");
+ psql_error("\\pset: allowed formats are unaligned, aligned, html, latex\n");
return false;
}
popt->topt.fieldSep = xstrdup(value);
}
if (!quiet)
- printf("Field separator is \"%s\".\n", popt->topt.fieldSep);
+ printf("Field separator is '%s'.\n", popt->topt.fieldSep);
+ }
+
+ /* record separator for unaligned text */
+ else if (strcmp(param, "recordsep") == 0)
+ {
+ if (value)
+ {
+ free(popt->topt.recordSep);
+ popt->topt.recordSep = xstrdup(value);
+ }
+ if (!quiet) {
+ if (strcmp(popt->topt.recordSep, "\n")==0)
+ printf("Record separator is <newline>.");
+ else
+ printf("Record separator is '%s'.\n", popt->topt.recordSep);
+ }
}
/* toggle between full and barebones format */
else
{
- fprintf(stderr, "Unknown option: %s\n", param);
+ psql_error("\\pset: unknown option: %s\n", param);
return false;
}
shellName = DEFAULT_SHELL;
sys = malloc(strlen(shellName) + 16);
- if (!sys)
- return false;
+ if (!sys) {
+ psql_error("out of memory\n");
+ if (pset.cur_cmd_interactive)
+ return false;
+ else
+ exit(EXIT_FAILURE);
+ }
sprintf(sys, "exec %s", shellName);
result = system(sys);
free(sys);
if (result == 127 || result == -1)
{
- perror("system");
+ psql_error("\\!: failed\n");
return false;
}
return true;
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/command.h,v 1.6 2000/01/18 23:30:23 petere Exp $
+ */
#ifndef COMMAND_H
#define COMMAND_H
-#include <config.h>
#include <c.h>
#include <pqexpbuffer.h>
#include "print.h"
-
typedef enum _backslashResult
{
CMD_UNKNOWN = 0, /* not done parsing yet (internal only) */
} backslashResult;
-
backslashResult
HandleSlashCmds(const char *line,
PQExpBuffer query_buf,
- const char **end_of_cmd, int encoding);
+ const char **end_of_cmd);
bool
-process_file(const char *filename, int encoding);
+process_file(char *filename);
bool
do_pset(const char *param,
printQueryOpt * popt,
bool quiet);
-#endif
+#endif /* COMMAND_H */
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.9 2000/01/18 23:30:23 petere Exp $
+ */
#include <c.h>
#include "common.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
+#include <stdarg.h>
#ifdef HAVE_TERMIOS_H
#include <termios.h>
#endif
if (!string)
{
- fprintf(stderr, "xstrdup: Cannot duplicate null pointer.\n");
+ fprintf(stderr, "%s: xstrdup: cannot duplicate null pointer\n", pset.progname);
exit(EXIT_FAILURE);
}
tmp = strdup(string);
if (!tmp)
{
- perror("strdup");
+ psql_error("out of memory\n");
exit(EXIT_FAILURE);
}
return tmp;
if (!(pset.queryFout))
{
- fprintf(stderr, "%s: %s: %s\n", pset.progname, fname, strerror(errno));
+ psql_error("%s: %s\n", fname, strerror(errno));
pset.queryFout = stdout;
pset.queryFoutPipe = false;
status = false;
/*
+ * Error reporting for scripts. Errors should look like
+ * filename:lineno: message
+ *
+ */
+void
+psql_error(const char *fmt, ...)
+{
+ va_list ap;
+
+ fflush(stdout);
+ if (pset.queryFout!=stdout)
+ fflush(pset.queryFout);
+
+ if (pset.inputfile)
+ fprintf(stderr, "%s:%u: ", pset.inputfile ? pset.inputfile : pset.progname, pset.lineno);
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
+}
+
+/* for backend NOTICES */
+
+void
+NoticeProcessor(void * arg, const char * message)
+{
+ (void)arg; /* not used */
+ psql_error("%s", message);
+}
+
+
+
+/*
* simple_prompt
*
* Generalized function especially intended for reading in usernames and
if (!pset.db)
{
- fputs("You are currently not connected to a database.\n", stderr);
+ psql_error("You are currently not connected to a database.\n");
return NULL;
}
{
if (!pset.cur_cmd_interactive)
{
- fprintf(stderr, "%s: connection to server was lost", pset.progname);
+ psql_error("connection to server was lost");
exit(EXIT_BADCONN);
}
fputs("The connection to the server was lost. Attempting reset: ", stderr);
return res;
else
{
- fputs(PQerrorMessage(pset.db), stderr);
+ psql_error("%s", PQerrorMessage(pset.db));
PQclear(res);
return NULL;
}
if (!pset.db)
{
- fputs("You are currently not connected to a database.\n", stderr);
+ psql_error("you are currently not connected to a database.\n");
return false;
}
case PGRES_FATAL_ERROR:
case PGRES_BAD_RESPONSE:
success = false;
- fputs(PQerrorMessage(pset.db), stderr);
+ psql_error("%s", PQerrorMessage(pset.db));
break;
}
{
if (!pset.cur_cmd_interactive)
{
- fprintf(stderr, "%s: connection to server was lost", pset.progname);
+ psql_error("connection to server was lost");
exit(EXIT_BADCONN);
}
fputs("The connection to the server was lost. Attempting reset: ", stderr);
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/common.h,v 1.4 2000/01/18 23:30:23 petere Exp $
+ */
#ifndef COMMON_H
#define COMMON_H
#include <c.h>
-#include "settings.h"
+#include <libpq-fe.h>
-char *
- xstrdup(const char *string);
+char * xstrdup(const char *string);
-bool
- setQFout(const char *fname);
+bool setQFout(const char *fname);
-char *
- simple_prompt(const char *prompt, int maxlen, bool echo);
+#ifndef __GNUC__
+void psql_error(const char *fmt, ...);
+#else
+/* This checks the format string for consistency. */
+void psql_error(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
+#endif
-PGresult *
- PSQLexec(const char *query);
+void NoticeProcessor(void * arg, const char * message);
-bool
- SendQuery(const char *query);
+char * simple_prompt(const char *prompt, int maxlen, bool echo);
+
+PGresult * PSQLexec(const char *query);
+
+bool SendQuery(const char *query);
#endif /* COMMON_H */
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/copy.c,v 1.6 2000/01/18 23:30:23 petere Exp $
+ */
#include <c.h>
#include "copy.h"
static struct copy_options *
-parse_slash_copy(const char *args, int encoding)
+parse_slash_copy(const char *args)
{
struct copy_options *result;
char *line;
if (!(result = calloc(1, sizeof(struct copy_options))))
{
- perror("calloc");
+ psql_error("out of memory\n");
exit(EXIT_FAILURE);
}
- token = strtokx(line, " \t", "\"", '\\', "e, NULL, encoding);
+ token = strtokx(line, " \t", "\"", '\\', "e, NULL, pset.encoding);
if (!token)
error = true;
else
if (!quote && strcasecmp(token, "binary") == 0)
{
result->binary = true;
- token = strtokx(NULL, " \t", "\"", '\\', "e, NULL, encoding);
+ token = strtokx(NULL, " \t", "\"", '\\', "e, NULL, pset.encoding);
if (!token)
error = true;
}
if (!error)
{
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
if (!token)
error = true;
else
{
if (strcasecmp(token, "with") == 0)
{
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
if (!token || strcasecmp(token, "oids") != 0)
error = true;
else
if (!error)
{
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
if (!token)
error = true;
}
if (!error)
{
- token = strtokx(NULL, " \t", "'", '\\', "e, NULL, encoding);
+ token = strtokx(NULL, " \t", "'", '\\', "e, NULL, pset.encoding);
if (!token)
error = true;
else if (!quote && (strcasecmp(token, "stdin")==0 || strcasecmp(token, "stdout")==0))
if (!error)
{
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
if (token)
{
if (strcasecmp(token, "using") == 0)
{
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
if (!token || strcasecmp(token, "delimiters") != 0)
error = true;
else
{
- token = strtokx(NULL, " \t", "'", '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", "'", '\\', NULL, NULL, pset.encoding);
if (token)
{
result->delim = xstrdup(token);
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
}
else
error = true;
{
if (strcasecmp(token, "with") == 0)
{
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
if (!token || strcasecmp(token, "null") != 0)
error = true;
else
{
- token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", NULL, '\\', NULL, NULL, pset.encoding);
if (!token || strcasecmp(token, "as") != 0)
error = true;
else
{
- token = strtokx(NULL, " \t", "'", '\\', NULL, NULL, encoding);
+ token = strtokx(NULL, " \t", "'", '\\', NULL, NULL, pset.encoding);
if (token)
result->null = xstrdup(token);
}
if (error)
{
- if (!pset.cur_cmd_interactive)
- fprintf(stderr, "%s: ", pset.progname);
- fputs("\\copy: parse error at ", stderr);
- if (!token)
- fputs("end of line", stderr);
- else
- fprintf(stderr, "'%s'", token);
- fputs("\n", stderr);
- free(result);
+ psql_error("\\copy: parse error at %s%s%s\n",
+ token ? "'" : "",
+ token ? token : "end of line",
+ token ? "'" : "");
+ free_copy_options(result);
return NULL;
}
else
* file or route its response into the file.
*/
bool
-do_copy(const char *args, int encoding)
+do_copy(const char *args)
{
char query[128 + NAMEDATALEN];
FILE *copystream;
bool success;
/* parse options */
- options = parse_slash_copy(args, encoding);
+ options = parse_slash_copy(args);
if (!options)
return false;
if (!copystream)
{
- if (!pset.cur_cmd_interactive)
- fprintf(stderr, "%s: ", pset.progname);
- fprintf(stderr,
- "unable to open file %s: %s\n",
- options->file, strerror(errno));
+ psql_error("%s: %s\n",
+ options->file, strerror(errno));
free_copy_options(options);
return false;
}
case PGRES_FATAL_ERROR:
case PGRES_BAD_RESPONSE:
success = false;
- fputs(PQerrorMessage(pset.db), stderr);
+ psql_error("\\copy: %s", PQerrorMessage(pset.db));
break;
default:
success = false;
- if (!pset.cur_cmd_interactive)
- fprintf(stderr, "%s: ", pset.progname);
- fprintf(stderr, "\\copy: unexpected response (%d)\n", PQresultStatus(result));
+ psql_error("\\copy: unexpected response (%d)\n", PQresultStatus(result));
}
PQclear(result);
- if (!success)
- {
- if (!pset.cur_cmd_interactive)
- fprintf(stderr, "%s: ", pset.progname);
- fprintf(stderr, "\\copy failed\n");
- }
-
if (copystream != stdout && copystream != stdin)
fclose(copystream);
free_copy_options(options);
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/copy.h,v 1.5 2000/01/18 23:30:23 petere Exp $
+ */
#ifndef COPY_H
#define COPY_H
#include <c.h>
#include <stdio.h>
#include <libpq-fe.h>
-#include "settings.h"
/* handler for \copy */
-bool
- do_copy(const char *args, int encoding);
-
+bool do_copy(const char *args);
/* lower level processors for copy in/out streams */
-bool
- handleCopyOut(PGconn *conn, FILE *copystream);
-
-bool
- handleCopyIn(PGconn *conn, FILE *copystream, const char *prompt);
+bool handleCopyOut(PGconn *conn, FILE *copystream);
+bool handleCopyIn(PGconn *conn, FILE *copystream, const char *prompt);
#endif
-#include <config.h>
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/describe.c,v 1.13 2000/01/18 23:30:23 petere Exp $
+ */
#include <c.h>
#include "describe.h"
if (!res)
return false;
- myopt.topt.tuples_only = false;
myopt.nullPrint = NULL;
myopt.title = "Object descriptions";
PQclear(result4);
}
- if (!error) {
- myopt.tuples_only = false;
- printTable(title, headers, (const char**)cells, (const char**)footers, "llll", &myopt, pset.queryFout);
- }
+ if (!error)
+ printTable(title, headers, (const char**)cells, (const char**)footers, "llll", &myopt, pset.queryFout);
/* clean up */
free(title);
}
else
{
- myopt.topt.tuples_only = false;
myopt.nullPrint = NULL;
myopt.title = "List of relations";
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/describe.h,v 1.6 2000/01/18 23:30:23 petere Exp $
+ */
#ifndef DESCRIBE_H
#define DESCRIBE_H
-#include <config.h>
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/help.c,v 1.11 2000/01/18 23:30:23 petere Exp $
+ */
#include <c.h>
#include "help.h"
puts( "\nUsage:");
puts( " psql [options] [dbname [username]]");
puts( "\nOptions:");
- puts( " -A Unaligned table output mode (-P format=unaligned");
- puts( " -c query Run only single query (or slash command) and exit");
+ puts( " -A Unaligned table output mode (-P format=unaligned)");
+ puts( " -c <query> Run only single query (or slash command) and exit");
/* Display default database */
env = getenv("PGDATABASE");
if (!env)
env = user;
- printf(" -d dbname Specify database name to connect to (default: %s)\n", env);
+ printf(" -d <dbname> Specify database name to connect to (default: %s)\n", env);
puts( " -e Echo all input in non-interactive mode");
puts( " -E Display queries that internal commands generate");
- puts( " -f filename Execute queries from file, then exit");
- puts( " -F sep Set field separator (default: \"" DEFAULT_FIELD_SEP "\") (-P fieldsep=)");
+ puts( " -f <filename> Execute queries from file, then exit");
+ puts( " -F <string> Set field separator (default: \"" DEFAULT_FIELD_SEP "\") (-P fieldsep=)");
/* Display default host */
env = getenv("PGHOST");
- printf(" -h host Specify database server host (default: ");
+ printf(" -h <host> Specify database server host (default: ");
if (env)
fputs(env, stdout);
else
puts( " -H HTML table output mode (-P format=html)");
puts( " -l List available databases, then exit");
puts( " -n Do not use readline or history");
- puts( " -o filename Send query output to filename (or |pipe)");
+ puts( " -o <filename> Send query output to filename (or |pipe)");
/* Display default port */
env = getenv("PGPORT");
- printf(" -p port Specify database server port (default: %s)\n",
+ printf(" -p <port> Specify database server port (default: %s)\n",
env ? env : "hardwired");
puts( " -P var[=arg] Set printing option 'var' to 'arg' (see \\pset command)");
env = getenv("PGUSER");
if (!env)
env = user;
- printf(" -U [username] Specifiy username, \"?\"=prompt (default user: %s)\n", env);
+ printf(" -U <username> Specifiy username, \"?\"=prompt (default user: %s)\n", env);
puts( " -x Turn on expanded table output (-P expanded)");
puts( " -v name=val Set psql variable 'name' to 'value'");
puts( " -W Prompt for password (should happen automatically)");
puts( "\nFor more information, type \"\\?\" (for internal commands) or \"\\help\"");
- puts( "(for SQL commands) from within psql, or consult the psql section in the");
- puts( "PostgreSQL manual, which accompanies the distribution and is also available at");
- puts( "<http://www.postgresql.org>.");
+ puts( "(for SQL commands) from within psql, or consult the psql section in");
+ puts( "the PostgreSQL manual, which accompanies the distribution and is also");
+ puts( "available at <http://www.postgresql.org>.");
puts( "Report bugs to <bugs@postgresql.org>.");
#ifndef WIN32
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/help.h,v 1.4 2000/01/18 23:30:23 petere Exp $
+ */
#ifndef HELP_H
#define HELP_H
-#include "settings.h"
+#include <c.h>
void usage(void);
void print_copyright(void);
-
#endif
-#include <config.h>
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/input.c,v 1.7 2000/01/18 23:30:23 petere Exp $
+ */
#include <c.h>
#include "input.h"
{
useReadline = true;
rl_readline_name = "psql";
- initialize_readline(&(pset.db));
+ initialize_readline();
}
#endif
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/input.h,v 1.5 2000/01/18 23:30:23 petere Exp $
+ */
#ifndef INPUT_H
#define INPUT_H
-#include <config.h>
#include <c.h>
#include <stdio.h>
-#include "settings.h"
-
-/* If some other file needs to have access to readline/history, include this
+/*
+ * If some other file needs to have access to readline/history, include this
* file and save yourself all this work.
*
* USE_READLINE and USE_HISTORY are the definite pointers regarding existence or not.
*/
#ifdef HAVE_LIBREADLINE
-#ifdef HAVE_READLINE_H
-#include <readline.h>
-#define USE_READLINE 1
-#else
-#if defined(HAVE_READLINE_READLINE_H)
-#include <readline/readline.h>
-#define USE_READLINE 1
-#endif
-#endif
+# ifdef HAVE_READLINE_H
+# include <readline.h>
+# define USE_READLINE 1
+# elif defined(HAVE_READLINE_READLINE_H)
+# include <readline/readline.h>
+# define USE_READLINE 1
+# endif
#endif
#if defined(HAVE_LIBHISTORY) || (defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_IN_READLINE))
-#if defined(HAVE_HISTORY_H)
-#include <history.h>
-#define USE_HISTORY 1
-#else
-#if defined(HAVE_READLINE_HISTORY_H)
-#include <readline/history.h>
-#define USE_HISTORY 1
-#endif
+# ifdef HAVE_HISTORY_H
+# include <history.h>
+# define USE_HISTORY 1
+# elif defined(HAVE_READLINE_HISTORY_H)
+# include <readline/history.h>
+# define USE_HISTORY 1
+# endif
#endif
-#endif
-
char * gets_interactive(const char *prompt);
-
char * gets_fromFile(FILE *source);
-
void initializeInput(int flags);
-
bool saveHistory(const char *fname);
-
void finishInput(void);
-#endif
+#endif /* INPUT_H */
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/large_obj.c,v 1.6 2000/01/18 23:30:23 petere Exp $
+ */
#include <c.h>
#include "large_obj.h"
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/large_obj.h,v 1.6 2000/01/18 23:30:23 petere Exp $
+ */
#ifndef LARGE_OBJ_H
#define LARGE_OBJ_H
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/mainloop.c,v 1.15 2000/01/18 23:30:23 petere Exp $
+ */
#include <c.h>
#include "mainloop.h"
* FIXME: rewrite this whole thing with flex
*/
int
-MainLoop(FILE *source, int encoding)
+MainLoop(FILE *source)
{
PQExpBuffer query_buf; /* buffer for query being accumulated */
PQExpBuffer previous_buf; /* if there isn't anything in the new buffer
FILE *prev_cmd_source;
bool prev_cmd_interactive;
+ unsigned int prev_lineno;
bool die_on_error;
previous_buf = createPQExpBuffer();
if (!query_buf || !previous_buf)
{
- perror("createPQExpBuffer");
+ psql_error("out of memory");
exit(EXIT_FAILURE);
}
in_quote = 0;
paren_level = 0;
slashCmdStatus = CMD_UNKNOWN; /* set default */
+ prev_lineno = pset.lineno;
+ pset.lineno = 0;
/* main loop to get queries and execute them */
if (getout)
{
- putc('\n', stdout); /* just newline */
+ if (QUIET())
+ putc('\n', stdout);
+ else
+ puts("\\q");
break;
}
else
else
count_eof = 0;
+ pset.lineno++;
+
/* strip trailing backslashes, they don't have a clear meaning */
while (1)
{
var = GetVariable(pset.vars, "ECHO");
if (var && strcmp(var, "full")==0)
puts(line);
- fflush(stdout);
+ fflush(stdout);
len = strlen(line);
query_start = 0;
* The current character is at line[i], the prior character at line[i
* - prevlen], the next character at line[i + thislen].
*/
-#define ADVANCE_1 (prevlen = thislen, i += thislen, thislen = PQmblen(line+i, encoding))
+#define ADVANCE_1 (prevlen = thislen, i += thislen, thislen = PQmblen(line+i, pset.encoding))
success = true;
- for (i = 0, prevlen = 0, thislen = (len > 0) ? PQmblen(line, encoding) : 0;
+ for (i = 0, prevlen = 0, thislen = (len > 0) ? PQmblen(line, pset.encoding) : 0;
i < len;
ADVANCE_1)
{
new = malloc(len + out_length - (1 + in_length) + 1);
if (!new)
{
- perror("malloc");
+ psql_error("out of memory");
exit(EXIT_FAILURE);
}
/* handle backslash command */
slashCmdStatus = HandleSlashCmds(&line[i],
query_buf->len>0 ? query_buf : previous_buf,
- &end_of_cmd, encoding);
+ &end_of_cmd);
success = slashCmdStatus != CMD_ERROR;
pset.cur_cmd_source = prev_cmd_source;
pset.cur_cmd_interactive = prev_cmd_interactive;
+ pset.lineno = prev_lineno;
return successResult;
} /* MainLoop() */
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/mainloop.h,v 1.5 2000/01/18 23:30:24 petere Exp $
+ */
#ifndef MAINLOOP_H
#define MAINLOOP_H
#include <stdio.h>
-int MainLoop(FILE *source, int encoding);
+int MainLoop(FILE *source);
#endif /* MAINLOOP_H */
-#include <config.h>
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/print.c,v 1.8 2000/01/18 23:30:24 petere Exp $
+ */
#include <c.h>
#include "print.h"
static void
print_unaligned_text(const char *title, const char * const * headers,
const char * const * cells, const char * const * footers,
- const char *opt_fieldsep, bool opt_barebones,
+ const char *opt_fieldsep, const char *opt_recordsep, bool opt_barebones,
FILE *fout)
{
unsigned int col_count = 0;
unsigned int i;
const char * const * ptr;
+ bool need_recordsep = false;
if (!opt_fieldsep)
opt_fieldsep = "";
+ if (!opt_recordsep)
+ opt_recordsep = "";
/* print title */
if (!opt_barebones && title)
- fprintf(fout, "%s\n", title);
+ fprintf(fout, "%s%s", title, opt_recordsep);
/* print headers and count columns */
for (ptr = headers; *ptr; ptr++)
}
}
if (!opt_barebones)
- fputs("\n", fout);
+ need_recordsep = true;
/* print cells */
i = 0;
for (ptr = cells; *ptr; ptr++)
{
+ if (need_recordsep)
+ {
+ fputs(opt_recordsep, fout);
+ need_recordsep = false;
+ }
fputs(*ptr, fout);
if ((i + 1) % col_count)
fputs(opt_fieldsep, fout);
else
- fputs("\n", fout);
+ need_recordsep = true;
i++;
}
if (!opt_barebones && footers)
for (ptr = footers; *ptr; ptr++)
- fprintf(fout, "%s\n", *ptr);
+ {
+ if (need_recordsep)
+ {
+ fputs(opt_recordsep, fout);
+ need_recordsep = false;
+ }
+ fputs(*ptr, fout);
+ need_recordsep = true;
+ }
+ /* the last record needs to be concluded with a newline */
+ if (need_recordsep)
+ fputc('\n', fout);
}
static void
print_unaligned_vertical(const char *title, const char * const * headers,
const char * const * cells, const char * const * footers,
- const char *opt_fieldsep, bool opt_barebones,
+ const char *opt_fieldsep, const char *opt_recordsep, bool opt_barebones,
FILE *fout)
{
unsigned int col_count = 0;
unsigned int i;
- unsigned int record = 1;
const char * const * ptr;
if (!opt_fieldsep)
opt_fieldsep = "";
+ if (!opt_recordsep)
+ opt_recordsep = "";
/* print title */
if (!opt_barebones && title)
- fprintf(fout, "%s\n", title);
+ fputs(title, fout);
/* count columns */
for (ptr = headers; *ptr; ptr++)
/* print records */
for (i = 0, ptr = cells; *ptr; i++, ptr++)
{
- if (i % col_count == 0)
- {
- if (!opt_barebones)
- fprintf(fout, "-- RECORD %d\n", record++);
- else
- fputc('\n', fout);
- }
- fprintf(fout, "%s%s%s\n", headers[i % col_count], opt_fieldsep, *ptr);
+ if (i!=0 || (!opt_barebones && title))
+ {
+ fputs(opt_recordsep, fout);
+ if (i % col_count == 0)
+ fputs(opt_recordsep, fout); /* another one */
+ }
+
+ fputs(headers[i % col_count], fout);
+ fputs(opt_fieldsep, fout);
+ fputs(*ptr, fout);
}
/* print footers */
-
- if (!opt_barebones && footers)
+ if (!opt_barebones && footers && *footers)
{
- fputs("--- END ---\n", fout);
+ fputs(opt_recordsep, fout);
for (ptr = footers; *ptr; ptr++)
- fprintf(fout, "%s\n", *ptr);
+ {
+ fputs(opt_recordsep, fout);
+ fputs(*ptr, fout);
+ }
}
+
+ fputc('\n', fout);
}
/* print title */
if (!opt_barebones && title)
{
- fputs("\begin{center}\n", fout);
+ fputs("\\begin{center}\n", fout);
latex_escaped_print(title, fout);
- fputs("\n\end{center}\n\n", fout);
+ fputs("\n\\end{center}\n\n", fout);
}
/* begin environment and set alignments and borders */
/* print title */
if (!opt_barebones && title)
{
- fputs("\begin{center}\n", fout);
+ fputs("\\begin{center}\n", fout);
latex_escaped_print(title, fout);
- fputs("\n\end{center}\n\n", fout);
+ fputs("\n\\end{center}\n\n", fout);
}
/* begin environment and set alignments and borders */
{
case PRINT_UNALIGNED:
if (opt->expanded)
- print_unaligned_vertical(title, headers, cells, footers, opt->fieldSep, opt->tuples_only, output);
+ print_unaligned_vertical(title, headers, cells, footers, opt->fieldSep, opt->recordSep, opt->tuples_only, output);
else
- print_unaligned_text(title, headers, cells, footers, opt->fieldSep, opt->tuples_only, output);
+ print_unaligned_text(title, headers, cells, footers, opt->fieldSep, opt->recordSep, opt->tuples_only, output);
break;
case PRINT_ALIGNED:
if (opt->expanded)
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/print.h,v 1.5 2000/01/18 23:30:24 petere Exp $
+ */
#ifndef PRINT_H
#define PRINT_H
unsigned short int border; /* Print a border around the table.
* 0=none, 1=dividing lines, 2=full */
char *fieldSep; /* field separator for unaligned text mode */
+ char *recordSep; /* record separator for unaligned text mode */
char *tableAttr; /* attributes for HTML <table ...> */
} printTableOpt;
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/prompt.c,v 1.6 2000/01/18 23:30:24 petere Exp $
+ */
#include <c.h>
#include "prompt.h"
* get_prompt
*
* Returns a statically allocated prompt made by interpolating certain
- * tcsh style escape sequences into pset->vars "PROMPT1|2|3".
+ * tcsh style escape sequences into pset.vars "PROMPT1|2|3".
* (might not be completely multibyte safe)
*
* Defined interpolations are:
* %$name$ - The value of the psql variable 'name'
* (those will not be rescanned for more escape sequences!)
*
- *
* If the application-wide prompts became NULL somehow, the returned string
* will be empty (not NULL!).
*--------------------------
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/prompt.h,v 1.4 2000/01/18 23:30:24 petere Exp $
+ */
#ifndef PROMPT_H
#define PROMPT_H
-#include "settings.h"
+#include <c.h>
typedef enum _promptStatus
{
PROMPT_COPY
} promptStatus_t;
-const char *
- get_prompt(promptStatus_t status);
-
+const char *get_prompt(promptStatus_t status);
#endif /* PROMPT_H */
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/settings.h,v 1.7 2000/01/18 23:30:24 petere Exp $
+ */
#ifndef SETTINGS_H
#define SETTINGS_H
-#include <config.h>
+
#include <c.h>
#include <stdio.h>
#include "print.h"
#define DEFAULT_FIELD_SEP "|"
+#define DEFAULT_RECORD_SEP "\n"
#define DEFAULT_EDITOR "vi"
#define DEFAULT_PROMPT1 "%/%R%# "
typedef struct _psqlSettings
{
PGconn *db; /* connection to backend */
+ int encoding;
FILE *queryFout; /* where to send the query results */
bool queryFoutPipe; /* queryFout is from a popen() */
* loop */
bool cur_cmd_interactive;
- bool has_client_encoding; /* was PGCLIENTENCODING set on
- * startup? */
char *progname; /* in case you renamed psql */
+ char *inputfile; /* for error reporting */
+ unsigned lineno; /* also for error reporting */
} PsqlSettings;
extern PsqlSettings pset;
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/startup.c,v 1.16 2000/01/18 23:30:24 petere Exp $
+ */
#include <c.h>
#include <signal.h>
pset.cur_cmd_source = stdin;
pset.cur_cmd_interactive = false;
+ pset.encoding = PQenv2encoding();
pset.vars = CreateVariableSpace();
pset.popt.topt.format = PRINT_ALIGNED;
pset.queryFout = stdout;
- pset.popt.topt.fieldSep = strdup(DEFAULT_FIELD_SEP);
+ pset.popt.topt.fieldSep = xstrdup(DEFAULT_FIELD_SEP);
+ pset.popt.topt.recordSep = xstrdup(DEFAULT_RECORD_SEP);
pset.popt.topt.border = 1;
- pset.popt.topt.pager = 1;
+ pset.popt.topt.pager = true;
SetVariable(pset.vars, "PROMPT1", DEFAULT_PROMPT1);
SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);
pset.getPassword = false;
#endif
-#ifdef MULTIBYTE
- pset.has_client_encoding = (getenv("PGCLIENTENCODING") != NULL);
-#endif
-
parse_options(argc, argv, &options);
if (options.action == ACT_LIST_DB)
if (PQstatus(pset.db) == CONNECTION_BAD)
{
- fprintf(stderr, "%s: connection to database '%s' failed.\n%s",
- pset.progname, PQdb(pset.db), PQerrorMessage(pset.db));
+ fprintf(stderr, "%s: connection to database \"%s\" failed - %s",
+ pset.progname, PQdb(pset.db), PQerrorMessage(pset.db));
PQfinish(pset.db);
exit(EXIT_BADCONN);
}
+ PQsetNoticeProcessor(pset.db, NoticeProcessor, NULL);
+ /*
+ * We need to save the encoding because we want to have it
+ * available even if the database connection goes bad.
+ */
+ pset.encoding = PQclientencoding(pset.db);
+
if (options.action == ACT_LIST_DB)
{
int success = listAllDbs(false);
/* process file given by -f */
if (options.action == ACT_FILE)
- successResult = process_file(options.action_string, PQclientencoding(pset.db)) ? 0 : 1;
+ successResult = process_file(options.action_string) ? 0 : 1;
/* process slash command if one was given to -c */
else if (options.action == ACT_SINGLE_SLASH)
- successResult = HandleSlashCmds(options.action_string, NULL, NULL, PQclientencoding(pset.db)) != CMD_ERROR ? 0 : 1;
+ successResult = HandleSlashCmds(options.action_string, NULL, NULL) != CMD_ERROR ? 0 : 1;
/* If the query given to -c was a normal one, send it */
else if (options.action == ACT_SINGLE_QUERY)
successResult = SendQuery( options.action_string) ? 0 : 1;
{
process_psqlrc();
initializeInput(options.no_readline ? 0 : 1);
- successResult = MainLoop(stdin, PQclientencoding(pset.db));
+ successResult = MainLoop(stdin);
finishInput();
}
static struct option long_options[] = {
{"no-align", no_argument, NULL, 'A'},
{"command", required_argument, NULL, 'c'},
- {"database", required_argument, NULL, 'd'},
{"dbname", required_argument, NULL, 'd'},
{"echo", no_argument, NULL, 'e'},
{"echo-hidden", no_argument, NULL, 'E'},
pset.getPassword = true;
break;
case '?':
- usage();
- exit(EXIT_SUCCESS);
+ if (strcmp(argv[optind-1], "-?")==0)
+ {
+ usage();
+ exit(EXIT_SUCCESS);
+ }
+ else
+ {
+ fputs("Try -? for help.\n", stderr);
+ exit(EXIT_FAILURE);
+ }
break;
#ifndef HAVE_GETOPT_LONG
case '-':
break;
#endif
default:
- usage();
+ fputs("Try -? for help.\n", stderr);
exit(EXIT_FAILURE);
break;
}
{
char *psqlrc;
char *home;
- int encoding;
#ifdef WIN32
#define R_OK 0
#endif
- /* get client side encoding from envrionment variable if any */
- encoding = PQenv2encoding();
-
/* System-wide startup file */
if (access("/etc/psqlrc-" PG_RELEASE "." PG_VERSION "." PG_SUBVERSION, R_OK) == 0)
- process_file("/etc/psqlrc-" PG_RELEASE "." PG_VERSION "." PG_SUBVERSION, encoding);
+ process_file("/etc/psqlrc-" PG_RELEASE "." PG_VERSION "." PG_SUBVERSION);
else if (access("/etc/psqlrc", R_OK) == 0)
- process_file("/etc/psqlrc", encoding);
+ process_file("/etc/psqlrc");
/* Look for one in the home dir */
home = getenv("HOME");
psqlrc = (char *) malloc(strlen(home) + 20);
if (!psqlrc)
{
- perror("malloc");
+ fprintf(stderr, "%s: out of memory\n", pset.progname);
exit(EXIT_FAILURE);
}
sprintf(psqlrc, "%s/.psqlrc-" PG_RELEASE "." PG_VERSION "." PG_SUBVERSION, home);
if (access(psqlrc, R_OK) == 0)
- process_file(psqlrc, encoding);
+ process_file(psqlrc);
else
{
sprintf(psqlrc, "%s/.psqlrc", home);
if (access(psqlrc, R_OK) == 0)
- process_file(psqlrc, encoding);
+ process_file(psqlrc);
}
free(psqlrc);
}
-#include <config.h>
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/stringutils.c,v 1.22 2000/01/18 23:30:24 petere Exp $
+ */
#include <c.h>
#include "stringutils.h"
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/stringutils.h,v 1.12 2000/01/18 23:30:24 petere Exp $
+ */
#ifndef STRINGUTILS_H
#define STRINGUTILS_H
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.c,v 1.7 2000/01/18 23:30:24 petere Exp $
+ */
+
/*-----------
This file implements a somewhat more sophisticated readline "TAB completion"
in psql. It is not intended to be AI, to replace learning SQL, or to relieve
gracefully.
-------------*/
-#include <config.h>
#include <c.h>
#include "tab-complete.h"
#include <libpq-fe.h>
#include "common.h"
-
+#include "settings.h"
#define BUF_SIZE 2048
#define ERROR_QUERY_TOO_LONG /* empty */
-/* This pointer saves the place where psql stores its own pointer to the
- currently active database connection. This is probably a less than ideal way
- of passing this around, but this way I only had to make minimal changes to
- psql.c. */
-static PGconn ** database_connection;
-
/* Forward declaration of functions */
static char ** psql_completion(char *text, int start, int end);
static int completion_max_records;
-static void * xmalloc(size_t length)
-{
- void *tmp = malloc(length);
- if (!tmp) {
- perror("malloc");
- exit(EXIT_FAILURE);
- }
- return tmp;
-}
-
-
/* Initialize the readline library for our purposes. */
-void initialize_readline(PGconn ** conn)
+void initialize_readline(void)
{
- rl_readline_name = "psql";
+ rl_readline_name = pset.progname;
rl_attempted_completion_function = psql_completion;
rl_special_prefixes = "()'";
completion_max_records = 100;
/* There is a variable rl_completion_query_items for this but apparently
it's not defined everywhere. */
-
- database_connection = conn;
}
COMPLETE_WITH_LIST(sql_commands);
else if (strcmp(prev_wd, "\\pset")==0) {
char * my_list[] = { "format", "border", "expanded", "null", "fieldsep",
- "tuples_only", "title", "tableattr", "pager", NULL };
+ "tuples_only", "title", "tableattr", "pager",
+ "recordsep", NULL };
COMPLETE_WITH_LIST(my_list);
}
else if( strcmp(prev_wd, "\\e")==0 || strcmp(prev_wd, "\\edit")==0 ||
PGresult * result;
char query_buffer[BUF_SIZE];
- if (query == NULL || PQstatus(*database_connection) != CONNECTION_OK)
+ if (query == NULL || !pset.db || PQstatus(pset.db) != CONNECTION_OK)
return NULL;
#ifdef USE_ASSERT_CHECKING
assert( query[strlen(query)-1] != ';' );
return NULL;
}
- result = PQexec(*database_connection, query);
+ result = PQexec(pset.db, query);
if (result != NULL && PQresultStatus(result) != PGRES_TUPLES_OK) {
-#ifdef NOT_USED
- fprintf(stderr, "\nThe completion query \"%s\" failed thus: %s\n",
- query, PQresStatus(PQresultStatus(result)));
+#if 0
+ psql_error("tab completion: %s failed - %s",
+ query, PQresStatus(PQresultStatus(result)));
#endif
PQclear(result);
result = NULL;
}
/* make a copy */
- s = (char *)xmalloc(end-start+2);
+ s = (char *)malloc(end-start+2);
+ if (!s)
+ {
+ psql_error("out of memory\n");
+ if (!pset.cur_cmd_interactive)
+ exit(EXIT_FAILURE);
+ else
+ return NULL;
+ }
+
strncpy(s, &rl_line_buffer[start], end-start+1);
s[end-start+1] = '\0';
-#ifdef NOT_USED
+#if 0
-/* Surround a string with single quotes. This works for both SQL and
- psql internal. Doesn't work so well yet.
-*/
+/*
+ * Surround a string with single quotes. This works for both SQL and
+ * psql internal. Currently disable because it is reported not to
+ * cooperate with certain versions of readline.
+ */
char * quote_file_name(char *text, int match_type, char * quote_pointer)
{
char *s;
(void)quote_pointer; /* not used */
length = strlen(text) + ( match_type==SINGLE_MATCH ? 3 : 2 );
- s = xmalloc(length);
+ s = malloc(length);
s[0] = '\'';
strcpy(s+1, text);
if (match_type==SINGLE_MATCH)
return xstrdup(text);
length = strlen(text);
- s = xmalloc(length-2+1);
+ s = malloc(length-2+1);
strncpy(s, text+1, length-2);
s[length] = '\0';
return s;
}
-#endif /* NOT_USED */
+#endif /* 0 */
#endif /* USE_READLINE */
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.h,v 1.2 2000/01/18 23:30:24 petere Exp $
+ */
#ifndef TAB_COMPLETE_H
#define TAB_COMPLETE_H
-#include <libpq-fe.h>
-
-void initialize_readline(PGconn ** conn);
+void initialize_readline(void);
#endif
-#include <config.h>
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/variables.c,v 1.4 2000/01/18 23:30:24 petere Exp $
+ */
#include <c.h>
#include "variables.h"
-/* This implements a sort of variable repository. One could also think of it
+/*
+ * psql - the PostgreSQL interactive terminal
+ *
+ * Copyright 2000 by PostgreSQL Global Development Team
+ *
+ * $Header: /cvsroot/pgsql/src/bin/psql/variables.h,v 1.4 2000/01/18 23:30:24 petere Exp $
+ */
+
+/*
+ * This implements a sort of variable repository. One could also think of it
* as cheap version of an associative array. In each one of these
* datastructures you can store name/value pairs.
*
OSDN Git Service
