[php] database class probleempje

[Verwijderd]

Hi mensen,

ik ben me wat meer aan het verdiepen in de OO-logica van php5 maar ik kom er nog niet helemaal uit.
Ik ben nu bezig met een db-class (ik weet het, er zijn er al 1000-en... maar daar leer ik niks van :-) )

PHP:

<?php

class connection {

    var $mysqli;
    var $result;
    
    var $num_rows;
    var $affected_rows;
    var $insertID;

    public function __construct()
    {
        $this->mysqli = new mysqli(HOSTNAME, USERNAME, PASSWORD, DATABASE);
        
        if(mysqli_connect_errno())
        {
            trigger_error('Fout bij verbinding: '.$this->mysqli->error);
        }

    }

    /* 
     * Singleton functionality 
     */
    public static function getInstance()
    {

/*      static $instance;
        if (!isset($instance)) 
        {
             $c = __CLASS__;
             $instance = new $c;

        }
        return $instance;
*/      
        
        static $instance;
        return $instance ? $instance : $instance = new self();
        
        
    }


    public function query($query) 
    {
        $this->result = $this->mysqli->query($query);
        
        if (!empty($this->mysqli->error))
        {
            trigger_error('Fout in query: '.$this->mysqli->error);
        }
        else
        {
            // insert
            if (strpos($query, 'insert') !== false)
            {
                $this->insertID = $this->mysqli->insert_id;
            }
            // delete , update, replace
            elseif (strpos($query, 'delete') !== false || strpos($query, 'replace') !== false || strpos($query, 'update') !== false)
            {
                $this->affected_rows = $this->mysqli->affected_rows; 
            }
            // else
            else
            {
                $this->num_rows = $this->result->num_rows;
            }
            if (!empty($this->insertID)) { return ($this->insertID); }
        }   
    }

    public function getAllRecords($query, $result) 
    {
        if (!$result && !$this->result) {
            $this->query($query); 
        }
        
        if ($result == NULL) {
            $result = $this->result;
        }
        
        if ($result == NULL || $result->num_rows < 1 ) 
        {
            return NULL;
        }
        else
        {
            $output = array();
            while ( $row = $result->fetch_object() ) {
                $output[] = $row;
            }
            
            return $output;
        }

        
    }


}

?>

Nu krijg ik bij mijn eerste query gewoon netjes de juiste output maar bij de tweede query niet meer?

PHP:

$result = connection::getInstance()->getAllRecords($query);

Het gaat volgens mij ergens niet helemaal lekker met de getInstance maar ik kom er helaas zelf niet uit.

Wie kan mij op weg helpen?

thanks!

[AtleX]

Die static variable zou ik toch echt bovenaan bij je andere properties neerzetten. Nu is de scope beperkt tot die methode en dan werkt het inderdaad niet zo best.

Waarom geef je trouwens wel access modifiers op bij je methods, maar niet bij je properties? En als je toch met PHP5 bezig bent kan je net zo goed exceptions throwen in plaats van dat gare trigger_error().

[NetForce1]

probeer eens een class-member van je instance variabele te maken ipv een lokale variabele binnen je functie

[Verwijderd]

Ah dom... die static $instance heb ik nu bij de andere variabelen staan en het werkt netjes!

NetForce1 schreef op maandag 28 april 2008 @ 14:57:
probeer eens een class-member van je instance variabele te maken ipv een lokale variabele binnen je functie

Zou je dat iets meer willen uitleggen? Die begrijp ik niet helemaal..,

[NetForce1]

Ik bedoelde precies dat wat AtleX zegt, alleen zegt hij het dus iets duidelijker...
Variabelen op het niveau van je klasse worden ook wel class members genoemd of properties, instance variabele is hier een beetje ambigious, maar ik bedoelde dus de variabele 'instance'.

[ Voor 55% gewijzigd door NetForce1 op 28-04-2008 15:09 ]

[Morax]

Verwijderd schreef op maandag 28 april 2008 @ 15:04:
Ah dom... die static $instance heb ik nu bij de andere variabelen staan en het werkt netjes!


[...]


Zou je dat iets meer willen uitleggen? Die begrijp ik niet helemaal..,

