psql

If the current table output format is unaligned, switch to aligned. If it is not unaligned, set it to unaligned. This command is kept for backwards compatibility. See \pset for a general solution.

Set the title of any tables being printed as the result of a query or unset any such title. This command is equivalent to \pset title title. (The name of this command derives from "caption", as it was previously only used to set the caption in an HTML table.)

Establishes a connection to a new database and/or under a user name. The previous connection is closed. If dbname is - the current database name is assumed.

If username is omitted the current user name is assumed.

As a special rule, \connect without any arguments will connect to the default database as the default user (as you would have gotten by starting psql without any arguments).

If the connection attempt failed (wrong username, access denied, etc.) the 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 scripts are not accidentally acting on the wrong database on the other hand.

Performs a frontend (client) copy. This is an operation that runs an SQL COPY command, but instead of the backend reading or writing the specified file, and consequently requiring backend access and special user privilege, as well as being bound to the file system accessible by the backend, psql reads or writes the file and routes the data to or from the backend onto the local file system.

The syntax of the command is in analogy to the SQL COPY command, see its description for the details. Note that because of this, special parsing rules apply to the \copy command. In particular, the variable substitution rules and backslash escapes do not apply.

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 the other technique may be preferable.

Note the difference in interpretation of stdin and stdout between frontend and backend copies: In a frontend copy these always refer to psql's input and output stream. On a backend copy stdin comes from whereever the COPY itself came from (for example, a script ran with the -f) option, and stdout refers to the query output stream (see \o meta-command below).

Shows the copyright and distribution terms of PostgreSQL.

Shows all columns of relation (which could be a table, view, index, or sequence), their types, and any special attributes such as NOT NULL or defaults, if any. If the relation is, in fact, a table, any defined indices are also listed. If the relation is a view, the view definition is also shown.

The command form \d+ is identical, but any comments associated with the table columns are shown as well.

If \d is called without any arguments, it is equivalent to \dtvs which will show a list of all tables, views, and sequences. This is purely a convenience measure.

Lists all available aggregate functions, together with the data type they operate on. If pattern (a regular expression) is specified, only matching aggregates are shown.

Shows the descriptions of object (which can be a regular expression), or of all objects if no argument is given. ("Object" covers aggregates, functions, operators, types, relations (tables, views, indices, sequences, large objects), rules, and triggers.) For example:

=> \dd version
              Object descriptions
  Name   |   What   |        Description
---------+----------+---------------------------
 version | function | PostgreSQL version string
(1 row)

Descriptions for objects can be generated with the COMMENT ON SQL command.

PostgreSQL stores the object descriptions in the pg_description system table.

Lists available functions, together with their argument and return types. If pattern (a regular expression) is specified, only matching functions are shown. If the form \df+ is used, additional information about each function, including language and description is shown.

This is not the actual command name: The letters i, s, t, v, S stand for index, sequence, table, view, and system table, respectively. You can specify any or all of them in any order to obtain a listing of them, together with who the owner is.

If pattern is specified, it is a regular expression restricts the listing to those objects whose name matches. If one appends a "+" to the command name, each object is listed with its associated description, if any.

This is an alias for \lo_list, which shows a list of large objects.

Lists available operators with their operand and return types. If pattern is specified, only operators with that name will be shown. (Since this is a regular expression, be sure to quote all special characters in you operator name with backslashes. To prevent interpretation of the backslash as a new command, you might also wish to quote the argument.)

This is an alias for \z which was included for its greater mnemonic value ("display permissions").

Lists all data types or only those that match pattern. The command form \dT+ shows extra information.

If filename is specified, the file is edited and after the editor exit its content is copied back to the query buffer. If no argument is given, the current query buffer is copied to a temporary file which is then edited in the same fashion.

The new query buffer is then re-parsed according to the normal rules of psql, where the whole buffer is treated as a single line. (Thus you cannot make "scripts" this way, use \i for that.) This means also that if the query ends with (or rather contains) a semicolon, it is immediately executed. In other cases it will merely wait in the query buffer.

