Avendo result source con relazioni si possono ottenere risultati interessanti.

Esistono gli oggetti Folk ed Email, ove l’oggetto Folk sia in relazione con molteplici oggetti Email (folk has_many emails).

E’ possibile creare un record scrivendo i dati dell’oggetto/i relativo/i in un arrayref.

E ci si libera di tutto con un bel

Codice e output (con DBIC_TRACE attivo).

(Come si vede chiaramente con quel codice, le fasi di inserimento e selezione dei dati avvengono in due momenti distinti (ci sono due blocchi BEGIN/COMMIT infatti).

Con perl e DBI la cosa viene facile.

La cosa interessante sta in quel last_insert_id che raccatta l’ultimo valore auto incrementato e lo mette in uno scalare, riutilizzabile poi in altri insert per avere le foreign key allineate.

Le due righe che seguono fanno esattamente la stessa cosa, e creano una relazione fra lo schema Folks e Addresses.

Dunque se vorremo fare una join, potremo chiamare join sul metodo che determina la relazione (addresses, guarda caso l’ho chiamato come la tabella da joinare, ma si noti bene che quello è il nome della relazione segnato come primo parametro in has_many) proprio come segue:

che lancerà la seguente query:

Come si vede dall’SQL risultante, i dati della tabella joinata NON sono fetchati dal database (e nemmeno i metodi corrispettivi), comunque è possibile filtrare i dati su entrambe le tabelle sfruttando nella clausola WHERE anche i campi della seconda tabella.
Ad esempio:

Cerca i dati in Folks dove il nome del folk è ‘Simone’ e dove la città (in addresses) finisce per ‘a’.

Con prefetch al posto di join vengono fetchate tutte le colonne:

Come spiegato qua, per accedere ai dati si può usare un metodo già definito oppure get_column().
La selezione delle colonne avviene attraverso i metodi select e as

oppure con columns

che mi è parso una combinazione dei due.

Si può mettere un ‘+’ davanti al nome per aggiungere le colonne selezionate al resultset.
Ad esempio, dopo una join in cui vengono richiamati solo i campi della tabella principale, potremmo rendere disponibili le colonne di un altra tabella con ‘+columns’:

Inoltre grazie alle relazioni potremo anche raccattare dati da uno schema diverso dal resultset di partenza, come in questo caso:

che sarà rappresentato da queste due query consecutive:

Questi sono gli oggetti Addresses (cioè gli indirizzi) appartenenti al Folk num. 27:

Poco male, si ricomincia. E due DB is meil che one (almeno finchè ci sono gli ORM come DBIC che capiscon tutto loro).

Mentre pistolavo a casaccio, ho visto che MySQL ha un tot di script da shell che mostrano un po’ di robba, e comunque aiutano se li si impara ad usare.

$ mysqlshow
+--------------------+
|     Databases      |
+--------------------+
| information_schema |
| agenda             |
| cmsfdt             |
| evento_odg         |
| libri              |
| mail               |
| mysql              |
| studiog7           |
| system_backup      |
| test               |
| test_blog          |
| wines              |
| wp281              |
+--------------------+

$ mysqlshow libri
Database: libri
+---------+
| Tables  |
+---------+
| book    |
| details |
+---------+

$ mysqlshow libri book
Database: libri  Table: book
+---------+-----------+-------------------+------+--
| Field   | Type      | Collation         | Null | ..
+---------+-----------+-------------------+------+--
| id      | int(11)   |                   | NO   | ..
| titolo  | char(100) | latin1_swedish_ci | NO   | ..
| autore  | char(100) | latin1_swedish_ci | NO   | ..
| editore | char(50)  | latin1_swedish_ci | NO   | ..
+---------+-----------+-------------------+------+---

A me è parso caruccio.

Edit postumo: mysqlshow ha un po’ di opzioni. Una cosa che ho trovato utile è stato usare l’opzione –count che dice quante righe ha la tabella richiesta (ho aggiunto in ~/.bashrc alias mysqlshow=’mysqlshow –count’)

Gli schemi che si mangia DBIx::Class sono di questo genere (ho tagliato la definizione delle colonne, perché irrilevante):

e

Per fare una join con DBIC ci si appoggia alle relazioni:

has_many crea una relazione “uno a molti”, e ha come argomenti: il nome dell’accessor, il nome della classe che rappresenta la tabella, un hashref con la reference (a cosa punta la foreign key).
In pratica lo schema Authors è in connessione uno a molti con Thoughs (per un Author ci possono essere molti Thoughts) , la relazione si chiama thoughts e vi si accede attraverso l’accessor thoughts, che punta allo schema Main::Result::Thoughts, secondo la relazione author_id (nella tabella thoughts) – id (nella tabella author).

In maniera analoga, lo schema Thoughts ha una relazione belongs_to con nome author_id, che punta allo schema Authors e che lega l’id in Authors con l’author_id di Thoughts.

Grazie a queste relazioni esplicitate nello schema, è possibile creare delle join in DBIx::Class:

Questa join parte dal ResultSet di Thoughts e senza filtri fa un JOIN con author attraverso l’accessor author_id.
L’SQL risultante è:

(Il prefisso “me” – inserito da DBIC – indica la tabella a sinistra del join.)

DBIC si appoggia a “schemi” di tabelle nel database che gli permettono di interagire col db-server in maniera corretta (e ottimizzata).
Gli schemi sono un po’ pallosi da estrarre, ma a tutto c’è soluzione:

Dopo questo comando nella directory Sim ci sarà un pacchetto Prova.pm (lo schema) che caricherà le classi che rappresentano le tabelle del database XXX (nella dir Sim/Prova/tabella_*.pm).

Le rappresentazioni delle tabelle sono interessanti da guardare.

Da questo momento sarà possibile scrivere script che usino lo schema (Sim::Prova), si connettano attraverso di esso (metodo connect) ed agiscano sui dati del database XXX.

L’oggetto $schema porta la connessione, tramite ->resultset(‘table’) capisce com’è organizzata la tabella nel db e poi accetta i metodi utili per fare qualcosa (CRUD: Create, Retrieve, Update, Delete).

Un po’ di basic usage e di manualistica.

Se per caso servisse sapere quali driver DBI mette a disposizione, ecco l’elenco dei database a cui è possibile collegarsi.

Di sicuro invece c’è che DBIx::Simple funziona. Non ho ben capito perchè dovrebbe essere più semplice di DBI, però… funziona.

DBI, come ho già scritto in passato, funge così: si carica l’handler, si prepara la query, la si esegue e si fetcha il risultato nella maniera che si ritiene più opportuna. (*)

use DBI;
my $dsn = "dbi:mysql:database=test";
my $dbh = DBI->connect( $dsn, $username, $password )
        or die $DBI::errstr;
my $sth = $dbh->prepare("SELECT * FROM testing")
        or die $dbh->errstr;
$sth->execute();
while ( my $row = $sth->fetchrow_hashref() )
{ ... }

Il vantaggio con DBIx::Simple è che prepare() ed execute() sono compresi in un’unica chiamata. Il fetching dei risultati dovrebbe essere un po’ semplificato, ma a me non ha cambiato la vita (i metodi sono al paragrafo DBIx::Simple::Result methods).

use DBIx::Simple;
my $dbh = DBIx::Simple->connect('dbi:Pg:dbname=test',
        'username', 'password' ) or die DBIx::Simple->error;
my $res = $dbh->query('SELECT * FROM pluto');
while ( $res->into(my($id, $ti, $ra)) ) {
              say "$id $ti $ra";
}

Nota: L’idea del metodo html per ottenere una tabella HTML dal risultato l’ho trovata simpatica.

sub sql_query {
        my ($dbh,$query) = @_;
        my $result = $dbh->prepare($query)
                or print("Failed to set up query: $query\n");
        $result->execute()
                or print("Failed to exec query: $query\n");
        return $result;
}
...
my $dbh = DBI->connect(...)
$risultato = sql_query($dbh, "SELECT * FROM pippo");
while ( my @riga = $risultato->fetchrow_array ) { ... }

use DBI;

my $dbh = DBI->connect("dbi:mysql:dbname","user","passwd")
     or die("Couldn't connect to db");

La query puo’ essere scritta normalmente come $variabile = ‘SELECT bla FROM blabla [...]‘ oppure manipolata in maniera piu’ interessante come segue:

my @columns = qw(id name surname birth notes);
my $query_ins = "INSERT INTO table (".
                join(", ", @columns).
                ") VALUES (".
                join(", ", map {"?"} @columns).
                ")";

Che equivale ad un INSERT INTO table (id, name, surname, birth, notes) VALUES (?, ?, ?, ?, ?);

I punti interrogativi (?) sono i cosiddetti placeholder, che permettono di inserire singoli parametri molto comodamente.

#!/usr/bin/perl

use DBI;

my $dbh = DBI->connect("dbi:mysql:dbname","user","passwd")
     or die("Couldn't connect to db: ".$DBI::errstr);

my $sql = "SELECT id,name,surname FROM table";

my $sth = $dbh->prepare($sql)
     or die("Couldn't prepare statement: ".$dbh->errstr);

$sth->execute();

1) fetchrow_array, questo metodo copia i dati dal db all’array @row e poi li manipola intervenendo sull’array.

