L’ereditarietà in PostgreSQL consente di creare relazioni di tipo IS molto simile ai concetti tipici dell’OO riguardanti le classi. La tecnica è particolarmente usata per il partizionamento.

Una volta collegati a PostgreSQL, è sufficiente digitare la seguente query SQL:

SELECT DISTINCT relname FROM pg_inherits JOIN pg_class ON (oid = inhparent);

Espandendo la query, possiamo anche contare quante tabelle derivano dalla master, ordinandole per nome:

SELECT relname, count(*) FROM pg_inherits JOIN pg_class ON (oid = inhparent) GROUP BY 1 ORDER BY 1;

Buon divertimento!

Il primo passo consiste nell’abilitare i backport:

cat << E_O_BACKPORTS > /etc/apt/sources.list.d/backports.list deb http://www.backports.org/debian lenny-backports main contrib non-free deb-src http://www.backports.org/debian lenny-backports main contrib non-free E_O_BACKPORTS

cat << E_O_APTPREF >> /etc/apt/preferences

Package: 2ndquadrant_italia_mod.txt 2ndquadrant_italia.txt da_installare_pandoc hdoisajds.sh risultati step2 Pin: release a=lenny-backports Pin-Priority: 200 E_O_APTPREF

wget -O – http://backports.org/debian/archive.key | apt-key add –

apt-get update

Poi installare postgresql-8.4

apt-get -t lenny-backports postgresql-8.4 postgresql-contrib-8.4 postgresql-doc-8.4

Semplice, no?

PostgreSQL è in grado di memorizzare le date a partire dall’anno 4713 A.C. fino al 5874897 D.C., utilizzando il tipo di dato denominato "date", conforme allo standard SQL92. Ogni campo di tipo date occupa lo spazio interno di 4 byte. Al fine di poter inserire nel database oppure recuperare dal database campi di tipo data, PostgreSQL definisce un formato di default da utilizzare, tramite il parametro datestyle all’interno di postgresql.conf.

Questo parametro è solitamente impostato nel formato standard ISO 8601, che prevede la specifica di date nel formato "AAAA-MM-GG".

Ecco un estratto dal file di configurazione:

datestyle = 'iso, dmy'

E’ possibile visualizzare il valore del parametro datestyle anche da riga di comando, aprendo una sessione psql:

gabriele=> show datestyle;
DateStyle
-----------
ISO, DMY
(1 riga)

Prima di andare avanti, creiamo uno schema ed una tabella per fare degli esempi:

gabriele=> create schema test_data;
CREATE SCHEMA
gabriele=> set search_path to test_data;
gabriele=> create table test_data ( giorno date);
CREATE TABLE

Proviamo ad inserire la data odierna nella tabella test_data, utilizzando la funzione predefinita CURRENT_DATE:

gabriele=> insert into test_data values (CURRENT_DATE);
INSERT 0 1
gabriele=> SELECT 2ndquadrant_italia_mod.txt 2ndquadrant_italia.txt da_installare_pandoc hdoisajds.sh risultati step2 FROM test_data ;
giorno
------------
2009-05-03
(1 riga)

La cosa veramente utile ed interessante è che il parametro ‘datestyle‘ può essere reimpostato a livello di sessione. Ad esempio, una applicazione che si connette a PostgreSQL può volere inserire o ricevere dati in un formato diverso dal formato ISO 8601. Ad esempio, è possibile voler "negoziare" i dati nel formato "GG-MM-AAAA". Come fare?

La cosa è molto semplice. E’ sufficiente impostare lo stile della data a "Postgres, European", oppure "Postgres, DMY" (in quanto DMY è un sinonimo di European).

gabriele=> set datestyle to 'Postgres, DMY';
SET
gabriele=> SELECT 2ndquadrant_italia_mod.txt 2ndquadrant_italia.txt da_installare_pandoc hdoisajds.sh risultati step2 FROM test_data ;
giorno
------------
03-05-2009
(1 riga)

Se invece del segno meno (‘-‘) come separatore, desideriamo avere la barra (‘/’), possiamo utilizzare il formato SQL in datestyle:

gabriele=> set datestyle to 'SQL, DMY';
SET
gabriele=> SELECT 2ndquadrant_italia_mod.txt 2ndquadrant_italia.txt da_installare_pandoc hdoisajds.sh risultati step2 FROM test_data ;
giorno
------------
03/05/2009
(1 riga)

Utilizzando opportunamente la variabile datestyle è pertanto possibile in molti casi evitare di utilizzare funzioni di formattazione runtime come to_char o to_date. Non è possibile utilizzare questa soluzione se intendiamo avere nella stessa query più campi data con più di un formato di visualizzazione.

Per quanto riguarda l’immissione di valori, è opportuno segnalare che Postgres ha un sistema di parsing molto flessibile basato su euristiche e in grado di identificare formati di dati diversi (si veda l’Appendice B referenziata in fondo). Le date in formato ‘ISO 8601’ sono sempre accettate, per quanto riguarda i formati Postgres e SQL è necessario seguire la sottodirettiva che specifica l’ordine dei campi (DMY oppure MDY – il formato americano).