psql searches the environment variables PSQL_EDITOR, EDITOR, and VISUAL (in that order) for an editor to use. If all of them are unset, /bin/vi is run.

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 you use the \o command to redirect your query output you may wish to use \qecho instead of this command.

Sets the client encoding, if you are using multibyte encodings. Without an argument, this command shows the current encoding.

Sets the field separator for unaligned query output. The default is "|" (a "pipe" symbol). See also \pset for a generic way of setting output options.

Sends the current query input buffer to the backend and optionally saves the output in filename or pipes the output into a separate Unix shell to execute command. A bare \g is virtually equivalent to a semicolon. A \g with argument is a "one-shot" alternative to the \o command.

Give syntax help on the specified SQL command. If command is not specified, then psql will list all the commands for which syntax help is available. If command is an asterisk ("*"), then syntax help on all SQL commands is shown.

To simplify typing, commands that consists of several words do not have to be quoted. Thus it is fine to type \help alter table.

Turns on HTML query output format. If the HTML format is already on, it is switched back to the default aligned text format. This command is for compatibility and convenience, but see \pset about setting other output options.

Reads input from the file filename and executes it as though it had been typed on the keyboard.

If you want to see the lines on the screen as they are read you must set the variable ECHO to all.

List all the databases in the server as well as their owners. Append a "+" to the command name to see any descriptions for the databases as well. If your PostgreSQL installation was compiled with multibyte encoding support, the encoding scheme of each database is shown as well.

Reads the large object with OID loid from the database and writes it to filename. Note that this is subtly different from the server function lo_export, which acts with the permissions of the user that the database server runs as and on the server's file system.

Use \lo_list to find out the large object's OID.

See the description of the LO_TRANSACTION variable for important information concerning all large object operations.

Stores the file into a PostgreSQL "large object". Optionally, it associates the given comment with the object. Example:

foo=> \lo_import '/home/peter/pictures/photo.xcf' 'a picture of me'
lo_import 152801

Note that this command is subtly different from the server-side lo_import because it acts as the local user on the local file system, rather than the server's user and file system.

See the description of the LO_TRANSACTION variable for important information concerning all large object operations.

Shows a list of all PostgreSQL "large objects" currently stored in the database along with their owners.

Deletes the large object with OID loid from the database.

Use \lo_list to find out the large object's OID.

See the description of the LO_TRANSACTION variable for important information concerning all large object operations.

Saves future query results to the file filename or pipe future results into a separate Unix shell to execute command. If no arguments are specified, the query output will be reset to stdout.

"Query results" includes all tables, command responses, and notices obtained from the database server, as well as output of various backslash commands that query the database (such as \d), but not error messages.

To intersperse text output in between query results, use \qecho.

Print the current query buffer to the standard output.

This command sets options affecting the output of query result tables. parameter describes which option is to be set. The semantics of value depend thereon.

Adjustable printing options are:

There are various shortcut commands for \pset. See \a, \C, \H, \t, \T, and \x.

It is an error to call \pset without arguments. In the future this call might show the current status of all printing options.

Quit the psql program.

This command is identical to \echo except that all output will be written to the query output channel, as set by \o.

Resets (clears) the query buffer.

Print or save the command line history to filename. If filename is omitted, the history is written to the standard output. This option is only available if psql is configured to use the GNU history library.

As of psql version 7.0 it is no longer necessary, in fact, to save the command history as that will be done automatically on program termination. The history is then also automatically loaded every time psql starts up.

Sets the internal variable name 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.

Valid variable names can contain characters, digits, and underscores. See the section about psql variables for details.

Although you are welcome to set any variable to anything you want to, psql treats several variables special. They are documented in the section about variables.

This command is totally separate from the SQL command SET.

Toggles the display of output column name headings and row count footer. This command is equivalent to \pset tuples_only and is provided for convenience.

Allows you to specify options to be placed within the table tag in HTML tabular output mode. This command is equivalent to \pset tableattr table_options.

Outputs the current query buffer to the file filename or pipes it to the Unix command command.

