Guida a PostgreSQL

1.  Introduzione

Introduzione a PostgreSQL

Quando tra vari sviluppatori si discute sulle differenti soluzioni database che si possono usare, due grandi database solitamente costituiscono le risposte. Uno sarebbe MySQL e l'altro è quello a cui questo documento si riferisce, ovvero PostgreSQL. I vantaggi dell'uno rispetto all'altro alimentano da sempre una lunga e sfiancante disputa, comunque c'è solo da dire che PostgreSQL ha avuto un più fermo controllo sulle vere strutture database relazionali rispetto a MySQL. Molte caratteristiche standard come FOREIGN KEY sono state aggiunte solamente su MySQL 5. Comunque, in ogni caso questo documento assume già che PostgreSQL sia stato già scelto dall'utente come database da usare. Il primo passo da eseguire è il processo di emerge. Nella prossima sezione, verrà descritto il processo di installazione tramite emerge, oltre che la configurazione di base.

Installazione di PostgreSQL

Per iniziare, bisogna per prima cosa effettuare l'emerge del pacchetto PostgreSQL. Per fare ciò, eseguire il seguente comando per assicurarsi che le opzioni corrette siano impostate

# emerge -pv postgresql

These are the packages that I would merge, in order:

Calculating dependencies ...done!
[ebuild  N    ] dev-db/postgresql-8.0.4  -doc -kerberos +nls +pam +perl -pg-intdatetime
+python +readline (-selinux) +ssl -tcl +xml +zlib 0 kB

La lista seguente spiega i significati delle differenti opzioni:

Una volta che PostgrSQL è stato personalizzato per soddisfare le proprie esigenze, proseguire con il processo di emergw:

# emerge postgresql
(Output ridotto)
>>> /usr/lib/libecpg.so.5 -> libecpg.so.5.0
>>> /usr/bin/postmaster -> postgres
 * Make sure the postgres user in /etc/passwd has an account setup with /bin/bash as the shell
 *
 * Execute the following command
 * emerge --config =postgresql-8.0.4
 * to setup the initial database environment.
 *
>>> Regenerating /etc/ld.so.cache...
>>> dev-db/postgresql-8.0.4 merged.

Come mostrato dall'output di einfo, ci sono delle operazioni post-installazione da fare. Il capitolo successivo si occuperà della configurazione di PostgreSQL.

2.  Configurazione di PostgreSQL

Impostazione dell'ambiente iniziale per il database

Come notato nel precedente output di emerge, bisogna impostare l'ambiente iniziale per il database. Comunque, prima di fare ciò, bisogna tenere presente che, diversamente da MySQL, la password di "root" di PostgreSQL è la password dell'utente reale. Tuttavia, solo l'utente viene creato dall'ebuild, non la password. Quindi, prima di cominciare, bisogna imposare la password per l'utente postgres:

# passwd postgres
New UNIX password:
Retype new UNIX password:
passwd: password updated successfully

Adesso, è possibile creare l'ambiente iniziale per il database:

# emerge --config =postgresql-8.0.4


Configuring pkg...

 * Creating the data directory ...
 * Initializing the database ...
The files belonging to this database system will be owned by user "postgres".
This user must also own the server process.

The database cluster will be initialized with locale C.

fixing permissions on existing directory /var/lib/postgresql/data ... ok
creating directory /var/lib/postgresql/data/global ... ok
creating directory /var/lib/postgresql/data/pg_xlog ... ok
creating directory /var/lib/postgresql/data/pg_xlog/archive_status ... ok
creating directory /var/lib/postgresql/data/pg_clog ... ok
creating directory /var/lib/postgresql/data/pg_subtrans ... ok
creating directory /var/lib/postgresql/data/base ... ok
creating directory /var/lib/postgresql/data/base/1 ... ok
creating directory /var/lib/postgresql/data/pg_tblspc ... ok
selecting default max_connections ... 100
selecting default shared_buffers ... 1000
creating configuration files ... ok
creating template1 database in /var/lib/postgresql/data/base/1 ... ok
initializing pg_shadow ... ok
enabling unlimited row size for system tables ... ok
initializing pg_depend ... ok
creating system views ... ok
loading pg_description ... ok
creating conversions ... ok
setting privileges on built-in objects ... ok
creating information schema ... ok
vacuuming database template1 ... ok
copying template1 to template0 ... ok

