Active Record + biblioteka funkcji a połączenia, z bazą danych (trochę filozoficzne) Opcje

[Aztech]

Zagadnienie, które mnie nurtuje to jak zorganiwazować połączenia z bazą danych w bibliotekach (zbiorach funkcji) a mianowicie dokładnie
(*) klasy reprezentujące rekordy poszczególnych tabel zgodnie z filozofią Active Record posiadają klasę bazową baseClass, która w konstruktorze wywołuje połączenie z bazą danych (to jest dobre )
(*) teraz przystępuję do pisania zbioru funkcji, łączonych w biblioteki, będą to funkcje zwracające z bazy MySQL różne tablice z danymi np:

[PHP] pobierz, plaintext 
<?php
 
  function getNotActivePrivateGroups() {/* kod */}
  function getActivePrivateGroups() {/* kod */}
  function getPrivateGroupUsersList() { /* kod */}
 
?>
[PHP] pobierz, plaintext 

itp

Pytanie brzmi: o ile dla klas połączenie było realizowne w kontruktorze, to jak lepiej zrobić to dla zbioruy takich funkcji bibliotecznych.

1) czy lepiej w ciele każdej z tej funkcji łączyć się i rozłączać z bazą danych
2) czy może lepsze jest zastosowanie parametru przekazującego obiekt PDO

[PHP] pobierz, plaintext 
<?php
 
   function getNotActivePrivateGroups(dbPDOConn){/* kod */}
 
?>
[PHP] pobierz, plaintext 

3) a może nieładnie skorzystać z globalnego obiektu odpowiedzialnego za połączenie?

Zastanawiam się jak się będzie to miało do wydajności (szybkości działania) aplikacji w momencie gdy będą wykonywane duże ilości takich zapytań w jednym skrypcie? Jak państwo rozwiązujecie takie problemy?

[matid]

Moim zdaniem najlepiej będzie zastosować albo wzorzec Registry albo Singleton.

[ActivePlayer]

a wydawało mi się to juz skrajnie jasne - połączenia z bazą zawsze trzymam jako singleton - bo mam w 99% jedno. Jesli mialo by byc wiecej uzylbym registry.

czy lepiej w ciele każdej z tej funkcji łączyć się i rozłączać z bazą danych

Mi zawsze wydawało się ze laczysz sie na starcie (ew przy 1 zapytaniu), a rozłączasz na koncu. Wg Twojego podescia mialbys sie łączyc i rozłączac pomiedzy kazdym zapytaniem?

czy może lepsze jest zastosowanie parametru przekazującego obiekt PDO

Lepsze ale troche nie wygodne. Ja juz sie praktycznie zakochałem w moim 'DB_Connection::get_instance()', nawiasem mowiac php4kowym

3) a może nieładnie skorzystać z globalnego obiektu odpowiedzialnego za połączenie?

No, czyli takie 'registry', przy 1 pobraniu obiektu tworzysz db_connection, a potem za kazdym razem zwraca jego instancje. simple, wydajnie i ogolnie gra muzyka : )

[matid]

A poza tym mówienie o wzorcach w stylu ActiveRecord i zostosowanie ich w zbiorach funkcji, zamiast w obiektach wzorca DomainModel lub podobnych brzmi nieco śmiesznie

[Aztech]

@Matid, żle mnie zrozumiałeś (albo ja wyraziłem się niezbyt precyzyjnie ?), wzorzec Active Record nie ma nic wspólnego ze zbiorami funkcji, chodziło mi tylko o pokazanie, że w tworzonym obiekcie, w jego konstruktorze wywołuję połączenie z bazą danych, przestaje istnieć obiekt, przestaje istnieć połączenie.
Jak się zapewnie domyślasz funkcje, które tutaj przytoczyłem, będą znajdowały sie w panelu administracyjnym. Admin/użytkownik pobiera np informacje o nieaktywowanych (=niezaakdeptowanych przez niego) forach, następnie gdy zaznaczy któreś z nich dopiero wtedy "do gry" wejdzie obiekt wg wzorca Active Record, który wczyta dane (jeden wiersz) dotyczace tego forum, zaktualizuje pole odpowiedzialne za aktywowanie ot tyle. Tyle w kwesti wyjaśnień (tutaj swego czasu gdy zaczynałem przygode z php5 uświadamiali mnie o wzorcach)

Teraz miałbym prośbę, do osób, które się w tych wątkach już wypowiadały (albo zamierzają ) i mają spore doświadczenie w większych projektach, czy mogłyby podrzucić linki do dobrych kursów, artykułów dotyczących wzorca Singleton oraz Registry, chodzi mi o sprawdzone, dobre źródło informacji na temat w/w do których sami często sięgacie.