Hij zei precies hetzelfde als AtleX, maar dan iets anders

[Verwijderd]

hehe... na 10x lezen snap zelfs ik 'm!

Thanks!

[Snake]

Zet ook eens access modifiers op u variablen!

[Andre-85]

Je implementeert het Singleton Pattern, door de constructor als private te declareren weet je zeker dat de getInstance() method gebruikt moet worden om aan een instantie van je class te komen.

[PrisonerOfPain]

AtleX schreef op maandag 28 april 2008 @ 14:56:
Die static variable zou ik toch echt bovenaan bij je andere properties neerzetten. Nu is de scope beperkt tot die methode en dan werkt het inderdaad niet zo best.

Het zou niet uit moeten maken of de static class of method scope heeft, beide gevallen zouden moeten resulteren in één instantie van de class.

Snake schreef op maandag 28 april 2008 @ 15:16:
Zet ook eens access modifiers op u variablen!

Die staan er al, var is synoniem voor public in PHP5, de enige reden om het te veranderen zou zijn dat 't een E_STRICT warning geeft in PHP versies voor 5.1.3.

Andre-85 schreef op maandag 28 april 2008 @ 16:11:
Je implementeert het Singleton Pattern, door de constructor als private te declareren weet je zeker dat de getInstance() method gebruikt moet worden om aan een instantie van je class te komen.

Dan kun je nog steeds $c = clone $x doen om een nieuwe instance te maken. Zowel __construct, __wakeup als __clone dienen private te zijn bij een PHP singleton.

[ Voor 46% gewijzigd door PrisonerOfPain op 28-04-2008 16:43 ]

[Verwijderd]

Ik wilde nog even terugkomen op mijn OO-leerproces.
De nodige tut's en een boek verder kom ik er ff niet op uit.

Ik heb onderstaande dbClass :

PHP:

class connection {

    static $instance;

    private $mysqli;
    private $result;
    
    public $num_rows;
    public $affected_rows;
    public $insertID;

    public function __construct()
    {
        $this->mysqli = new mysqli(HOSTNAME, USERNAME, PASSWORD, DATABASE);
        
        if(mysqli_connect_errno())
        {
            trigger_error('Fout bij verbinding: '.$this->mysqli->error);
        }

    }

    /* 
     * Singleton functionality 
     */
    public static function getInstance()
    {
        return $instance ? $instance : $instance = new self();
    }


    public function query($query) 
    {
        
        $this->result = $this->mysqli->query($query);
        
        if (!empty($this->mysqli->error))
        {
            trigger_error('Fout in query: '.$this->mysqli->error);
        }
        else
        {
            // insert
            if (strpos($query, 'insert') !== false)
            {
                $this->insertID = $this->mysqli->insert_id;
            }
            // delete , update, replace
            elseif (strpos($query, 'delete') !== false || strpos($query, 'replace') !== false || strpos($query, 'update') !== false)
            {
                $this->affected_rows = $this->mysqli->affected_rows; 
            }
            // else
            else
            {
                $this->num_rows = $this->result->num_rows;
            }
            if (!empty($this->insertID)) { return ($this->insertID); }
        }   
    }

    public function numRows($result = NULL)
    {
        if ($result == NULL) 
        {
            $result = $this->result;
        }
        return $result->num_rows;
    }

    public function getNextRecord($query, $result) 
    {
    
        if (!$result && !$this->result) {
            $this->query($query); 
        }
        
        if ($result == NULL) {
            $result = $this->result;
        }

        if ($result == NULL || $result->num_rows < 1 ) 
        {
            return NULL;
        }
        else
        {
            return $result->fetch_object();
        }
    }

    public function getAllRecords($query, $result) 
    {
        if (!$result && !$this->result) {
            $this->query($query); 
        }
        
        if ($result == NULL) {
            $result = $this->result;
        }
        
        if ($result == NULL || $result->num_rows < 1 ) 
        {
            return NULL;
        }
        else
        {
            $output = array();
            while ( $row = $result->fetch_object() ) {
                $output[] = $row;
            }
            
            return $output;
        }

        
    }


}

Als ik vervolgens de class aanspreek dan krijg ik bij optie 1 gewoon netjes het aantal numRows.
Maar bij optie 2 weet ik niet hoe ik die moet aanspreken
Iemand?

