Managing a Database
If the Postgres
postmaster is up and running we can create
some databases to experiment with. Here, we describe the
basic commands for managing a database.
Creating a Database
Let's say you want to create a database named mydb.
You can do this with the following command:
% createdb dbname
Postgres allows you to create
any number of databases
at a given site and you automatically become the
database administrator of the database you just created.
Database names must have an alphabetic first
character and are limited to 31 characters in length.
Not every user has authorization to become a database
administrator. If Postgres
refuses to create databases
for you, then the site administrator needs to grant you
permission to create databases. Consult your site
administrator if this occurs.
Accessing a Database
Once you have constructed a database, you can access it
by:
running the Postgres terminal monitor program
(psql) which allows you to interactively
enter, edit, and execute SQL commands.
writing a C program using the libpq subroutine
library. This allows you to submit SQL commands
from C and get answers and status messages back to
your program. This interface is discussed further
in the PostgreSQL Programmer's Guide.
You might want to start up psql,
to try out the examples in this manual. It can be activated for the
dbname database by typing the command:
psql dbname
You will be greeted with the following message:
Welcome to psql, the PostgreSQL interactive terminal.
Type: \copyright for distribution terms
\h for help with SQL commands
\? for help on internal slash commands
\g or terminate with semicolon to execute query
\q to quit
dbname=>
This prompt indicates that the terminal monitor is listening
to you and that you can type SQL queries into a
workspace maintained by the terminal monitor.
The psql program responds to escape
codes that begin
with the backslash character, "\". For example, you
can get help on the syntax of various
Postgres SQL commands by typing:
dbname=> \h
Once you have finished entering your queries into the
workspace, you can pass the contents of the workspace
to the Postgres server by typing:
dbname=> \g
This tells the server to process the query. If you
terminate your query with a semicolon, the backslash-g is not
necessary. psql will automatically
process semicolon terminated queries.
To read queries from a file, instead of
entering them interactively, type:
dbname=> \i filename
To get out of psql and return to Unix, type
dbname=> \q
and psql will quit and return
you to your command shell. (For more escape codes, type
backslash-h at the monitor prompt.)
White space (i.e., spaces, tabs and newlines) may be
used freely in SQL queries.
Single-line comments are denoted by two dashes
("--"). Everything after the dashes up to the end of the
line is ignored. Multiple-line comments, and comments within a line,
are denoted by "/* ... */", a convention borrowed
from Ingres.
Destroying a Database
If you are the database administrator for the database
mydb, you can destroy it using the following Unix command:
% dropdb dbname
This action physically removes all of the Unix files
associated with the database and cannot be undone, so
this should only be done with a great deal of forethought.
It is also possible to destroy a database from within an
SQL session by using
> drop database dbname
Backup and Restore
Every database should be backed up on a regular basis. Since
Postgres manages it's own files in the
file system, it is not advisable to rely on
system backups of your file system for your database backups;
there is no guarantee that the files will be in a usable,
consistant state after restoration.
Postgres provides two utilities to
backup your system: pg_dump to backup
individual databases and
pg_dumpall to backup your installation
in one step.
An individual database can be backed up using the following
command:
% pg_dump dbname > dbname.pgdump
and can be restored using
cat dbname.pgdump | psql dbname
This technique can be used to move databases to new
locations, and to rename existing databases.
Large Databases
Author
Written by Hannu Krosing on
1999-06-19.
Since Postgres allows tables larger
than the maximum file size on your system, it can be problematic
to dump the table to a file, since the resulting file will likely
be larger than the maximum size allowed by your system.
As pg_dump writes to stdout,
you can just use standard *nix tools
to work around this possible problem:
Use compressed dumps:
% pg_dump dbname | gzip > filename.dump.gz
reload with
% createdb dbname
% gunzip -c filename.dump.gz | psql dbname
or
% cat filename.dump.gz | gunzip | psql dbname
Use split:
% pg_dump dbname | split -b 1m - filename.dump.
reload with
% createdb dbname
% cat filename.dump.* | pgsql dbname
Of course, the name of the file
(filename) and the
content of the pg_dump output need not
match the name of the database. Also, the restored database can
have an arbitrary new name, so this mechanism is also suitable
for renaming databases.