Ris/ros til egen udviklet mysql class/lib

Som jeg skrev, den gang da du begyndte:
interfaces beskriver den generelle struktur...

Med din kode for man denne struktur:

class MySQLOldImplementation implements MySQLInterface
class MySQLiImplementation implements MySQLiInterface
class SqlLiteImplementation implements SqlLiteInterface

Bedre struktur er:

class MySQLOldImplementation implements DatabaseInterface
class MySQLiImplementation implements DatabaseInterface
class SqlLiteImplementation implements DatabaseInterface

Dertil er din factory class også lidt mærkelig, men den kan gå an. Men ville nok omskrive den til at kunne supportere flg.:

Database::factory('mysql',$host,$user,$pass,$database);

Tilslut, der er ingen grund til at lade databaseforbindelsen om at styre kontrollen af HTML eller ej. Det vil i stort set alle tilfælde være noget som håndteres et andet sted.

Det med interface er selvfølgelig logisk nok når du siger det (det var nemlig meningen til en generelt brug), jeg ved ikke lige hvad jeg har tænkt da jeg så gav den navnet (Hvis jeg tænkte).

Ja factory klassen er lidt underlig. Jeg ville egentlig bare have haft en klasse med kun en konstruktør, men jeg kunne bare ikke få den til at returnere det object, men det er noget der skal arbejdes på.

Det med min factory class kan jeg godt følge dig i, men er lidt i tvivl om hvordan jeg skal implementere det, men jeg går ud fra det kunne gøres sådan:

 class database
 {
     private $class;
 
     public funtion factory($type, $db_host, $db_user, $db_pass, $db_data)
     {
         if($type == 'mysql')
         {
             include('class.mysql.php');
             $class = new MySQLOldImplementation($db_host,$db_user,$db_pass,$db_data);
         }
         
         return $class;
     }
 }

du mangler da foldsvis mange ting.

du kan jo se php implementeringen af mysql, blandt de vigtigste af dem du mangler er nok
mysql_insert_id
mysql_error
mysql_errno


Et forslag som jeg selv bruger er at i stedet for at returnere resultatet så returner en iterator klasse med resultatet:

så man kan skrive f.eks
$results=$mysql->query();
foreach($results as $row){
}


Et andet forslag er at fjerne strippe argumentet fra dit query, hvis du insistere på at have det kan du bare lave en member variable, grunden til dette er at du så ikke behøver at lave et array med input men i stedet kan iterer over de sendte argumenter.


Et tredje forslag er at lave gøre så interfacet har alle functionerne, så klasser der implementer interfaset kun skal implementer dem, men tilgengæld også ved at de kun kan blive tilgået gennem function defineret i interfacet.

f.eks har du fetchRow men den er ikke i interfacet så hvis du skiftede klassen ud med en anden klasse hvor den hed getRow skulle du til at om kode alle steder du havde skrevet fetchRow.

Jeg ved skam godt jeg manger nogle ting endnu, men jeg synes også det er rart at få lidt kritik undervejs så jeg ikke står bagefter og skal ændre en hel masse.

 <?php
     class Database
     {
         /**
          * @param string $adapter
          * @param string $host
          * @param string $user
          * @param string $pass
          * @param string $name
          * 
          * @return Database_Adapter_Abstract
          */
         static public function factory($adapter,$host,$user,$pass,$name) {
             $adapter_name = 'Database_'.$adapter;
             return new $adapter_name($host,$user,$pass,$name);
         }
     }
     
     class Database_MySQL extends Database_Adapter_Abstract
     {
         protected function connect() {
             mysql_connect($this->host,$this->username,$this->password);
             mysql_select_db($this->database);
         }
         
         protected function _query($sql,$binds) {
             /** ... **/
         }
     }
     
     class Database_Adapter_Abstract
     {
         protected $host, $username, $password, $database;
         
         function __construct($host,$user,$pass,$name) {
             $this->host = $host;
             $this->username = $user;
             $this->password = $pass;
             $this->database = $name;
             
             $this->connect();
         }
         
         public function query($sql,$binds) {
             return $this->_query($sql,$binds);
         }
     }
     
     $db = Database::factory('MySQL','localhost','root','','test');
     $db->query($sql,array());
 ?>

Dette ligner en smule det setup jeg bruger i mit eget library. Det sparer dig for et par ting.
Og hvis man så skriver en passende sql statement handler, så kan man lave queries vha. metode navne frem for at skulle skrive hele SQLen selv. Det har den fordel at man ikke skal ud og omskrive en masse sql, hvis man en dag flytter database.

Vil det ikke så være en fordel at lave klassen Database_Adapter_Abstract til en abstract klasse? Kan godt se at det letter den del hvor man opretter forbindelsen.

Jo da... det gik lidt stærkt da jeg skrev det.

Jeg kan se jeg stadigvæk har brug for en masse erfaring Men det er bare om at klø på. Jeg siger tak.

Jeg er stadigvæk interesseret i at høre fra andre.

Jeg kørt lidt videre på dit kodeeksempel, men så har jeg lidt mere kontrol.

 interface DatabaseInterface
 {
     public function __construct($host, $user, $pass, $data);
     public function connect();
     public function query($sql, $input = array());
 }
 
 abstract class Database_adapter implements DatabaseInterface
 {
     protected $hostname, $username, $password, $database;
     
     function __construct($host, $user, $pass, $data) {
         $this->hostname = $host;
         $this->username = $user;
         $this->password = $pass;
         $this->database = $data;
         
         $this->connect();
     }
 }
 
 class Database_MySQL extends Database_adapter {
     private $link;
     
     function connect() {
         $this->link = mysql_connect($this->hostname, $this->username, $this->password);
         mysql_select_db($this->database, $this->link);
     }
     
     function query($sql, $input = array()) {
     }
 }