Is er uberhaubt een voordeel bij een van de 2 opties?

PHP:

        // OPTIE 1

    $connect = new connection();
    $connect->query($query);
    $numLines   = $connect->numRows();


       // OPTIE 2
    
    $query = " select * from $table where parent='$parentID' ";
    $resultset  = connection::getInstance()->getAllRecords($query);

Een aanvullende vraag op de Error-afhandeling in Classes in het algemeen waarop ik het antwoord ook nergens eenduidig vind:

Checken jullie in iedere method of de benodigde variabelen aanwezig zijn (indien niet een errormelding) of alleen in de cruciale methods?

Thanks!

[Facer]

Singleton is een ontwerppatroon om het aantal objecten van een bepaalde klasse tot één te beperken. Met dit ontwerppatroon is het mogelijk om de toegang tot bepaalde systeembronnen altijd via één object te laten gaan.

Bron: Wikipedia: Singleton (informatica)

Oftewel je krijgt maar 1 database verbinding naar je database. Er wordt dus niet een nieuwe verbinding geopend als je een nieuwe instancie van de connection class aanmaakt.

[ Voor 3% gewijzigd door Facer op 15-05-2008 19:25 . Reden: Taal verbeterd ]

[Verwijderd]

Dat begrijp ik, dat is nou net de funtie van een singleton

Maar kan je via optie dan niet meer de numrows method aanspreken?

[NetForce1]

Bij optie 2 krijg je een array terug waar alle resultaten in zitten, je zult dus de lengte van die array op moeten vragen om het aantal records te weten.
Waarom maak je trouwens bij optie 1 geen gebruik van de singletonfunctionaliteit? De idee van een singleton is dat je maar een instance hebt, je moet dus nu weer niet overal nieuwe instanties aan gaan maken. Als je met deze klasse singleton wilt laten zijn zou ik de constructor iig private maken, zodat getInstance de enige manier is om een instantie te verkrijgen.

[Verwijderd]

mm..

ik denk dat ik mijn vraag verkeerd formuleer:

wat is de correcte syntax om in optie 2 de numrow aan te spreken?

[NetForce1]

Euh, bedoel je dit?

PHP:

<?php
    $conn = connection::getInstance();
    $query = " select * from $table where parent='$parentID' ";
    $resultset = conn->getAllRecords($query);
    // of zonder alle records op te halen:
    $conn->query($query);
    $numRows = conn->numRows();

    // kan ook via de array uit getAllRecords:
    $numRows2 = $resultset.length //oid, weet niet precies hoe je de lengte van een array pakt in php
?>

[ Voor 8% gewijzigd door NetForce1 op 15-05-2008 21:47 ]

[Verwijderd]

quibuz: ik denk dat ik mijn vraag verkeerd formuleer: wat is de correcte syntax om in optie 2 de numrow aan te spreken?

Als ik goed begrijp wat je wilt (object-georiënteerd leren programmeren met PHP), dan formuleer je je vraag nog steeds verkeerd.

Waarom wil je optie 2 (of optie 1) gebruiken? Waarom kies je voor dit ontwerp? Toch niet om de syntax?

Begin bij het ontwerp; die syntax komt later wel.

Ik zal je op weg helpen aan de hand van je "optie 1":

PHP:

$connect = new connection();
$connect->query($query);
$numLines     = $connect->numRows();

• Wat gebeurt er als je geen verbinding kunt maken met de database?
• Waarom gebruik je namen als $connect en connection? Gaat het om de verbinding of om de database?
• Waarom vraag je de verbinding om het aantal resultaten? Een verbinding (of een database) heeft helemaal geen resultaten. (Resultaten horen bij een query.)

[ Voor 35% gewijzigd door Verwijderd op 15-05-2008 21:55 ]

[Verwijderd]

Eigenlijk wil je helemaal geen singleton gebruiken want het heeft niet echt voordeel en al zeker niet in php.

Handiger is het om je constructor van je connection class aan te passen zodat deze de benodigde connectie parameters accepteert (username, password, schema, etc). Je class is dan direct herbruikbaar voor meerdere databases. Alle classes die gebruik maken van de connection class hebben dit als constructor argument en je maakt simpelweg een keer een instantie van je connection class aan...