WARNING: enabling "trust" authentication for local connections
You can change this by editing pg_hba.conf or using the -A option the
next time you run initdb.

Success. You can now start the database server using:

    /usr/bin/postmaster -D /var/lib/postgresql/data
or
    /usr/bin/pg_ctl -D /var/lib/postgresql/data -l logfile start

 *
 * You can use /etc/init.d/postgresql script to run PostgreSQL instead of pg_ctl.
 *

Adesso l'ambiente iniziale per il database è stato configurato. La prossima sezione riguarderà la verifica dell'installazione e la configurazione degli utenti per accedere al database.

Configurazione del database PostgreSQL

Adesso che PostgreSQL è configurato, a questo punto è buona norma verificare l'installazione. Per prima cosa, assicurarsi che il servizio parta regolarmente:

# /etc/init.d/postgresql start
* Starting PostgreSQL ...                                          [ ok ]

Dopo aver verificato il funzionamento, è consigliabile aggiungerlo al runlevel default in modo da farlo partire all'avvio della macchina:

# rc-update add postgresql default
* postgresql added to runlevel default

Adesso che il servizio è attivato, è il momento di configurare un database di test. Per iniziare, creare un database di test usando il comando createdb. Passare inoltre l'opzione -U per selezionare l'utente (se non viene specificato nulla utilizza l'utente corrente), e il parametro -W per fargli chiedere la password creata in precedenza. Infine passare anche il nome del database che si vuole creare:

$ createdb -U postgres -W test
Password:
CREATE DATABASE

Il database è stato creato con successo ed è possibile confermare che il database può eseguire dei compiti di base. Proseguire con l'eliminazione (drop) del database tramite il comando dropdb:

$ dropdb -U postgres -W test
Password:
DROP DATABASE

Al momento i comandi possono essere eseguiti solamente dall'utente postgres. Ovviamente questo non è il tipo di configurazione adatto ad un ambiente multi-utente, perciò la prossima sezione riguarderà la configurazione degli account per gli utenti.

Configurazione degli account utente per il database

Come detto prima, loggarsi come utente postgres è una cosa sicuramente poco adatta per un ambiente multi-utente, poichè in molti casi ci saranno vari utenti e servizi che accederanno al server, e ognuno richiede diversi permessi. Così, per gestire questa situazione, può essere usato il comando createuser, che risulta essere una alternativa all'esecuzione di poche query SQL, ed è molto più flessibile dal punto di vista dell'amministratore. Proseguire con la creazione di due utenti, un 'superutentè che può aggiungere altri utenti e amministrare il database, e un utente standard:

(sostituire chris con il nome utente che si vuole usare)
$ createuser -a -d -P -E -U postgres -W chris
Enter password for new user:
Enter it again:
Password:
CREATE USER

Con quest'operazione è stato creato il superutente. L'opzione -a specifica che l'utente può aggiungere altri utenti. -d indica che l'utente può creare nuovi database. -P serve per ricevere la richiesta di una password per l'utente e -E la cripterà per ragioni di sicurezza. Testare ora i permessi del nuovo utente creando un nuovo utente standard:

(sostituire chris con il nome dell'utente creato in precedenza)
$ createuser -A -D -P -E -U chris -W testuser
Enter password for new user:
Enter it again:
Password:
CREATE USER

Il nostro nuovo utente è stato creato con successo usando il superutente creato precedentemente. Le opzioni -A e -D sono il contrario di -a e -d, quindi negano all'utente la possibilità di creare altri utenti e database. Adesso ci sono gli utenti per lavorare, il prossimo capitolo riguarderà l'utilizzo di questo nuovo database.

3.  Usare PostgreSQL

Impostare i permessi

Ora è presente un utente che può creare database e aggiungere altri utenti e l'utente postgres principale che può fare qualsiasi cosa. L'utente creato prima può solamente loggarsi nel server. In generale, però, gli utenti hanno la necessità di inserire e prelevare dati, e a volte anche altri tipi di operazioni. Quindi, per permettere al nuovo utente di fare qualsiasi cosa, è necessario impostarlo con i giusti permessi: lo si può fare facilmente passando il parametro -O a createdb. Si comincerà col creare un nuovo database, MyDB tramite il superuser il cui proprietario sarà il precedente testuser:

$ createdb -O testuser -U chris -W MyDB
Password:
CREATE DATABASE

A questo punto è disponibile un nuovo database MyDB e un testuser che può accedervi. Per testare il tutto, effettuare il login come testuser al nuovo database MyDB utilizzando il programma psql. Questo programma è usato per connettersi a un database PostgreSQL dalla linea di comando. Per cui la connessione al nuovo database sarà eseguita in questo modo:

$ psql -U testuser -W MyDB
Password:
Welcome to psql 8.0.4, the PostgreSQL interactive terminal.

Type:  \copyright for distribution terms
       \h for help with SQL commands
       \? for help with psql commands
       \g or terminate with semicolon to execute query
       \q to quit

MyDB=>

In questo modo, l'utente testuser è loggato nel database e può iniziare ad avviare qualche comando. Per prendere familiarità con PostgreSQL, la prossima sezione riguarderà l'utilizzo di alcuni comandi base navigando con il client psql.

Comandi base di PostgreSQL e creazione di tabelle

Per coloro che sono abituati a MySQL, questa sezione è indispensabile. Questa sezione dovrebbe illustrare il funzionamento di PostgreSQL con un occhio di riguardo ai comandi da eseguire. Per iniziare, qui c'è una lista di alcuni comandi che verranno trattati:

Con l'eccezione di \c[onnect], tutti i comandi visti saranno utilizzati successivamente in questa sezione. Per ora il database è vuoto, quindi biusogna inserire qualche dato. Il primo passo per inserire dati, tuttavia, è quello di inserirli in una tabella. Per ora non ci sono tabelle nel database, quindi bisogna crearne una, e lo si può fare con il comando CREATE TABLE. Verrà creata una tabella di articoli, che conterranno un identificativo (product_id), una descrizione (description) e un prezzo (price).

MyDB=> CREATE TABLE products (
MyDB(>   product_id SERIAL,
MyDB(>   description TEXT,
MyDB(>   price DECIMAL
MyDB(> );
NOTICE:  CREATE TABLE will create implicit sequence "products_product_id_seq"
for serial column "products.product_id"
CREATE TABLE

Si può tranquillamente ignorare il NOTICE, è innocuo. Guardando l'ultima riga della funzione, CREATE TABLE indica che il comando è stato eseguito con successo. Tuttavia è meglio verificare se la tabella è stata creata correttamente con il comando \d:

MyDB=> \d products
                                 Table "public.products"
   Column    |  Type   |                            Modifiers
-------------+---------+------------------------------------------------------------------
 product_id  | integer | not null default nextval('public.products_product_id_seq'::text)
 description | text    |
 price       | numeric |

La tabella è stata creata correttamente. Adesso che la tabella è creata, è il momento di riempirla con i dati. La prossima sezione riguarderà il riempimento del database con i dati.

Inserire dati nel database

Questa sezione riguarda le due vie per inserire dati nella nuova tabella creata. Prima è una buona idea vedere il comando più semplice, INSERT:

INSERT INTO [tablename] (column1,column2,column3) VALUES(value1,value2,value3)

tablename è il nome della tabella dove inserire i dati. (column1,column2,column3) servono per specificare le colonne dove devono essere inseriti i valori. VALUES(value1,value2,value3) è la lista dei valori. I valori vengono inseriti con lo stesso ordine delle colonne (la prima colonna riceve il primo valore, la seconda il secondo valore, etc). Il numero delle colonne e dei rispettivi valori deve essere uguali. Proseguire inserendo un articolo nella tabella:

MyDB=> INSERT INTO products (description,price) VALUES('A test product', 12.00);
INSERT 17273 1

L'ultima riga necessita un po' di spiegazioni. L'output riportato dal comando insert è formato da un OID (Object Identifier) e dal numero di righe inserite. L'OID va un po' oltre l'obiettivo di questa guida, e nel PostgreSQL manual è possibile trovare più informazioni a riguardo. Per una situazione dove si hanno 20.000 prodotti, questi comandi insert sono un po' fastidiosi; tuttavia, nulla è perduto. Il comando COPY può essere usato per inserire dati in una tabella da un file o dallo standard input. In questo esempio viene usato un file csv (comma separated values), che contiene product id, description e price. Il file avrà un contenuto simile a questo:

2,meat,6.79
3,soup,0.69
4,soda,1.79

Adesso verrà usato il comando COPY per popolare la tabella:

MyDB=> COPY products FROM STDIN WITH DELIMITER AS ',';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 2,meat,6.79
>> 3,soup,0.69
>> 4,soda,1.79
>> \.

Sfortunatamente, questa riga non restituisce le stesse informazioni date dal comando INSERT INTO. Come si fa a sapere se i dati sono stati inseriti? La prossima sezione riguarderà l'uso di query per controllare i propri dati.

Usare le query PostgreSQL

Questa sezione riguarda l'uso del comando SELECT per visionare i dati contenuti nelle tabelle. La sintassi base di SELECT è la seguente:

SELECT (column1,column2|*) FROM (table) [WHERE (conditionals)]

Ci sono due vie per selezionare le colonne. La prima è quella di usare * per selezionare tutte le colonne, e la seconda è quella di specificare una lista di colonne che si vogliono vedere. La seconda è abbastanza comoda quando si vuole trovare una specifica colonna anziché una grande lista. Cominciare usando SELECT con * per specificare tutte le colonne:

MyDB=> SELECT * FROM products;
 product_id |  description   | price
------------+----------------+-------
          1 | A test product | 12.00
          2 | meat           |  6.79
          3 | soup           |  0.69
          4 | soda           |  1.79
(4 rows)

Come si può notare, tutti i dati inseriti prima sono stati messi nella tabella. Adesso si ipotizzi di voler mostrare solo la descrizione ed il prezzo, ignorando l'id. In questo caso verranno specificate le colonne a SELECT in questo modo:

MyDB=> SELECT description,price FROM products;
  description   | price
----------------+-------
 A test product | 12.00
 meat           |  6.79
 soup           |  0.69
 soda           |  1.79
(4 rows)

Adesso vengono mostrati solo la descrizione e il prezzo, pertanto lo sguardo cade solo sui dati importanti. Adesso si ipotizzi di voler mostrare solo i prodotti che hanno un prezzo maggiore di $2,00. In questi casi è molto comodo il parametro WHERE:

MyDB=> SELECT description,price FROM products WHERE price > 2.00;
  description   | price
----------------+-------
 A test product | 12.00
 meat           |  6.79
(2 rows)

Ora viene mostrata una lista dei prodotti che hanno un prezzo maggiore di $2,00, riducendo ancora di più la serie di dati visualizzati. Le query di questo tipo sono molti utili e possono aiutare nella creazione di utili report.

Conclusione

Con ciò si conclude la guida a PostgreSQL. Un grande ringraziamento va a Masatomo Nakano, il quale gestiva Gentoo PostgreSQL, per il suo aiuto nel rispondere alle domande poste dall'autore di questo documento. Se si hanno suggerimenti in merito a questa guida è possibile inviare un'email a Chris White. Per una documentazione più estesa, dare un'occhiata alsito web di PostgreSQL.

I contenuti di questo documento sono rilasciati sotto la licenza Creative Commons - Attribution / Share Alike.