while ( my @row = $sth->fetchrow_array() )
{
        print("$row[0]\t$row[1]\t$row[2]\n");
}

2) fetchrow_arrayref, questo metodo crea un riferimento numerico al record nel db.

while ( my $row = $sth->fetchrow_hashref() )
{
        print("$row->[0]\t$row->[1]\t$row->[2]\n");
}

3) fetchrow_hashref, questo metodo crea un riferimento associativo al record nel db.

while ( my $row = $sth->fetchrow_hashref() )
{
        print("$row->{id}\t$row->{name}\t$row->{surname}\n");
}

4) fetchall_arrayref, questo metodo è molto interessante perche’ permette di manipolare tutti i record attraverso le reference di un array di reference. (I dati si possono mischiare, scambiando i riferimenti dell’array di riferimento.)

my $row = $sth->fetchall_arrayref();
# stampano i 3 dati del primo [0] e del secondo [1] record
        print("$row->[0]->[0]\t$row->[0]->[1]\t$row->[0]->[2]\n");
        print("$row->[1]->[0]\t$row->[1]->[1]\t$row->[1]->[2]\n");
# stampa il primo dato del primo record, il secondo dato del secondo
# record, ed il terzo dato del terzo record.
        print("$row->[0]->[0]\t$row->[1]->[1]\t$row->[2]->[2]\n");

5) bind_columns / fetch

my( $id, $name, $surname );
$sth->bind_columns( \$id, \$name, \$surname );
while ($sth->fetch())
{
        print("$id\t$name $surname\n");
}

• CPAN: DBI.pm
• DBI bind columns
• Perl DBI Example
• Idiomi del DBI di Giuseppe Maxia [pdf]
• Perlmeme: connecto to db