[sky-]

Je kan ook gewoon de mysqli class extenden. Dat is ook "OOP".
Je gebruikt wel singleton maar je __construct is public ? Die kan gewoon private. (of zie een reactie hierboven)

Voor de rest idd niet veel spannends, maar ach
Ik gebruik ipv fetch_object _altijd_ fetch_assoc. fetch_object maakt voor elke result een object aan, niet echt nodig lijkt me.

[ Voor 4% gewijzigd door sky- op 15-05-2008 21:50 ]

[curry684]

Verwijderd schreef op donderdag 15 mei 2008 @ 19:43:
Dat begrijp ik, dat is nou net de funtie van een singleton

Maar kan je via optie dan niet meer de numrows method aanspreken?

Als je begrijpt dat dat het nut is van singletons, waarom wil je dan iets waarvan er wel nul tot X zullen bestaan, zoals queries, beperken tot singleton logica? Je databaseverbinding mag in PHP of eender welke andere applicatie gerust singleton zijn, maar de database dient vervolgens per query een losse query class te genereren voor je. Die vervolgens wel netjes gescheiden per query een number of rows onthoudt. Extreem pseudocode:

code:

singleton class Database
{
  public function Query($sql) { return new Query($sql, $this); }
}

class Query
{
  public function __construct($sql, $db)
  {
    if(!($this->handle = mysql_query($sql, $db->handle)))
      throw new Exception('doh!');
  }

  public function Rows()
  {
    return mysql_num_rows($this->handle);
  }
}

etc.

[mithras]

Verwijderd schreef op donderdag 15 mei 2008 @ 21:48:
Eigenlijk wil je helemaal geen singleton gebruiken want het heeft niet echt voordeel en al zeker niet in php.

Handiger is het om je constructor van je connection class aan te passen zodat deze de benodigde connectie parameters accepteert (username, password, schema, etc). Je class is dan direct herbruikbaar voor meerdere databases. Alle classes die gebruik maken van de connection class hebben dit als constructor argument en je maakt simpelweg een keer een instantie van je connection class aan...

In een bepaalde casus kan ik me prima voorstellen dat je een database connectie als singleton wil zien. In mijn database class heb ik een static functie setMultiConnect() waarbij je kan schakelen naar een niet-singleton variant. Toch zie je in 9 v.d. 10 keer dat een singleton gewenst is en in verdere code makkelijk met je singleton pattern je database kan benaderen.

[Verwijderd]

mithras schreef op donderdag 15 mei 2008 @ 22:57:
In een bepaalde casus kan ik me prima voorstellen dat je een database connectie als singleton wil zien. In mijn database class heb ik een static functie setMultiConnect() waarbij je kan schakelen naar een niet-singleton variant. Toch zie je in 9 v.d. 10 keer dat een singleton gewenst is en in verdere code makkelijk met je singleton pattern je database kan benaderen.

Dat het makkelijk is kan ik niet anders dan met je eens zijn helaas is dat ook het enige voordeel van het pattern. Het singleton pattern is vooral een nadeel:
- het Decorator pattern toepassen wordt lastiger
- hergebruiken van de code in de singleton wordt lastiger
- verantwoordelijkheid op verkeerde plaats -> classes hoeven niet te weten welke concrete implementatie er wordt gebruikt

Maar ja, het blijft wel makkelijk hoor

[NetForce1]

Een mooie tussenweg zou een service locator kunnen zijn, dan is alleen je service locator nog maar singleton/static, en de rest kun je prachtig decoreren / hergebruiken / abstraheren.

[mithras]

Verwijderd schreef op donderdag 15 mei 2008 @ 23:30:
[...]
- verantwoordelijkheid op verkeerde plaats -> classes hoeven niet te weten welke concrete implementatie er wordt gebruikt

Daarvoor heb ik een soort van framework geschreven. Zelf leek het me makkelijk, maar ik ben benieuwd als ik het in de groep gooi:

PHP:

class qwik{
    
    private function __construct(){}
    
