Provided by: postgresql-client-8.4_8.4.11-1_amd64 bug


       pg_dumpall - extract a PostgreSQL database cluster into a script file


       pg_dumpall [ option... ]


       pg_dumpall  is  a  utility  for  writing  out  (``dumping'') all PostgreSQL databases of a
       cluster into one script file. The script file contains SQL commands that can  be  used  as
       input  to  psql(1)  to  restore the databases. It does this by calling pg_dump(1) for each
       database in a cluster.  pg_dumpall also dumps  global  objects  that  are  common  to  all
       databases.   (pg_dump  does  not save these objects.)  This currently includes information
       about database users and groups, tablespaces, and properties such  as  access  permissions
       that apply to databases as a whole.

       Since pg_dumpall reads tables from all databases you will most likely have to connect as a
       database superuser in order to produce a complete  dump.  Also  you  will  need  superuser
       privileges to execute the saved script in order to be allowed to add users and groups, and
       to create databases.

       The SQL script will be written to the standard output. Shell operators should be  used  to
       redirect it into a file.

       pg_dumpall needs to connect several times to the PostgreSQL server (once per database). If
       you use password authentication it will ask for a password each time. It is convenient  to
       have a ~/.pgpass file in such cases. See in the documentation for more information.


       The following command-line options control the content and format of the output.


              Dump only the data, not the schema (data definitions).


              Include  SQL  commands  to  clean  (drop)  databases  before  recreating them. DROP
              commands for roles and tablespaces are added as well.

       -f filename

              Send output to the specified file. If this is omitted, the standard output is used.


              Dump only global objects (roles and tablespaces), no databases.


              A deprecated option that is now ignored.


       --oids Dump object identifiers (OIDs) as part of the data for every table. Use this option
              if  your application references the OID columns in some way (e.g., in a foreign key
              constraint).  Otherwise, this option should not be used.


              Do not output commands to set ownership of objects to match the original  database.
              By  default,  pg_dumpall issues ALTER OWNER or SET SESSION AUTHORIZATION statements
              to set ownership of created schema elements.  These statements will fail  when  the
              script  is  run unless it is started by a superuser (or the same user that owns all
              of the objects in the script).  To make a script that can be restored by any  user,
              but will give that user ownership of all the objects, specify -O.

              Do  not  wait  forever  to acquire shared table locks at the beginning of the dump.
              Instead fail if unable to lock a table within the specified  timeout.  The  timeout
              may  be specified in any of the formats accepted by SET statement_timeout. (Allowed
              values vary depending on the server version you are dumping from,  but  an  integer
              number  of  milliseconds  is  accepted  by  all  versions since 7.3. This option is
              ignored when dumping from a pre-7.3 server.)

              Do not output commands to create tablespaces nor select  tablespaces  for  objects.
              With  this  option,  all  objects  will  be  created in whichever tablespace is the
              default during restore.


              Dump only roles, no databases or tablespaces.


              Dump only the object definitions (schema), not data.

       -S username

              Specify the superuser user name to use  when  disabling  triggers.   This  is  only
              relevant  if  --disable-triggers is used.  (Usually, it's better to leave this out,
              and instead start the resulting script as superuser.)


              Dump only tablespaces, no databases or roles.


              Specifies verbose mode. This will cause pg_dumpall to output  start/stop  times  to
              the  dump  file,  and  progress  messages  to  standard error.  It will also enable
              verbose output in pg_dump.



              Prevent dumping of access privileges (grant/revoke commands).

              This option is for use by in-place upgrade utilities. Its use for other purposes is
              not  recommended  or  supported.  The  behavior  of the option may change in future
              releases without notice.

              Dump data as INSERT commands (rather than COPY). This will  make  restoration  very
              slow;  it  is mainly useful for making dumps that can be loaded into non-PostgreSQL
              databases. Note that the restore might  fail  altogether  if  you  have  rearranged
              column order.  The --column-inserts option is safer, though even slower.


              Dump data as INSERT commands with explicit column names (INSERT INTO table (column,
              ...) VALUES ...). This will make restoration very slow; it  is  mainly  useful  for
              making dumps that can be loaded into non-PostgreSQL databases.

              This option disables the use of dollar quoting for function bodies, and forces them
              to be quoted using SQL standard string syntax.

              This option is  only  relevant  when  creating  a  data-only  dump.   It  instructs
              pg_dumpall to include commands to temporarily disable triggers on the target tables
              while the data is reloaded. Use this if you have referential  integrity  checks  or
              other triggers on the tables that you do not want to invoke during data reload.

              Presently,  the  commands emitted for --disable-triggers must be done as superuser.
              So, you should also specify a superuser name with -S, or preferably be  careful  to
              start the resulting script as a superuser.

              Output  SQL-standard  SET  SESSION  AUTHORIZATION  commands  instead of ALTER OWNER
              commands to  determine  object  ownership.  This  makes  the  dump  more  standards
              compatible,  but  depending  on  the  history of the objects in the dump, might not
              restore properly.

       The following command-line options control the database connection parameters.

       -h host

              Specifies the host name of the machine on which the database server is running.  If
              the  value  begins  with  a  slash, it is used as the directory for the Unix domain
              socket. The default is taken from the PGHOST environment variable, if set,  else  a
              Unix domain socket connection is attempted.

       -l dbname

              Specifies  the  name  of  the  database  to  connect  to to dump global objects and
              discover what other databases should be dumped. If not specified, the  ``postgres''
              database will be used, and if that does not exist, ``template1'' will be used.

       -p port

              Specifies  the  TCP  port  or  local Unix domain socket file extension on which the
              server is listening for connections.  Defaults to the PGPORT environment  variable,
              if set, or a compiled-in default.

       -U username

              User name to connect as.


              Never issue a password prompt. If the server requires password authentication and a
              password is not available by other means such as a  .pgpass  file,  the  connection
              attempt  will  fail.  This  option can be useful in batch jobs and scripts where no
              user is present to enter a password.


              Force pg_dumpall to prompt for a password before connecting to a database.

              This option is never essential, since pg_dumpall will automatically  prompt  for  a
              password  if  the server demands password authentication.  However, pg_dumpall will
              waste a connection attempt finding out that the server wants a password.   In  some
              cases it is worth typing -W to avoid the extra connection attempt.

              Note  that  the  password  prompt  will occur again for each database to be dumped.
              Usually, it's better to set up a ~/.pgpass file than to  rely  on  manual  password

              Specifies a role name to be used to create the dump.  This option causes pg_dumpall
              to issue a SET ROLE rolename command after connecting to the database. It is useful
              when   the  authenticated  user  (specified  by  -U)  lacks  privileges  needed  by
              pg_dumpall, but can switch to a role with the required rights.  Some  installations
              have  a  policy  against logging in directly as a superuser, and use of this option
              allows dumps to be made without violating the policy.





       PGUSER Default connection parameters

       This utility, like most other PostgreSQL utilities, also uses  the  environment  variables
       supported by libpq (see in the documentation).


       Since pg_dumpall calls pg_dump internally, some diagnostic messages will refer to pg_dump.

       Once  restored,  it  is  wise  to run ANALYZE on each database so the optimizer has useful
       statistics. You can also run vacuumdb -a -z to analyze all databases.

       pg_dumpall requires all needed tablespace directories to exist before  the  restore,  else
       database creation will fail for databases in non-default locations.


       To dump all databases:

       $ pg_dumpall > db.out

       To reload this database use, for example:

       $ psql -f db.out postgres

       (It  is  not important to which database you connect here since the script file created by
       pg_dumpall will contain the appropriate commands  to  create  and  connect  to  the  saved


       Check pg_dump(1) for details on possible error conditions.