Toggles extended row format mode. As such it is equivalent to \pset expanded.

Produces a list of all tables in the database with their appropriate access permissions listed. If an argument is given it is taken as a regular expression which limits the listing to those tables which match it.

test=> \z
Access permissions for database "test"
 Relation |           Access permissions
----------+-------------------------------------
 my_table | {"=r","joe=arwR", "group staff=ar"}
(1 row )

• "=r": PUBLIC has read (SELECT) permission on the table.

• "joe=arwR": User joe has read, write (UPDATE, DELETE), "append" (INSERT) permissions, and permission to create rules on the table.

• "group staff=ar": Group staff has SELECT and INSERT permission.

The commands GRANT and REVOKE are used to set access permissions.

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.

Get help information about the slash ("\") commands.

Print all the lines to the screen as they are read. This is more useful for script processing rather than interactive mode. This is equivalent to setting the variable ECHO to all.

Switches to unaligned output mode. (The default output mode is otherwise aligned.)

Specifies that psql is to execute one query string, query, and then exit. This is useful in shell scripts.

query must be either a query string that is completely parseable by the backend (i.e., it contains no psql 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, like so: echo "\x \\ select * from foo;" | psql.

Specifies the name of the database to connect to. This is equivalent to specifying dbname as the first non-option argument on the command line.

Show all queries that are sent to the backend. This is equivalent to setting the variable ECHO to queries.

Echos the actual queries generated by \d and other backslash commands. You can use this if you wish to include similar functionality into your own programs. This is equivalent to setting the variable ECHO_HIDDEN from within psql.

Use the file filename as the source of queries instead of reading queries interactively. 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.

Use separator as the field separator. This is equivalent to \pset fieldsep or \f.

Specifies the host name of the machine on which the postmaster is running. Without this option, communication is performed using local Unix domain sockets.

Turns on HTML tabular output. This is equivalent to \pset format html or the \H command.

Lists all available databases, then exits. Other non-connection options are ignored. This is similar to the internal command \list.

Put all query output into file filename. This is equivalent to the command \o.

Specifies the TCP/IP port or, by omission, the local Unix domain socket file extension on which the postmaster is listening for connections. Defaults to the value of the PGPORT environment variable or, if not set, to the port specified at compile time, usually 5432.

Allows you to specify printing options in the style of \pset on the command line. Note that here you have to separate name and value with an equal sign instead of a space. Thus to set the output format to LaTeX, you could write -P format=latex.

Specifies that psql should do its work quietly. By default, it prints welcome messages and various informational output. If this option is used, none of this happens. This is useful with the -c option. Within psql you can also set the QUIET variable to achieve the same effect.

Use separator as the record separator. This is equivalent to the \pset recordsep command.

Run in single-step mode. That means the user is prompted before each query is sent to the backend, with the option to cancel execution as well. Use this to debug scripts.

Runs in single-line mode where a newline terminates a query, like a semicolon would do.

This mode is provided for those who insist on it, but you are not necessarily encouraged to use it. In particular, if you mix SQL and meta-commands on a line the order of execution might not always be clear to the unexperienced user.

Turn off printing of column names and result row count footers, etc. It is completely equivalent to the \t.

Allows you to specify options to be placed within the HTML table tag. See \pset for details.

Makes psql prompt for the user name and password before connecting to the database.

This option is deprecated, as it is conceptually flawed. (Prompting for a non-default user name and prompting for a password because the backend requires it are really two different things.) You are encouraged to look at the -U and -W options instead.

Connects to the database as the user username instead of the default. (You must have permission to do so, of course.)

Performs a variable assignment, like the \set internal command. Note that you must separate name and value, if any, by an equal sign on the command line. To unset a variable, leave off the equal sign. These assignments are done during a very early state of startup, so variables reserved for internal purposes might get overwritten again.

Shows the psql version.

Requests that psql should prompt for a password before connecting to a database. This will remain set for the entire session, even if you change the database connection with the meta-command \connect.

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

Turns on extended row format mode. This is equivalent to the command \x.

Shows help about psql command line arguments.