ActiveRecord: da Rails a PHP, programmare agilmente (2)

Daniele Veratti — Mon, 12 Jan 2009 11:04:52 +0000

Rieccoci di nuovo a parlare di active record. Nella scorsa puntata avevamo visto una implementazione base del pattern. Essa però è orfana di qualsiasi metodo per la ricerca dei record. Vediamo ora come è possibile farlo.

Rails mette a disposizione diversi metodi per recuperare record dalle tabelle di un database. Il primo è quello di utilizzare il costruttore della classe passando come parametro l’id del record che vogliamo leggere. In molti linguaggi di programmazione Object-Oriented è possibile effettuare l’overload del costruttore, ovvero definire più costruttori per una stessa classe, dove in ogni costruttore cambiano i parametri per numero e/o tipo. In PHP non esiste tale meccanismo (e neanche in Ruby da quanto mi risulta!). Abbiamo visto nella puntata precedente come il costruttore della classe php ActiveRecordBase accetti come unico parametro un array contenente i campi che vogliamo dare ad un nuovo record. Simuliamo ora l’overloading del costruttore in modo che accetti sia l’array che un numero che identifichi l’ID del record.

abstract class ActiveRecordBase {
  # qui ci va la dichiarazione degli attributi della classe che tralasciamo
  # .....
  #
  public function __construct($data=array()){
     $this->__db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!is_array($data) && is_numeric($data)){
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table).
                  " WHERE ".$this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($data);
         $data = $this->__db->queryRow($sql);
     }
     if (!empty($data)) foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
  }
# Qui prosegue il resto del codice della classe
# ....
}

Con questa modifica la nostra classe continua a funzionare accettando 0 o 1 parametro di tipo numerico o array/hash.
Vediamo ora l’implementazione di un metodo find() che permetta di passare come parametro l’ID del record che vogliamo ottenere. Per semplicità d’ora in avanti verranno omesse le dichiarazioni di classe quando non strettamente necessarie.

    public function find($id){
         if (!is_numeric($id)) return false;
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table)." WHERE ".
                  $this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($id);
         $data = $this->__db->queryRow($data);
         if (!empty($data)){
             foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
             return true;
         }
         return false;
    }

Come potete vedere, l’implementazione di find() è molto simile a quella del costruttore. Ricordiamoci il principio DRY (= Don’t Repeat Yourself). Modifichiamo il costruttore e aggiungiamo un metodo privato che assegni a partire da un array i valori corrispondenti agli attributi della classe.
__assignData sarà un metodo privato che assegna i valori agli attributi:

    private function __assignData($data=array()){
        if (!empty($data)){
             foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
             return true;
         }
         return false;
    }

Possiamo semplificare il metodo find():

    public function find($id){
         if (!is_numeric($id)) return false;
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table)." WHERE ".
                  $this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($id);
         $data = $this->__db->queryRow($data);
         return $this->__assignData($data);
    }

E ora rivediamo il costruttore:

  public function __construct($data=array()){
     $this->__db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!is_array($data) && is_numeric($data)){
         $this->find($data);
     }
     $this->__assignData($data);
  }

ActiveRecord: da Rails a PHP, programmare agilmente (1)

Daniele Veratti — Wed, 10 Dec 2008 12:42:19 +0000

Una delle feature del framework Ruby On Rails più potenti è l’implementazione del pattern ActiveRecord. Esso permette di “vedere” ogni record di una tabella del database come istanze di una classe permettendo di eseguire le normali operazioni di CRUD (Create, Read, Update, Delete) con poche righe di codice.

L’implementazione di ActiveRecord in Rails è molto complessa, permette di effettuare validazioni e avere riferimenti a chiavi esterne. Vediamo un’implementazione più semplice in PHP, ma comunque efficace.
Cercheremo di arrivare ad un’implementazione molto potente in qualche puntata.

Il concetto che sta alla base di active record è di trasformare l’accesso al database in accesso a una classe.
Cominciamo a definire una classe base che abbia l’accesso al database. Per semplificare utilizzeremo la classe PEAR::MDB2.

