cojack blog » Doctrine

Doctrine ORM dla PHP cz.2

cojack — Tue, 30 Jun 2009 08:33:16 +0000

Tak więc poznaliśmy już jak połączyć się z bazą danych, teraz należało by dowiedzieć się co nie co o modelach, tworzeniu, automatycznym generowaniu z bazy danych, referencjach pomiędzy tabelami.
Tak więc zacznijmy od tego jak prawidłowo model powinien wyglądać co powinien zawierać?

Model tabeli z bazy danych, jest klasą, w której główną metodą jest public function setTableDefinition(), klasa dziedziczy z Doctrine_Record, w niej należy powiedzieć Doctrine jak się nazywa dana tabela, jakie ma pola, jakiego są one typu, czy mają jakieś ograniczenia.

Przykład


class dTest extends Doctrine_Record
{
  public function setTableDefinition()
  {
    $this->setTableName('test');
    $this->hasColumn('imie','string');
  }
}
?>

Tutaj nawiązując do naszego przykładu wcześniejszego, utworzyliśmy sobie klasę dTest, powiedzieliśmy Doctrine jak się nazywa tabela w bazie danych setTableName, oraz że ta tabela ma 1 kolumnę hasColumn, kolumna nazywa się imie i jest typu string.

Typy danych w Doctrine

W zależności od typu kolumny, każda ma swój odpowiednik w Doctrine (no prawie każda, np nie ma w doctrine typu text, należy użyć string, co ma się zmienić w Doctrine 2.0). Dostępne typy danych dla tabel w Doctrine to:

Boolean
Integer
Float
Decimal
String
Array
Object
Blob
Clob
Timestamp
Time
Date
Enum
Gzip

W Doctrine możemy też używać aliasów dla kolumn, jeżli np mamy nawyk dodawania prefixu dla nazwy kolumny względnie zależnego od typu kolumny, to taki alias może nam ułatwić pracę, spójrzmy:

$this->hasColumn('s_imie as imie','string');

Dzięki temu podczas operacji na takiej kolumnie nie musimy używać jej nazwy s_imie tylko wystarczy wtedy już sam jej alias czyli imie

Nasze kolumny mogą mieć tak jakby modyfikatory, chodź nie do końca, ponieważ o modyfikatorach porozmawiamy później. Zobaczcie sami:

$this->hasColumn('s_imie as imie','string',64, array(
          'type'=>'string',
          'fixed'=> true,
          'notnull'=> true,
          'default' => 'Jaś',
          'lenght'=>64
          )
);

Omówmy te podane powyżej:
type – typ danych
fixed – Doctrine używa typów zmiennej różnej długości, parametr fixed wymusza używanie typów o stałej długości
notnull – komórka nie może być pustą wartością
default – domyślna wartość komórki
lenght – długość jaką może przyjąć wartość

inne nie przedstawione:
scale – dla Decimal, ilość miejsc po przecinku (int)
unsigned – dla Integer, oznaczony nie oznaczony integer (bool)
values -dla Enum, tablica asociacyjna z listą wartości (array), przykład:

$this->hasColumn('kolor', 'enum', null, array(
          'values' => array('zielony', 'czerwony', 'żółty')
);

Teraz jak wygląda ogólna definicja metody hasColumn

$this->hasColumn('nazwa_kolumny','typ_kolumny', zakres_typu, array(
          'modyfikator' => 'wartosc' .... )
);

Kolejną ważną metodą jest public function setUp(), w niej natomiast definiujemy relacje pomiędzy tabelami. Relacje mogą być typu:

one-to-one
one-to-many, many-to-one
many-to-many

Relacja typu one-to-one

Powiązanie jednej tabeli np Użytkownika z inna tabelą np tabelą przechowującą sesje użytkownika, czy czymkolwiek innym. Ogólnie rzecz biorąc powiązanie ma się tak: Po kluczu obcym w tabeli A, łączymy tabele B z kluczem podstawowym, czyli klucz obcy w tabeli A jest kluczem podstawowym w tabeli B i może wystąpić tylko raz! W każdym z przypadków.

Przykład stworzenia takiej metody:

public function setUp()
{
  $this->hasOne('NazwaKlasyModulu', array(
                    'local' => 'id', // pokazujemy na klucz główny
                    'foreign' => 'id_usera' // klucz obcy w tabeli na ktora wskazalismy NazwaKlasyModulu
                    )
  );
}

Tak tworzymy odwołanie macierzyste, czyli dla klasy Users, a tak będzie wyglądać funkcja setUp() w klasie modułu Sesji:

public function setUp()
{
  $this->hasOne('NazwaKlasyModulu', array(
                    'local' => 'id_usera', // pokazujemy na klucz obcy w naszej tabeli
                    'foreign' => 'id' // i wskazujemy że ma odwołanie do klucza głównego
                    )
  );
}

Relacja typu one-to-many oraz many-to-one

Powiązanie jednej tabeli np Użytkownika z inna tabelą np tabelą przechowującą dane adresowe użytkownika. Ogólnie rzecz biorąc powiązanie ma się tak:

Jeden użytkownik może mieć wiele np maili tak? Nie wiemy ile on może mieć tych maili czy np nr telefonów więc w tabeli User nie będziemy ich definiować tylko zrobimy sobie osobną tabelę na te dane adresowe. No więc
Po kluczu głównym w tabeli A, łączymy tabele B z kluczem obcym, czyli klucz podstawowy w tabeli A jest kluczem obcy w tabeli B i może wystąpić parę razy! W każdym z przypadków. Ale nie na odwrót!

Przykład tabela A:

public function setUp()
{
  $this->hasMany('NazwaKlasyModulu', array(
                    'local' => 'id', // pokazujemy na klucz obcy w naszej tabeli
                    'foreign' => 'id_usera' // i wskazujemy że ma odwołanie do klucza głównego
                    )
  );
}

Przykład tabela B:

public function setTableDefinition()
{
   $this->hasColumn('id_usera', 'integer');
   $this->hasColumn('email', 'string', 255);
}
 
public function setUp()
{
  $this->hasOne('NazwaKlasyModulu', array(
                    'local' => 'id_usera', // pokazujemy na klucz obcy w naszej tabeli
                    'foreign' => 'id' // i wskazujemy że ma odwołanie do klucza głównego
                    )
  );
}

Relacja typu many-to-many

Dobra szczeże, nie chce mi się jej opisywać ;D Ale hamskie wiem Dlatego zrobię jeszcze jeden motyw, po prostu na jana zedre przykład z Manuala. Ale tak z grubsza ocb.

Sprawa ma się tak, tworzymy dostęp użytkownikom do czegoś. No to najlepiej ich na grupy podzielić. No więc dlaczego jeden użytkownik nie może być w wielu grupach? A no może czemu nie. No właśnie. Jeden użytkownik może być w wielu grupach, jedna grupa może należeć do wielu użytkowników. I to jest własnie relacja typu many-to-many (hajs hajs ;D) Leci to tak:

class User extends BaseUser
{
    public function setUp()
    {
        parent::setUp();
 
        // ...
 
        $this->hasMany('Group as Groups', array(
                'local' => 'user_id',
                'foreign' => 'group_id',
                'refClass' => 'UserGroup'
            )
        );
    }
}

A teraz model Grup

class Group extends Doctrine_Record
{
    public function setTableDefinition()
    {
        $this->setTableName('groups');
        $this->hasColumn('name', 'string', 30);
    }
 
    public function setUp()
    {
        $this->hasMany('User as Users', array(
                'local' => 'group_id',
                'foreign' => 'user_id',
                'refClass' => 'UserGroup'
            )
        );
    }
}

No i nasza klasa wiążąca te dwie powyższe:

class UserGroup extends Doctrine_Record
{
    public function setTableDefinition()
    {
        $this->hasColumn('user_id', 'integer', null, array(
                'primary' => true
            )
        );
 
        $this->hasColumn('group_id', 'integer', null, array(
                'primary' => true
            )
        );
    }
}

Dobra, jak mi ktoś powie że nie działa to własnoręcznie powiesze za „uszy” Nic nie zmieniać, wrzucić sobie do plików, wygenerować z tego kod sql i zaimportować go do bazy. Liczę na Waszą kreatywność (o bym się nie przeliczył). Więcej można przeczytać na dole w linku Strona projektu. Już nie długo opis konfiguracji Doctrine Sandbox.

Doctrine ORM dla PHP

cojack — Mon, 29 Jun 2009 10:36:51 +0000

Zacznijmy od tego czym jest ORM, ORM z ang Object-Relational Mapping, na Polski, mapowanie obiektowo-relacyjne, co nam to daje, z czym to się je, jeżeli mamy powiązania pomiędzy tabelami (tzw relacje) oraz tworzymy aplikacje zorientowaną obiektowo, pozwala nam taki ORM na działania obiektowe po pobraniu danych z bazy, czyli np pola z bazy danych mamy jako obiekty. Typy danych z pól mamy jako obiekty itp. No to do dzieła, to co nam potrzebne to Doctrine oczywiście, możemy pobrać najnowszą wersje z strony: Doctrine Project
Jeżeli już mamy ściągniętego Doctrine, należy zabrać się do pracy, na początek trzeba nawiązać połączenie z bazą danych, możemy to zrobić na dwa sposoby pracując z Doctrine,

Łącznie się z bazą danych
Pierwszy sposób z PDO:


$con = 'mysql:dbname=nazwa_bazy;host:ip_hosta';
$user = 'nazwa_uzytkownika';
$haslo ='haslo_uzytkownika';
 
$pdo_conn = new PDO ($con, $user, $haslo);
$doc_conn = Doctrine_Manager::connection($pdo_conn);
?>

Doctrine w taki sposób nie ma możliwości dostania nazwy użytkownika i hasła i jeżeli chcemy później przy pomocy Doctrine tworzyć bazę danych, lub ją usuwać musimy musimy podać te informacje w taki sposób:


$doc_conn->setOption('username',$user);
$doc_conn->setOption('password',$haslo);
?>

No i teraz będzie grała muzyka

Drugi sposób z Doctrine:
Jest o tyle lepszy, że jeżeli nie potrzebujemy połączenia z bazą danych, Doctrine nie wywołuje go automatycznie, więc nie męczymy serwera. Ogólny schemat wygląda tak:

typbazy://uzykownik:haslo@adres/nazwa_bazy

Gdzie typ bazy może być:

mysql dla MySQL
psql dla PostgreSQL
ico dla Oracle 7/8/9/10
fbsql dla FrontBase
ibase dla InterBase/FireBird wymagany PHP 5
querysim dla QuerySim
sqlite (tak sqlite przez jedno l) dla SQLite 2
mssql dla Microsoft SQL Server (nie gra z Sybase)

Tak więc połączmy się:


require_once('Doctrine.php'); // wczytujemy klase Doctrine
spl_autoload_register(array('Doctrine', 'autoload')); // auto ładowanie klasy
$manager = Doctrine_Manager::getInstance(); // w późniejszym etapie wyjaśnię
$dbconn = 'psql://testowy:test123@127.0.0.1/testowa';
set_time_limit(0);
$dbhandle = Doctrine_Manager::connection($dbconn,'polaczenie');
?>

Jeżeli nie dostaniemy żadnego błędu tzn że połączenie z bazą danych się udało prawidłowo.
Sprawdźmy czy działa nasze połączenie, utworzymy sobie tabele i wrzucimy do niej jakieś treści:


$dbhandle->export->createTable('test',array('imie' => array('type' => 'string')));
$dbhandle->execute('INSERT INTO test (imie) VALUES (?)',array('Andrzej'));
$query = $dbhandle->prepare('SELECT * FROM test');
$query->execute();
$result = $query->toArray();
print_r($result);
?>

Powinno nam zwrócić:

Array
(
  [0] => Array
  (
    [imie] => Andrzej
    [0] => Andrzej
  )
)

dziękuje Paweł za wytknięte błędy, usunięto mysqli z listy typu, z prostej przyczyny, nie ma takiego drivera pdo

Klasa sesji

cojack — Mon, 29 Jun 2009 00:20:00 +0000

Tak więc poniżej przedstawiam Wam gotową bezpieczną klasę sessji, napisaną na Doctrine, klasa zapisuje dane sessji do bazy danych, uaktualnia ostatnie logowanie użytkownika, czyści sessjie z bazy danych (stare i nie aktualne), weryfikuje ip użytkownika, user agenta przeglądarki, nie można się zalogować z dwóch różnych przeglądarek, nie można się zalogować z dwóch różnych adresów ip na tego samego użytkownika w tym samym czasie.


/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author cojack from Aichra.pl
 * @date 16.06.09
 *
 **/
 
 
class UserSession
{
    private $php_session_id;						 # php session id zapisywane przy logowaniu
    private $ff_session_id;							 # bezpieczny session id
    private $logged_in;									 # bool, zalogowany user
    private $user_id;										 # user id
    private $time_start;								 # czas zalogowania usera
    private $check_browser = true;			 # bool, sprawdzac przegladarke usera
    private $check_ip_blocks = 4;				 # ile blokow ip ma byc sprawdzanych 
    private $session_name = 'Testing';   # nazwa sessji
    private $secure_word = 'GzuH3sLaURRCsuCd'; # sól
    private $session_timeout = 600;      # 10 minutowa nieaktywnosc sessji
    private $session_lifespan = 3600;    # 1 godzinna waznosc sessji, po tym nastapi wylogowanie
    
    public function __construct() 
    {
      # Ustawiamy czas życia ciasteczek
      session_set_cookie_params($this->session_lifespan);
      # Ustawiamy nazwe sessji
      session_name($this->session_name);
      # Startujemy sessje
      session_start();
      # Regenerowanie php session id, zabezpieczenie przed atakami PHP_SID
      $this->_session_idregenerate();
      # czyścimy sessje 
      $this->_session_clean();
      # sprawdzamy czy user jest zalogowany
     	$this->_session_read();
     	# aktualizujemy czas sessji
    	$this->_session_timeupdate();
    }
 
    private function _session_timeupdate() 
    {
      if ($this->ff_session_id) 
      {
				$query = Doctrine_Query::create()
								 ->update('dUserSession')
								 ->set('ostatnia_reakcja',time())
								 ->where('ff_sid = ?',$this->ff_session_id);
				$result = $query->execute();
      }
    }
 
    public function IsLoggedIn() #zwracamy wartość boolean, czy użytkownik jest zalogowany
    {
    	return($this->logged_in);
    }
 
    public function GetUserID() #zwracamy id użytkownika
    {
      if ($this->logged_in) 
      {
        return($this->user_id);
      } 
      else 
      {
        return(false);
      }
    }
 
    public function GetFfSessionIdentifier() # zwracaamy ff_sprinta
    {
    	return($this->ff_session_id);
    }
 
    public function Login($login, $haslo) #logowanie użytkownika
    {
    	if($this->logged_in == false)
    	{
	      $md5haslo = md5($haslo);
	      $query = Doctrine_Query::create()
	      				 ->select('id')
	      				 ->from('dUser')
	      				 ->where('login = ?',$login)
	      				 ->andWhere('haslo = ?',$md5haslo);
	      $result = $query->execute();
	      $result = $result->toArray();
	      if (!empty($result))
	      {
	        $this->user_id = $result[0]['id'];
	        $this->logged_in = true;
					$this->_session_start();
					return (true);
	      }
	      else
	      	throw new Exception (Errors::_getError('l_01'));
    	}
    	else
    		throw new Exception (Errors::_getError('l_03'));
    }  
 
    public function LogOut() 
    {
      if ($this->logged_in == true) 
      {
      	var_dump($this->logged_in);
				$this->_session_destroy($this->user_id);
        $this->logged_in = false;
        $this->user_id = 0;
        return(true);
      }
      throw new Exception (Errors::_getError('l_02'));
    }
 
    private function _session_start()
    {
    	$this->time_start = time();
    	$this->_session_open();
			$this->_session_write();
			$this->_session_misc();
			return (true);
    }
 
    private function _session_open() 
    {
			$this->php_session_id = session_id();
			$this->ff_session_id = $this->_session_secure();
    }
 
    private function _session_write() 
    {
    	if($this->_session_check())
    	{
	    	$query = new dUserSession;
	    	$query->php_sid = $this->php_session_id;
	    	$query->ff_sid = $this->ff_session_id;
	    	$query->zalogowany = $this->logged_in;
	    	$query->iidusera = $this->user_id;
	    	$query->ostatnia_reakcja = $this->time_start;
	    	$query->utworzono = $this->time_start;
	    	$query->user_agent = $_SERVER['HTTP_USER_AGENT'];
	    	$query->save();
	    	$query = Doctrine_Query::create()
	    					 ->update('dUser')
	    					 ->set('lastvisit',$this->time_start)
	    					 ->where('id = ?',$this->user_id);
				$result = $query->execute();
    	}
    }
 
    private function _session_misc()
    {
    		setcookie('ff_sprint',$this->ff_session_id,($this->time_start+$this->session_lifespan));
    		$_SESSION['ff_sprint'] = $this->ff_session_id;
    }
 
    private function _session_read() 
    {
      $query = Doctrine_Query::create()
      				 ->select('id, zalogowany, iidusera')
      				 ->from('dUserSession')
      				 ->where('ff_sid = ?',$_SESSION['ff_sprint']);
			$result = $query->execute();
			$result = $result->toArray();
      if (!empty($result)) 
      {
	       $this->native_session_id = $result[0]['id'];
	       $this->ff_session_id = $_SESSION['ff_sprint'];
	       if ($result[0]['zalogowany']== 'true') 
	       {
	       	$this->logged_in = true;
	       	$this->user_id = $result[0]["iidusera"];
	       }
	       else {
	       	$this->logged_in = false;
	       }
	       $this->_session_compare();
	     }
     return(true);
    }
 
    private function _session_clean()
    {
			$strUserAgent = $_SERVER["HTTP_USER_AGENT"];
      $this->ff_session_id = $_COOKIE["ss_fprint"];
      $query = Doctrine_Query::create()
      				->select('id')
      				->from('dUserSession')
      				->where('ff_sid = ?',$this->ff_session_id)
      				->andWhere('(('.time().' - utworzono) < ? ) ',$this->session_lifespan)
      				->andWhere('user_agent = ? ',$strUserAgent)
      				->andWhere('('.time().' - ostatnia_reakcja) <= ? ',$this->session_timeout)
      				->orWhere('ostatnia_reakcja IS NULL');				
      $result = $query->execute();
      $result = $result->toArray();
      if (empty($result)) 
      {
        $query = Doctrine_Query::create()
        				 ->delete('dUserSession')
        				 ->where('ff_sid = ?',$this->ff_session_id)
        				 ->orWhere('('.time().' - utworzono) > ?',$this->session_lifespan)
        				 ->orWhere('('.time().' - ostatnia_reakcja) > ?',$this->session_timeout);
			  $result = $query->execute();
      }
    }
 
    private function _session_check()
    {
    	$query = Doctrine::getTable('dUserSession')->findOneByiidusera($this->user_id);
    	if(empty($query))
    	{
    		return (true);
    	}
    	else
    	{
    		$this->_session_compare();
    	}
    }
 
 
    private function _session_compare()
    {
    	$query = Doctrine::getTable('dUserSession')->findOneByiidusera($this->user_id);
			if ($query->ff_sid == $this->ff_session_id)
			{
				return (true);
			}
			else
			{
				$this->_session_destroy();
				throw new Exception (Errors::_getError('l_04'));
			}
    }
 
    private function _session_secure()
    {
        $fingerprint = $this->secure_word;
        if ($this->check_browser) {
            $fingerprint .= $_SERVER['HTTP_USER_AGENT'];
        }
        $fingerprint .= $this->user_id;
        if ($this->check_ip_blocks) {
            $num_blocks = abs(intval($this->check_ip_blocks));
            if ($num_blocks > 4) {
                $nxum_blocks = 4;
            }
            $blocks = explode('.', $_SERVER['REMOTE_ADDR']);
            for ($i = 0; $i < $num_blocks; $i++) {
                $fingerprint .= $blocks[$i] . '.';
            }
        }
        $fingerprint .= $this->time_start;
        $fingerprint .= $this->php_session_id;
        return md5($fingerprint);
    }
 
    private function _session_idregenerate()
    {
        if ($this->regenerate_id && function_exists('session_regenerate_id')) {
            if (version_compare('5.1.0', phpversion(), '>=')) {
                session_regenerate_id(true);
            } else {
                session_regenerate_id();
            }
        }
    }
 
    private function _session_destroy() 
    {
    	$query = Doctrine_Query::create()
      				 ->delete('dUserSession')
       				 ->where('iidusera = ?',$this->user_id)
       				 ->orWhere('ff_sid = ?',$this->ff_session_id);
			$result = $query->execute();
			$this->_session_close();      
    }
 
    private function _session_close() 
    {
    	if (isset($_COOKIE['ff_sprint'])) 
    	{ 
			   setcookie('ff_sprint', '', time()-84000, '/'); 
			}
			$_SESSION = array();
			$_COOKIE = array();
			session_destroy();
    }
 
    public function __destruct()
    {
    	unset($query,$result);
    }
}
?>

Jak będę miał czas to o komentuję tą klasę, poniżej modele Doctrine dla Usera oraz dla Sessji


/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author cojack from Aichra.pl
 * @date 19.06.09
 *
**/
 
class dUserSession extends Doctrine_Record
{
  public function setTableDefinition()
  {
    $this->setTableName('user_session');
    $this->hasColumn('ssession_identifer_php as php_sid','string',32);
    $this->hasColumn('ssession_identifer_ff as ff_sid','string',32); 
    $this->hasColumn('bzalogowany as zalogowany','boolean');
    $this->hasColumn('iidusera','integer');
    $this->hasColumn('iostatnia_reakcja as ostatnia_reakcja','integer');
    $this->hasColumn('iutworzono as utworzono','integer');
    $this->hasColumn('user_agent','string',256);
  }
 
  public function setUp()
  {
 
    $this->hasOne('dUser',array(
    	'local' => 'iidusera',
    	'foreign' => 'id'
    	)
    );
  }
}
 
?>

Teraz dla użytkownika:


/**
 * @li gnu/agpl v3 or leter
 * @code utf8
 * @version 0.1
 * @author cojack from Aichra.pl
 * @date 10.06.09
 *
 * For Doctrine ORM for php, create a model with reference to group, to easier adding a group to user, manager etc.
 * Relation is many-to-many, user can have many groups and group can have many users.
 * 
**/
 
class dUser extends Doctrine_Record
{
  public function setTableDefinition()
  {
    $this->setTableName('users');
    // we don't have to define id column, it's auto defined by Doctrine, called id, and auto incrament it
    $this->hasColumn('slogin as login','string',64); // it's a login for user, s here tell us it's a string value
    $this->hasColumn('shaslo as haslo','string',32); // same like upper, but with one difreneces, it's a password in md5 sum
    $this->hasColumn('simie as imie','string',64); // same like upper, it's first name
    $this->hasColumn('snazwisko as nazwisko','string',64); // same like upper, it'f second name (last name etc)
    $this->hasColumn('ilastvisit as lastvisit','integer'); // it's a time in unixitimestamp (UNIX epoch), this value is integer
  }
 
  public function setUp()
  {
    $this->hasMany('dGroup as dGroups', array (
      'refClass' => 'dUser2Group', // we have reference this relation to class UserGroup, table name called user2group
      'local' => 'iidusera', // creating reference from local user id
      'foreign' => 'iidgrupy' // to group id in table user2group (class UserGroup)
    	)
    );
 
    $this->hasOne('dUserSession',array(
    	'local' => 'id',
    	'foreign' => 'iidusera'
    	)
    );
 
    $this->hasMutator('haslo','md5haslo');
  }
 
  public function md5haslo($value)
  {
  	$this->_set('haslo',md5($value));
  }
}
 
?>

Jestem bardzo nie usystemowany, i raz piszę po ang a raz po pl

A teraz kod SQL dla klasy,

CREATE TABLE "users" 
(
  "id" serial UNIQUE PRIMARY KEY NOT NULL,
  "slogin" VARCHAR(64) NOT NULL,
  "shaslo" VARCHAR(32) NOT NULL,
  "simie" VARCHAR(64) NOT NULL,
  "snazwisko" VARCHAR(64) NOT NULL,
  "ilastvisit" INT
);
 
CREATE TABLE "user_session"
(
  "id" serial UNIQUE PRIMARY KEY NOT NULL,
  "ssession_identifer_php" VARCHAR(32),
  "ssession_identifer_ff" VARCHAR(32),
  "bzalogowany" BOOLEAN,
  "iidusera" INT,
  "iostatnia_reakcja" INT,
  "iutworzono" INT,
  "user_agent" VARCHAR(256),
  FOREIGN KEY ("iidusera") REFERENCES "users"("id")
);

To by było na tyle