Jeśli nie sprawi Wam to problemu, może pokazalibyście jak macie rozwiązane w swoich frameworkach poruszone przeze mnie kwestie dotyczace połączeń z bazą?

Poniżej moja klasa bazowa, po której dziedziczą wszystkie następne klasy w tym te korzystające z wzorca Active Record

[PHP] pobierz, plaintext 
<?php
 
/**
 * @author Tomasz Suchanek
 * @copyright Tomasz Suchanek 
 * @final 
 */
 
#includy
require_once('config.inc.php');
require_once("$RBX_CORE/includes/errors.inc.php");
require_once("$RBX_CORE/includes/constant.inc.php");
 
/**
 * Klasa bazowa dla wszystkich klas
 *
 */
abstract class BaseClass {
 
 
  /**
   * Połaczenie z bazą danych
   *
   * @var array PRzechowuje identyfiaktor połączenia z bazą danych.
   * @access private
   */
  private  $db;
 
  /**
   * Wynik zapytania
   *
   * @var array Wynik zapytania skierowanego do bazy
   * @access private   
   */
  private $result;
 
  /**
   * Zapytanie do bazy
   *
   * @var string Zapytanie kierowane do bazy
   * @access private
   */  
  private $sql;	
 
  /**
   * Konstruktor
   *
   * @param array $rbx_db Tablica zawierająca dane potrzebne do połączenia się z b
azą danych
   * @access public
   */	  
  public function __construct($rbx_db){
 
	# połącz z bazą typu MySQL	   
	$this->db = new PDO("mysql:host=".$rbx_db["host"].";dbname=".$rbx_db["name"], $rbx_db["user"], $rbx_db["pass"]);  
	# raportuj wszystkie błędy z AdoDB
	$this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
	# raportuj wszysrkie błedy z php 
	error_reporting(E_ALL);   
 
  }  
 
  /**
   * Ustawia wartości domyślne dla pól prywatnych klasy
   * 
   * @abstract 
   *
   */
   abstract public function setDefault();
   
  /**
   * Zwróc obiekt połączenia z bazą
   *
   * @return array Tablica z identyfiaktorem połączenia z bazą danych
   * @access public
   */	 
  public function getDB(){
	return $this->db;	
  }
 
  /**
   * Zwraca rezultat zapytania
   *
   * @return array Tablica zawierająca rezultat zapytania
   * @access public
   */
  public function getResult(){
	return $this->result;	
  }
 
  /**
   * Ustaw zapytanie sql
   *
   * @param string $sql Zapytanie SQL
   * @access public   
   */
  public function setSql($sql) {
	$this->sql = $sql;
  }
 
 
  /**
   * Zwróć treść zapytania
   *   
   * @return string $sql Zapytanie SQL
   */
  public function getSql() {
	return $this->sql;
  }
 
  /**
   * Zwróć wyjątek jeśli rezultat zapytania jest pusty
   * 
   * @return true jeśli wynik zapytania jest poprawny
   * @access public
   */
  public function checkResult() {
	if ($this->result) {		 
	  return true;
	}
	else {		 
	  return false;
	}
  }   
 
  /**
   * Wywołanie wszytkich metod związanych z wykonaniem zapytanie w jednej funkcji
   * treść zapytania zostaje zapamiętana
   *
   * @param string $sql Zapytanie SQL
   * @access public
   * @return boolean
   */  
  public function doSQL($sql=""){	
 
	# gdy niepusty to zapisz zapytanie SQL	
	if (!empty($sql)) $this->setSql($sql);
 
	#wykonaj zapytanie i zapisz do wyników		   
	$stmt = $this->db->prepare($this->getSql());
//	print_r($stmt);
//	echo "<br>";
	$stmt->execute();
	$this->result = $stmt->fetch(PDO::FETCH_ASSOC);
//	echo "<br> print result: ";
//	print_r($this->result);
//	echo "<br>";
	$this->checkResult();
  }
 
}
?>
[PHP] pobierz, plaintext 

Czekam na uwagi

Zdrawim

Ten post edytował Aztech 16.03.2006, 20:11:23

[matid]

Co do ActiveRecord, to ja chcę u siebie zaimplementować bardziej dynamiczne rozwiązanie, odwzorowujące w czasie rzeczywistym stan bazy danych, więc np. utworzenie obiektu Post, który będzie odwzorowywał tablicę posts w bazie danych wyglądałoby tak:

