Adding and Deleting Users
createuser enables specific users to access
Postgres.
destroyuser removes users and
prevents them from accessing Postgres.
Note that these
commands only affect users with respect to
Postgres;
they have no effect on users other privileges or status with regards
to the underlying
operating system.
Disk Management
Alternate Locations
It is possible to create a database in a location other than the default
location for the installation. Remember that all database access actually
occurs through the database backend, so that any location specified must
be accessible by the backend.
Alternate database locations are created and referenced by an environment variable
which gives the absolute path to the intended storage location.
This environment variable must have been defined before the backend was started
and must be writable by the postgres administrator account.
Any valid environment variable name may be used to reference an alternate
location, although using variable name with a prefix of PGDATA is recommended
to avoid confusion and conflict with other variables.
In previous versions of Postgres,
it was also permissable to use an absolute path name
to specify an alternate storage location.
The environment variable style of specification
is to be preferred since it allows the site administrator more flexibility in
managing disk storage.
If you prefer using absolute paths, you may do so by defining
"ALLOW_ABSOLUTE_DBPATHS" and recompiling Postgres
To do this, either add this line
#define ALLOW_ABSOLUTE_DBPATHS 1
to the file src/include/config.h, or by specifying
CFLAGS+= -DALLOW_ABSOLUTE_DBPATHS
in your Makefile.custom.
Remember that database creation is actually performed by the database backend.
Therefore, any environment variable specifying an alternate location must have
been defined before the backend was started. To define an alternate location
PGDATA2 pointing to /home/postgres/data, first type
% setenv PGDATA2 /home/postgres/data
to define the environment variable to be used with subsequent commands.
Usually, you will want to define this variable in the
Postgres superuser's
.profile
or
.cshrc
initialization file to ensure that it is defined upon system startup.
Any environment variable can be used to reference alternate location,
although it is preferred that the variables be prefixed with "PGDATA"
to eliminate confusion and the possibility of conflicting with or
overwriting other variables.
To create a data storage area in PGDATA2, ensure
that /home/postgres already exists and is writable
by the postgres administrator.
Then from the command line, type
% setenv PGDATA2 /home/postgres/data
% initlocation $PGDATA2
Creating Postgres database system directory /home/postgres/data
Creating Postgres database system directory /home/postgres/data/base
To test the new location, create a database test by typing
% createdb -D PGDATA2 test
% destroydb test
Managing a Database
Now that Postgres 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 mydb
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 16 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 mydb
database by typing the command:
% psql mydb
You will be greeted with the following message:
Welcome to the Postgres interactive sql monitor:
type \? for help on slash commands
type \q to quit
type \g or terminate with semicolon to execute query
You are currently connected to the database: mydb
mydb=>
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:
mydb=> \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:
mydb=> \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, say myFile, instead of
entering them interactively, type:
mydb=> \i fileName
To get out of psql and return to UNIX, type
mydb=> \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:
% destroydb mydb
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.