Nel codice che componeva le classi per la gestione delle tabelle del nostro database avrete notato la presenza delle proprietà $_name, $_referenceMap e $_dependentTables.
Vediamole nel dettaglio

La proprietà $_name serve a salvare internamente ad una classe il nome della tabella a cui questa è relazionata. Infatti, in caso di omissione di questa proprietà, il sistema andrebbe a cercare una tabella con lo stesso nome della classe, preservando le lettere maiuscole/minuscole. Per fare un esempio, se $_name fosse omessa nella classe Utenti, la tabella Utenti sarebbe ricercata dal sistema e questo genererebbe un errore. Siccome per convenzione nominiamo le nostre classi con la prima lettera maiuscola , la proprietà $_name ci viene incontro per salvare il nome corretto della tabella.

Vediamo adesso il codice della classe Recensioni. Questa classe è l’unica a contenere la proprietà $_referenceMap. Questa proprietà è un array che serve ad indicare a quale classe relazionare le foreign keys presente nella tabella in questione e nel nostro caso, la tabella recensioni è l’unica a contenere foreign keys. Le chiavi di questo array conterranno il nome della relazione ( rules ) ed il loro valore sarà un array contenente la foreign key, il nome della classe a cui la relazione si riferisce ed il nome della colonna di relazione, rispettivamente columns, refTableClass e refColumns.