Infine, alcuni link utili:

• Manuale di PostgreSQL, Tipi data e orario
• Manuale di PostgreSQL, parametro DateStyle
• Manuale di PostgreSQL, Appendice B: supporto date e orari

Le sequenze in PostgreSQL sono un’ottimo strumento per gestire in modo concorrente l’assegnazione di numeri sequenziali. Spesso sono usati per gestire i campi identificativi (id) delle tabelle.

In PostgreSQL le sequenze possono essere usate in modo esplicito (creando l’oggetto di tipo sequence e poi assegnando il valore di default di un campo) oppure in modo implicito, dichiarando un tipo di dato come serial.

Per maggiori informazioni, si vedano le pagine del manuale su:

• CREATE SEQUENCE
• Tipo di dato SERIAL

Coloro che provengono dal mondo MySQL noteranno la somiglianza con il qualificatore AUTO_INCREMENT.

Ad ogni modo, l’obiettivo dell’articolo è quello di fornire un modo semplice per aggiornare il valore corrente di una sequence sulla base dei valori presenti nella tabella.

L’operazione ha un suo scopo nelle operazioni di caricamento dei dati.

Supponiamo di avere una tabella customers con il campo id_customer associato alla sequenza customers_seq.

CREATE SEQUENCE customers_seq;
CREATE TABLE customers (
id_customer INTEGER NOT NULL
DEFAULT nextval('customers_seq') PRIMARY KEY,
...
);

Supponiamo di volerla esportare:

copy customers TO 'dati/customers.txt'

e quindi importare in un’altra istanza di PostgreSQL o in un alto database. Il comando da lanciare utilizzando l’applicazione da console psql è:

copy customers FROM 'dati/customers.txt'

si occupa semplicemente di importare i dati. Ma in seguito a questa operazione, la sequenza non sarà stata aggiornata e il primo inserimento automatico di un record nella tabella genererà un errore di violazione della chiave primaria.

E’ pertanto necessario aggiornare il valore corrente della sequenza prima di mettere in produzione il database, lanciando una semplice query di aggiornamento:

select setval('customers_seq', max(id_customer)) FROM customers;

Come ultimo riferimento, si consiglia una lettura della pagina sulle funzioni per le sequenze.

In questo breve articolo, indirizzato ai possessori di computer Macintosh con sistema operativo Mac OS 10.4 e 10.5, spiegherò come installare PostgreSQL compilandolo dai sorgenti dell’ultima release stabile, al momento la 8.3. Ricordo che esistono dei pacchetti già preparati per coloro che non intendono sperimentare e confezionare una installazione su misura per il vostro Mac OS X. Per maggiori informazioni, si visiti la pagina "Mac OS X Packages", mantenuta da Dave Page. Apriamo intanto un terminale (da Applicazioni/Utility) e cominciamo a divertirci. :)

Prerequisiti

Innanzitutto è necessario installare MacPorts. Per maggiori informazioni, si legga la guida di MacPorts sull’installazione. Ad ogni modo, i requisiti per la sua installazione sono:

1. X11 (solo per possessori di Mac OS X Panther, in quanto già incluso su Leopard);
2. installare XCode Tools

A questo punto scaricare il pacchetto di installazione dal sito di MacPorts, e proseguire con l’installazione. Purtroppo la prima installazione di MacPorts può richiedere anche un paio di ore di tempo. Tenetene di conto. :)

Una volta che MacPorts è a nostra disposizione, è necessario installare alcuni pacchetti, utilizzando l’apposito comando port install (è consigliato alzare il livello di debug dell’operazione, utilizzando l’opzione -d). Da dentro il terminale, digitare:

sudo port -d install NOME_PACCHETTO

In particolare:

• bison
• gettext
• libxml2
• libxslt
• openssl
• pcre
• readline
• zlib

Vedrete che lanciando il comando:

sudo port -d install bison gettext libxml2 libxslt openssl pcre readline zlib

Macports comincerà a scaricare i pacchetti, compilarli e installarli, occupandosi anche delle relative dipendenze.

Al termine di questa operazione siamo pronti per scaricare i sorgenti di PostgreSQL.

Scaricare i sorgenti

Esistono due soluzioni. Scaricare i sorgenti ufficiali, oppure prenderli direttamente dal CVS, utilizzando le ultimissime modifiche stabili (che saranno poi incluse nella prima release che verrà successivamente rilasciata). Visto che la prima è molto elementare (basta scaricare i sorgenti in formato TAR compresso dal sito di PostgreSQL), in questa sede ci occupiamo della seconda.

Nella propria home directory, creare la cartella src/postgres, da questo momento conosciuta con il nome di cartella principale dei sorgenti. Se preferite, potete utilizzare un’altra cartella.