require 'MDB2.php';
abstract class ActiveRecordBase {
  protected $__db; // Dichiariamo un oggetto "protected" per l'accesso al DB
  protected $__primary_key = "id"; // Definiamo una chiave primaria per la tabella. Può essere poi
                                           // modificata per ogni singola classe che estende questa.
  protected $__fields; // In questo attributo di tipo array andremo a salvare i campi della nostra tabella (escluso il campo primary key)
  protected $__table; // In questo attributo salviamo il nome della tabella
  /**
   * Il costruttore istanzia una connessione con il db e se sono presenti dei dati
   * li salva nell'oggetto (non nel database!)
   */
  public function __construct($data=array()){
     $this->db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!empty($data)) foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
  }
 
  /**
   * Definiamo un metodo per create un nuovo Record.
   * Esso è privato perché verrà utilizzato dal metodo save()
   */
  private function create(){
     // Creaimo l'istruzione SQL a partire dai campi disponibili
     $sql = "INSERT INTO ".$this->__db->quoteIdentifier($this->table)." (";
     $first = true;
     $data = array();
     foreach ($this->__fields as $field){
       if (!$first) $sql.=",";
       $sql.= $this->__db->quoteIdentifier($field);
       $data[] = $this->$field;
       $first = false;
     }
     $sql.= ") VALUES (";
     for ($i = 0; $i < count($fields); $i++) if ($i=0) $sql.="?" else $sql.=",?";
     $sql:=");";
     $prep = $this->__db->prepare($sql);
     $res =  $prep->execute($data);
     $pkey_field = $this->__primary_key;
     if ($res) $this->$pkey_field = $this->__db->lastInsertID($this->__table);
     return $res;
  }
 
  private function update(){
    $sql = "UPDATE ".$this->__db->quoteIdentifier($this->__table)." SET ";
    $first = true;
    $data = array();
    foreach ($this->__fields as $field){
      if (!$first) $sql.=",";
      $sql = "$field = ?";
      $data[] = $this->$field;
      $first = false;
    }
    $pkey_field = $this->__primary_key;
    $sql = "WHERE ".$this->db->quoteIdentifier($pkey_field)." = ".$this->db->quote($this->$pkey_field);
    $prep = $this->__db->prepare($sql);
    return $prep->execute($data);
  }
 
  private function delete(){
    $pkey_field = $this->__primary_key;
    $sql = "DELETE FROM ".$this->__db->quoteIdentifier($this->__table).
             " WHERE ".$this->db->quoteIdentifier($pkey_field)." = ".$this->db->quote($this->$pkey_field);
    return $this->__db->query($sql);
  }
 
  public function save(){
     $pkey_field = $this->__primary_key;
     if (!isset($this->$pkey_field)) return $this->create();
     else return $this->update();
  }
 
  public function destroy(){
     $pkey_field = $this->__primary_key;
     if (isset($this->$pkey_field)) return $this->delete();
     else return false;
  }
 
}

In questa implementazione, ancora in stato “embrionale”, è possibile creare un nuovo record.
Un uso molto semplice potrebbe essere creare una classe che estenda la base e istanziarne un oggetto:

require 'ActiveRecordBase.class.php'
class Dog extends ActiveRecordBase {}
$dog = new Dog(array('name' => 'Pluto', 'age' => '7'));
$dog->save();

Il precedente script inserisce un nuovo record in una tabella ‘dog’ (stessa nome della classe che estende ActiveRecordBase) assegnando gli attributi ‘name’ e ‘age’.
La primary key viene implicitamente impostata come “id” (ovviamente se il campo ha l’attributo auto_increment) e il valore inserito automaticamente.
Il tutto in 3 righe di codice, molto molto semplici…non è una bella comodità?
Più avanti vedremo come effettuare ricerche, e quindi come implementare il metodo “find” e migliorare ulteriormente la classe base in modo da gestire meglio errori, validazioni e chiavi esterne.

Ciarpame {.com} » ActiveRecord

ActiveRecord: da Rails a PHP, programmare agilmente (2)

ActiveRecord: da Rails a PHP, programmare agilmente (1)