$_referenceMap in Recensioni

    protected $_referenceMap = array(
      'Paesi' => array(
        'columns'           => array('id_paese'),
        'refTableClass'     => 'Paesi',
        'refColumns'        => array('id')
      ),
      'Utenti' => array(
        'columns'           => array('id_utente'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      ) ,
      'Abilitazione' => array(
        'columns'           => array('id_utente_abilitazione'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      )
    );

Infine $_dependentTables è un array che definisce la o le classi ( tabelle ) direttamente dipendenti. Nel caso di Utenti e Paesi il valore di $_dependentTables è un array contenente Recensioni

Esempi di utilizzo

Inseriamo quindi qualche esempio nel nostro IndexController, il seguente codice è un esempio di accesso ai dati del database al row level

$utenti = new Utenti;
$myself = $utenti->fetchRow('id = 1');
$this->view->myself = $myself->name;

Il metodo fetchRow() ritorna una istanza della classe Utente, mentre name richiama l’omonimo metodo, la possibilità di effettuare una chiamata ad un metodo come se si trattasse di una proprietà l’abbiamo aggiunta tramite l’overload del metodo magico __get() ( ricordate? ne abbiamo parlato lo scorso articolo ). Per visualizzare la variabile ottenuta aggiungeremo in index.phtml la seguente linea

<p>Utente ID 1: <?php echo $this->myself;?> </p>

Il metodo findDependentRowset

Questo metodo serve per effettuare una relazione uno a molti ed utilizza le proprietà $_referenceMap e $_dependentTables. Di seguito un esempio di utilizzo

$paesi = new Paesi;
$paese= $paesi->fetchRow('id = 1');
$resOne = $paese->findDependentRowset( 'Recensioni');

Il metodo findManyToManyRowset

Questo metodo serve per effettuare una relazione molti a molti ed utilizza anch’esso le proprietà $_referenceMap e $_dependentTables di cui abbiamo parlato. Il primo argomento è la tabella di destinazione, metre il secondo argomento è la tabella di incrocio.

$utenti = new Utenti;
$myself = $utenti->fetchRow('id = 1');
$resOne = $myself->findManyToManyRowset( 'Paesi','Recensioni');

Il rowset risultante sarà composto da tutti i campi della tabella recensioni e da tutti i campi della tabella paesi, le righe selezionate ovviamente saranno quelle dove id_utente in recensioni è = a 1 ( l’utente selezionato da fetchRow() ). Questo metodo accetta eventuali regole definite in $_referenceMap. Infatti, in caso volessimo selezionare non le recensioni scritte dall’id 1 ma bensi le recensioni abilitate dall’utente id 1, il codice sarebbe il seguente

$utenti = new Utenti;
$myself = $utenti->fetchRow('id = 1');
$resOne = $myself->findManyToManyRowset( 'Paesi','Recensioni','Abilitazione');

Testate entrambe i casi eventualmente aggiungendo degli altri record al vostro database. Questo è il codice da inserire in index.phtml

<?php if(count($this->resOne)): ?>
<table>
<tr>
  <td>Id</td>
  <td>Nome</td>
  <td>Descrizione</td>
</tr>
<?php foreach($this->resOne as $p): ?>
<tr>
  <td><?php  echo $p->id; ?></td>
  <td><?php  echo $p->nome; ?></td>
  <td><?php echo $p->descrizione; ?></td>
</tr>
<?php endforeach;?>
</table>
<?php endif;?>

Si conclude così questa settima parte. Per ogni dubbio siete invitati ad utilizzare la funzionalità commento al termine di ogni articolo

Related posts:

1. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
2. Zend Framework: introduzione al componente Zend_Form Creare form web con Zend Form Con Zend Framework possiamo...

Related posts brought to you by Yet Another Related Posts Plugin.

Ritorniamo sull’argomento modelli iniziato qualche articolo fa, in questo articolo tratteremo come recuperare i dati dal database con Zend Framework. Una volta creato l’oggetto $db tramite chiamata al metodo statico factory, potremo procedere in diversi modi.

Effettuare una query

Tramitel’utilizzo del metodo ‘query’ potremo eseguire direttamente la query da noi specificata sul database, ad esempio:

$data = $db->quote('1990-01-01');
$sql = 'SELECT * FROM utenti WHERE data_di_nascita > ' . $date;
$result = $db->query($sql);

Nel codice precedente abbiamo utilizzato il metodo ‘quote’ che effettua per noi l’inserimento degli apici in modo da creare una query corretta ed esente da pericoli di SqlInjections.
Tuttavia potrebbe capitare di dimenticare di usare quote quindi l’ideale potrebbe essere utilizzare il seguente metodo per scrivere una query corretta e sicura:

$sql = 'SELECT * FROM utenti WHERE data_di_nascita > ?'
$result = $db->query($sql, array('1990-01-01'));

In ogni caso, il $result sarà un oggetto su cui potremo effettuare le chiamate dei metodi fetch() e fetchAll() per il recupero dei dati.

Zend_Db_Select

Zend_Db_Select è un oggetto che ci viene in aiuto per costruire delle query per la selezione di dati utilizzando maggiormente il linguaggio php piuttosto che SQL. Prendendo in considerazione l’esempio precedente, il codice qui di seguito mostra come ottenere lo stesso risultato utilizzando questa classe:

$select = new Zend_Db_Select($db);
$select->from('utenti');
$select->where('data_di_nascita > ?', '1990-01-01');
$result = $select->query();

Inserimento, Modifica ed Eliminazione dei dati con Zend_Db_Adapter

Per effettuare queste operazioni, la classe Zend_Db_Adapter ci offre i metodi insert(), update() e delete() rispettivamente. Il loro utilizzo è decisamente semplice, creare un array associatico con chiave il nome del campo della nostra tabella e come valore appunto il valore che dovrà avere questo campo, e passarlo ai vari metodi sopra citati nei seguenti modi:

inserimento

  $data = array(,
    'nome' => 'Mark',
    'cognome' => 'Hollis',
    'inserimento_data' => date('Y-m-d')
  ); 

  $table = 'utenti';
  $rows_affected = $db->insert($table, $data);
  $last_insert_id = $db->lastInsertId();

modifica

  $data = array(,
    'paese' => 'United Kingdom'
  ); 

  $table = 'utenti';
  $where = $db->quoteInto('country = ?', 'UK');
  $db->update($table, $data, $where);

elimina

  $table = 'utenti';
  $where = 'id = 2';
  $rows_affected = $db->delete($table, $where);

Inserimento, Modifica ed Eliminazione dei dati con Zend_Db_Table

Un’interessante metodo per la gestione del database ci viene offerto dalla classe Zend_Db_Table. Questa classe gestisce ogni tabella del database come se fosse un oggetto. Prima di cominciare con gli esempi aggiungiamo una nuova tabella al nostro database

CREATE TABLE `utenti` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(99) NOT NULL,
  `password` varchar(32) NOT NULL,
  `nome` varchar(99) NOT NULL,
  `cognome` varchar(99) NOT NULL,
  `sesso` enum('M','F') default NULL,
  `data_di_nascita` datetime NOT NULL,
  `paese` varchar(99) default NULL,
  `cap` varchar(20) NOT NULL,
  `inserimento_data` datetime NOT NULL,
  `inserimento_user_id` int(11) NOT NULL,
  `inserimento_ip` varchar(15) NOT NULL,
  `modifica_data` timestamp NULL default NULL on update CURRENT_TIMESTAMP,
  `modifica_user_id` int(11) default NULL,
  `modifica_ip` varchar(15) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;

INSERT INTO `utenti` (`id`, `username`, `password`, `nome`, `cognome`, `sesso`, `data_di_nascita`, `paese`, `cap`, `inserimento_data`, `inserimento_user_id`, `inserimento_ip`, `modifica_data`, `modifica_user_id`, `modifica_ip`) VALUES
(1, 'Razorblade', '0c88028bf3aa6a6a143ed846f2be1ea4', 'Sergio', 'Rinaudo', 'M', '1982-03-26 20:56:22', NULL, '10023', '2008-08-16 20:56:51', 1, '127.0.0.1', '2008-08-16 20:57:01', NULL, NULL);

Abbiamo dunque creato la tabella utenti, quindi possiamo procedere alla creazione della relativa classe. Questo nuovo file andrà salvato nella directory models

Utenti.php

<?php

  class Utenti extends Zend_Db_Table_Abstract
  {
    protected $_name = 'utenti';
    protected $_rowClass = 'Utente';
    protected $_dependentTables = array('Recensioni');
  }

In quanto Utenti estende Zend_Db_Table_Abstract come potete immaginare ne eredita i vari metodi e proprietà. Prima di procedere alla spiegazione di cosa siano le proprietà presenti all’interno della classe Utenti diamo uno sguardo su come effettuare le medesime operazioni di inserimento, modifica e update utilizzando Zend_Db_Table_Abstract

inserimento

  $utenti = new Utenti(); 

  $data = array(,
    'nome' => 'Mark',
    'cognome' => 'Hollis',
    'inserimento_data' => date('Y-m-d')
  ); 

  $id = $utenti->insert($data);

modifica

  $utenti = new Utenti(); 

  $data = array(,
    'paese' => 'United Kingdom'
  ); 

  $where = $db->quoteInto('country = ?', 'UK');
  $utenti->update($data, $where);

elimina

  $utenti = new Utenti(); 

  $where = 'id = 2';
  $utenti->delete($where);

Creazione dei nuovi modelli per l’applicazione

Prima di listare il codice delle classi delle altre tabelle del nostro database, ovvero recensioni e paesi, dobbiamo fare una precisazione sui livelli di accesso al database, che possono essere di due tipi: tabella e riga. Il primo livello di accesso è utlizzato quando dobbiamo creare dei listati di record, il secondo livello è utilizzato quando abbiamo a che fare con un singolo record della tabella.

Lavorando al secondo livello di accesso è inoltre possibile utilizzare il metodo save() in sostituzione di insert e update, il codice per effettuare entrambe le operazioni è molto simile:

inserimento

  $utenti = new Utenti();
  $riga = $utenti->fetchNew(); 

  $riga->nome = 'Mark';
  $riga->cognome = 'Hollis'; 

  $riga->save();

modifica

  $utenti = new Utenti();
  $riga = $utenti->fetchRow('id=2'); 

  $riga->nome = 'Mark';
  $riga->cognome = 'Hollis'; 

  $riga->save();

La classe Utenti da noi creata poco sopra agisce a livello di tabella. Al suo interno si trova una proprietà, $_rowClass, che indica il nome della classe per la gestione del secondo livello di accesso, ovvero Utente. Il seguente è il codice che ha attualmente Utente:

<?php

  class Utente extends Zend_Db_Table_Row_Abstract
  {
    public function name(){
      $name = trim($this->nome . ' ' . $this->cognome);
      if (empty($name)) {
        $name = $this->username;
      }
      return $name;
    }

    function __get($key)
    {
      if(method_exists($this, $key)){
        return $this->$key();
      }
      return parent::__get($key);
    }
  }

Come avrete sicuramente notato, il primo livello di accesso è gestito dalla classe Zend_Db_Table_Abstract mentre il secondo è gestito da Zend_Db_Table_Row_Abstract . Nella classe Utente abbiamo inserito due metodi, il primo serve a ricavare il nome dell’utente selezionato, il secondo è un metodo magico ( presto disponibile un articolo sui metodi magici su questo blog, fino ad allora vi consiglio una ricerca su google per saperne di più ) che ci da la possibilità di richiamare il metodo name come se fosse una proprietà ( omettendo le parentesi ).

Di seguito trovate il codice attuale delle classi Paesi e Recensioni, da inserire all’interno della directory models, assieme ad Utenti e Utente

Paesi

<?php

  class Paesi extends Zend_Db_Table
  {
    protected $_name = 'paesi';
    protected $_dependentTables = array('Recensioni');

    function fetchLatest($count = 10){
      return $this->fetchAll(null,'inserimento_data DESC', $count);
    }
  }

Recensioni

<?php 

  class Recensioni extends Zend_Db_Table_Abstract
  {
    protected $_name = 'recensioni';
    protected $_referenceMap = array(
      'Paesi' => array(
        'columns'           => array('id_paese'),
        'refTableClass'     => 'Paesi',
        'refColumns'        => array('id')
      ),
      'Utenti' => array(
        'columns'           => array('id_utente'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      ) ,
      'Abilitazione' => array(
        'columns'           => array('id_utente_abilitazione'),
        'refTableClass'     => 'Utenti',
        'refColumns'        => array('id')
      )
    );
  }

Nel prossimo articolo continueremo il discorso sui modelli, spiegando nel dettaglio a cosa servono le proprietà $_referenceMap e $_dependentTables ed effettueremo dei test di visualizzazione.

Related posts:

1. Zend Framework: Zend_Form con ReCaptcha Utilizzare il webservice ReCaptcha per validare i form ReCaptcha è...
2. Neobazaar annunci gratuiti: esempio di una applicazione sviluppata con Zend Framework Nasce Neobazaar.com, annunci gratuiti in Italia: interamente sviluppato con Zend...
3. Zend Framework: gestione dei moduli ed esempio modulo di amministrazione Come usare Zend_Layout per la gestione dei moduli In quest'articolo...

Related posts brought to you by Yet Another Related Posts Plugin.