Effettuare il login al CVS di PostgreSQL, digitando:

cvs -d :pserver:anoncvs@anoncvs.postgresql.org:/projects/cvsroot login

Digitare una password non vuota. L’operazione è necessaria soltanto una volta (a meno di non eseguire il logout).

Creare il file .cvsrc dentro la propria home directory, contenente:

cvs -z3
update -d -P

Posizionarsi nella cartella principale dei sorgenti e digitare:

cvs -d :pserver:anoncvs@anoncvs.postgresql.org:/projects/cvsroot co -P -r REL8_3_STABLE pgsql

L’operazione di scaricamento dei sorgenti durerà alcuni minuti. Rinominare la cartella pgsql in REL8_3_STABLE:

mv pgsql REL8_3_STABLE

Compilare i sorgenti

A questo punto dovremmo essere pronti per procedere con la configurazione e la compilazione di PostgreSQL sul nostro Mac. Entrare nella directory REL8_3_STABLE e digitare:

./configure --prefix=/usr/local/pgsql --with-openssl --with-libxml --with-libxslt --enable-nls --with-perl --with-python --with-bonjour

Successivamente, procedere con la compilazione e l’installazione:

make
sudo make install

Creare l’utente postgres

Affinché sia possibile utilizzare PostgreSQL stabilmente è convenzione fare in modo che esegua come utente non amministratore, solitamente come utente postgres. Su Mac OS X, la creazione di un utente non avviene nello stesso modo dei sistemi Linux. Tuttavia in questa sede, non vogliamo scendere in dettaglio ma fornirvi direttamente le istruzioni per creare il gruppo e l’utente, che di default si posizionerà nella cartella /usr/local/pgsql. Per fare questo, digitare:

dscl . -create /Groups/postgres
dscl . -create /Groups/postgres PrimaryGroupID 401
dscl . -append /Groups/postgres RecordName postgres
dscl . -create /Users/postgres
dscl . -create /Users/postgres UniqueID 401
dscl . -create /Users/postgres PrimaryGroupID 401
dscl . -create /Users/postgres UserShell /bin/bash
dscl . -create /Users/postgres RealName "PostgreSQL Server"
dscl . -create /Users/postgres NFSHomeDirectory /usr/local/pgsql
dscl . -append /Users/postgres RecordName postgres

Ci tengo a precisare che queste istruzioni sono state riprese dalla documentazione di PostgreSQL, sezione "The PostgreSQL User Account", grazie al contributo di un utilizzatore anonimo.

Inizializzare la directory PGDATA

A questo punto siamo pronti per l’ultimo passo – importantissimo – prima di far partire PostgreSQL. Occorre inizializzare la data directory di PostgreSQL, conosciuta solitamente con il nome di PGDATA.

export PGDATA=/usr/local/pgsql/data
sudo chown postgres:postgres $PGDATA

E adesso inizializziamola specificando la localizzazione italiana. E’ consigliatissimo oggigiorno utilizzare sempre codifica UTF-8. Digitare:

cd /usr/local/pgsql
./bin/initdb -D data -E=UTF8 --locale=it_IT.UTF-8

Startup del server e primo test

Diventare utente postgres (da amministratore, digitare ‘su - postgres‘ e digitare:

./bin/pg_ctl -D data -l /tmp/logfile start

L’opzione -l specifica il file di log, al momento indicato nella directory temporanea. Per ambienti di produzione, è necessario specificare una directory diversa e impostare correttamente meccanismi di rotazione (che non rientrano in questo articolo).

Se tutto va bene, l’applicazione pg_ctl risponde con un semplice e positivo server starting.

Connessione al server

Adesso siamo pronti a connetterci al nostro server. Come? Utilizzando psql, che si trova nella directory /usr/local/pgsql/bin. Aggiungiamo la directory nel PATH (vi consiglio di farlo anche per tutti gli utenti che utilizzeranno il client psql da console):

export PATH=$PATH:/usr/local/pgsql/bin

Come utente postgres testiamo la connessione:

psql

Quello che ottengo sul mio Mac è questo:

Welcome to psql 8.3.5, 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
postgres=#

Se anche voi ottenete questo risultato, complimenti, avete installato PostgreSQL sul vostro Mac! Vi consiglio di installare pgAdmin e cominciare a divertirvi con il più avanzato RDBMS open-source!

Conclusioni

A meno di non utilizzare un server di produzione Mac, il mio consiglio è quello di non far partire il servizio PostgreSQL all’avvio di Mac OS X, ma di lanciarlo a mano tutte le volte che ne avete bisogno, come utente postgres. Per fermare in modo gentile il server, (dando per scontato che la directory bin di PostgreSQL sia nel PATH e la variabile PGDATA sia correttamente impostata) è sufficiente digitare:

pg_ctl stop

Spero che questa guida in italiano possa esservi stata utile. Vi prego di farmi avere dei commenti a riguardo. Grazie!