    static function get( $module ){
        //Exit when file not found
        if( !file_exists( 'modules/' . $module . '/qwik.' . $module . '.php') ){
            throw new Exception( 'Qwik: File for module ' . $module . ' not found!' );
            return false;
        }

        //Exit when class not found
        include_once( 'modules/' . $module . '/qwik.' . $module . '.php');
        if( !class_exists( $module ) ){
            throw new Exception( 'Qwik: Module class ' . $module . ' not found in file modules/' . $module . '/qwik.' .$module . '.php!' );
            return false;
        }

        //Exit when implemented interface not found
        $interfaces = class_implements( $module );
        if( $interfaces[0] != 'getDefault'){
            throw new Exception( 'Qwik: Module ' . $module . ' does not implements the interface qwikModule' );
            return false;
        }

        return call_user_func( array( 'Qwik' . $module , "getDefault" ) );
    }    
}

interface qwikModule{
    public static function getDefault(){}
}

Je kan dan, mits de module in het mapje staat, gewoon dit doen:

PHP:

$database = qwik::get( 'db' )->connect( $username, $password );
$template = qwik::get( 'template' );
$something = qwik::get( 'something' );

In het geval van de database kan je dus ook doen:

PHP:

qwik::get( 'db' )::setMultiConnect();
$database1 = qwik::get( 'db' );
$database2 = qwik::get( 'db' );

Dan hoef je niet te kijken tegen welke interface je in de klasse moet praten en laat de controle ervan als een soort factory pattern lekker buiten beschouwing.

[Verwijderd]

NetForce1 schreef op vrijdag 16 mei 2008 @ 08:44:
Een mooie tussenweg zou een service locator kunnen zijn, dan is alleen je service locator nog maar singleton/static, en de rest kun je prachtig decoreren / hergebruiken / abstraheren.

Precies en dan is Factory al voldoende. Waarin je dus in de factory het desnoods singleton implementeert. Dus:
$conn = ConnectionFactory::getConnection();

[daniëlpunt]

mithras schreef op vrijdag 16 mei 2008 @ 09:29:
[...]
Daarvoor heb ik een soort van framework geschreven. Zelf leek het me makkelijk, maar ik ben benieuwd als ik het in de groep gooi:

PHP:

class qwik{
    
    private function __construct(){}
    
    static function get( $module ){
        //Exit when file not found
        if( !file_exists( 'modules/' . $module . '/qwik.' . $module . '.php') ){
            throw new Exception( 'Qwik: File for module ' . $module . ' not found!' );
            return false;
        }

        //Exit when class not found
        include_once( 'modules/' . $module . '/qwik.' . $module . '.php');
        if( !class_exists( $module ) ){
            throw new Exception( 'Qwik: Module class ' . $module . ' not found in file modules/' . $module . '/qwik.' .$module . '.php!' );
            return false;
        }

        //Exit when implemented interface not found
        $interfaces = class_implements( $module );
        if( $interfaces[0] != 'getDefault'){
            throw new Exception( 'Qwik: Module ' . $module . ' does not implements the interface qwikModule' );
            return false;
        }

        return call_user_func( array( 'Qwik' . $module , "getDefault" ) );
    }    
}

interface qwikModule{
    public static function getDefault(){}
}

Je kan dan, mits de module in het mapje staat, gewoon dit doen:

PHP:

$database = qwik::get( 'db' )->connect( $username, $password );
$template = qwik::get( 'template' );
$something = qwik::get( 'something' );

In het geval van de database kan je dus ook doen:

PHP:

qwik::get( 'db' )::setMultiConnect();
$database1 = qwik::get( 'db' );
$database2 = qwik::get( 'db' );

Dan hoef je niet te kijken tegen welke interface je in de klasse moet praten en laat de controle ervan als een soort factory pattern lekker buiten beschouwing.

Iets returnen na het gooien van een exception heeft niet veel zin. En volgens mij mogen methods in interfaces geen body's hebben, dat zou een fatal error moeten op leveren.

[mithras]

Woeps, dat waren zaken die ik hier in had gezet. Het eigenlijke ontwerp staat bij mij thuis en kan ik niet bij. Ik heb het hier even kort uit mn hoofd getikt, maar je hebt gelijk

offtopic:
Het echte ontwerp is ook iets beter