[PHP] pobierz, plaintext 
<?php
class Post extends ActiveRecord {}
?>
[PHP] pobierz, plaintext 

Podobnie wygląda to w Ruby on Rails.

A co do sprawdzonych źródeł wzorców, m.in. Registry: PoEAA (Patterns of Enterprise Application Architecture). W polskim wydaniu opis wzorca Registry znajduje się na s. 438.

A co do mojej implementacji tego wzorca - u mnie jest to po prostu kontener, nie zawiera on metod tworzenia obiektów, jeśli one nie istnieją, a jedynie udostępnia globalny intefejs dostępu do przechowywanych obiektów. Brakuje mi jeszcze w moim rozwiązaniu implementacji wzorca IdentityMap, lub czegoś podobnego, co zapewni unikalność obiektów - chwilowo są to tylko nazwy wpisów w rejestrze.

Wygląda to mniej więcej tak:

[PHP] pobierz, plaintext 
<?php
 
	final class Registry extends Container {
		private static $Instance;
		private static function getInstance(){
			if( self::$Instance instanceof Registry ){
				return self::$Instance;
			}
			else {
				return self::$Instance = new Registry;
				self::$Instance->DataType = new String( 'Entry' );
			}
		}
		public static function getEntry( String $Name ){
			$Registry = self::getInstance();
			if( self::hasEntry( $Name )->isFalse() ){
				throw new ContainerException( 'Element ' . $Name->toString() . '	does not
				exist in ' . get_class( $Registry ) );
			}
			return $Registry->Elements[$Name->toString()];
 
		}
 
		public static function hasEntry( String $Name ){
			$Registry = self::getInstance();
			return new Boolean( isset( $Registry->Elements[$Name->toString()] )	);
		}
 
		public static function addEntry( String $Name, $Element ){
			$Registry = self::getInstance();
			return $Registry->Elements[$Name->toString()] = $Element;
		}
	}
 
?>
[PHP] pobierz, plaintext 

A tak wygląda klasa kontenera, którą Registry rozszerza.

[PHP] pobierz, plaintext 
<?php
 
	abstract class Container{
		protected $Elements = array();
		protected $ClassName;
		protected $DataType;
 
		function __construct(){
			$ClassName = new String( get_class( $this ) );
			$ClassName->replace( new String( '/Container$/s' ), new String() );
			$this->DataType = Inflector::singularize( $ClassName );
		}
 
		protected function getDataType(){
			return $this->DataType;
		}
 
		protected function hasElement( String $Name ){
			$DataType = $this->getDataType()->toString();
			return new Boolean( isset( $this->Elements[ $Name->toString() ] ) &&
			$this->Elements[ $Name->toString() ] instanceof
			$DataType );
		}
 
		protected function getElement( String $Name ){
			if( $this->hasElement($Name)->isFalse() ){
				throw new Exception( 'Element ' . $Name->toString() . ' does not
				exist in ' . get_class( $this ) );
			}
			return $this->Elements[$Name->toString()];
		}
 
		protected function addElement( String $Name, $Element ){
			$DataType = $this->getDataType()->toString();
			if( !$Element instanceof $DataType ){
				throw new Exception( 'Argument 1 passed to ' . get_class( $this
				) . '::add' . $this->getDataType()->toString() . '() must be an object of class ' .
				$DataType );
			}
			return $this->Elements[$Name->toString()] = $Element;
		}
 
		protected function removeElement( String $Name ){
			if( $this->hasElement( $Name )->isTrue() ){
				unset( $this->Elements[ $Name->toString() ] );
			}
		}
 
		public function getAll(){
			return $this->Elements;
		}
 
		public function removeAll(){
			$this->Elements = array();
		}
 
		function __call( $MethodName, $MethodParams ){
			$MethodName = new String( $MethodName );
 
			if( $MethodName->startsWith( new String('get') ) ||
				$MethodName->startsWith( new String('has') ) ||
				$MethodName->startsWith( new String('add') ) ||
				$MethodName->startsWith( new String('remove') ) ){
				$DataType = clone $MethodName;
				$DataType->replace( new String( '/^(get|has|add|remove)/s' ), new
				String() );
				$MethodName->replace( new String( '/' . $DataType->toString() .
				'$/' ), new String() );
				$MethodName->concat( new String( 'Element' ) );
				if( $DataType->equals( $this->getDataType() ) === true ){
					return call_user_func_array( array( &$this,
					$MethodName->toString() ), $MethodParams );
				}
				else {
					throw new Exception( 'Container type invalid' );
				}
			}
		}
	}
 
?>
[PHP] pobierz, plaintext