[php] MySQL class

[Verwijderd]

Ik maak altijd gebruik van de volgende mysql class als ik met PHP werk

PHP:

<?
/*
Gebruik van de class:

if(!@class_exists("MySQL") && @file_exists("mysql_class.php")) { 
   require_once("mysql_class.php");
} else {
   print "<p align=\"center\"><font color=\"red\"><b>
             Database class could not be found!
          </b></font></p>";
   exit();
}

$query = "SELECT * FROM table";
$sql   = new MySQL();
$sql->Connect();
$results = $sql->Select($query);
// Controleren of de query geen fout oplevert
if(!$sql->Query($query)):
   $numrows = sizeof($results);
   if($numrows>0):
      // Resultaten laten zien
      echo "Er zijn " . $numrows . " resultaten gevonden.";
      for($i=0; $i<$numrows; $i++):
         echo $results[$i]["field"] . "\n";
      endfor;
   else:
      // Er zijn geen resultaten
      $sql->ErrorHandling();
   endif;
else:
   // Er is een fout opgetreden bij het uitvoeren van de query
   $sql->ErrorHandling();
endif;
$sql->Close();
unset($sql)
*/

class MySQL {

      var $Server   = "";
      var $Database = "";
      var $Username = "";
      var $Password = "";
      var $Connection;

        Function Connect() {
                 $usr = $this->Username;
                 $pwd = $this->Password;
                 $srv = $this->Server;
                 $db  = $this->Database;

                 $Connection  = @mysql_connect($srv, $usr, $pwd);
                 if (!$Connection || !@mysql_select_db($db,$Connection)) { return false; } ;
                 $this->Connection = $Connection;
                 return true;
        }

        Function Close() {
                 $Connection = $this->Connection;
                 @mysql_close ($Connection);
        }

        Function ErrorHandling() {
                echo mysql_errno().": ".mysql_error();
        }

        Function Select($query) {
                 if(empty($query)) return false;
                 if(!eregi("^select",$query)) return false;
                 if(empty($this->Connection)) return false;
                 $Connection = $this->Connection;
                 $Results = @mysql_query($query,$Connection);
                 if ((!Results) or (empty($Results))) return false;
                 $c = 0;
                 $data = array();
                 while ($Row = @mysql_fetch_array($Results)) {
                         $data[$c]=$Row;
                         $c++;
                 }
                 return $data;
        }

        Function Insert($query) {
                 if(empty($query)) return false;
                 if(!eregi("^insert",$query)) return false;
                 if(empty($this->Connection)) return false;
                 $Connection = $this->Connection;
                 $Results = @mysql_query($query,$Connection);
                 if(!Results) return false;
                 $Results = @mysql_insert_id();
                 return $Results;
        }

        Function Update($query) {
                 if(empty($query)) return false;
                 if(!eregi("^update",$query)) return false;
                 if(empty($this->Connection)) return false;
                 $Connection = $this->Connection;
                 $Results = @mysql_query($query,$Connection);
                 if(!$Results) return false;
                 return true;
        }

        Function Del($query) {
                 if(empty($query)) return false;
                 if(!eregi("^delete",$query)) return false;
                 if(empty($this->Connection)) return false;
                 $Connection = $this->Connection;
                 $Results = @mysql_query($query,$Connection);
                 if(!$Results) return false;
                 return true;
        }

        Function Query($query) {
                 if(empty($query)) return false;
                 if(empty($this->Connection)) return false;
                 $Connection = $this->Connection;
                 $Results = mysql_query($query,$Connection);
                 if((!$Results) or (empty($Results))) return false;
                 return true;
        }
}
?>

Dit werkt altijd geheel naar wens.

Ik heb dit script trouwens ooit ergens gevonden bij www.phpclasses.org.

Maar wat ik me afvraag:
Hebben jullie wellicht aan- en/of opmerkingen over deze class of adviezen, tips of ideeën voor uitbreidingen of verbeteringen?

[Verwijderd]

tja ik gebruik nooit classes voor MySQL connectivity, behalve dan ODBC like classes die cross-database support mogenlijk maken. Maar gebruik gewoon raw mysql statements ... en btw dit ziet er eerlijk gezegt uit als een newbie class maar ok.

[Verwijderd]

Hoezo is dit een "newbie"-class en zijn die verboden dan?!
Daar gaat het totaal natuurlijk niet om ...

Het kan inderdaad allemaal veel netter en mooier natuurlijk.
Maar de tijd ontbreekt me de laatste tijd eerlijk gezegd.

Het is wel een idee om het te herschrijven natuurlijk

[djc]

Vind het ook niet echt nuttig. Doordat je UPDATEs, INSERTs en dergelijke fixeert lever je nogal in op flexibiliteit. Ik gebruik zelf ook een class om met MySQL te werken, maar dat is vooral om de database layer te abstraheren, zodat ik ook andere databases kan gebruiken, door alleen de classname aan te passen. Verder zijn het vrijwel dezelfde functies als de standaard mysql_*() functies, alleen dan minder, en een paar extra.

[ACM]

Kijk es naar de PEAR db-classes die meegeleverd worden met php.
Daar zitten nog wel wat leuke dingen bij lijkt me.

[^Mo^]

Verwijderd schreef op 28 augustus 2002 @ 23:26:
tja ik gebruik nooit classes voor MySQL connectivity, behalve dan ODBC like classes die cross-database support mogenlijk maken. Maar gebruik gewoon raw mysql statements ... en btw dit ziet er eerlijk gezegt uit als een newbie class maar ok.

Ik raad je aan dat wel te gaan doen. Stel je zou later je scripts moeten migreren naar een andere database, zeg MS SQL, dan zou je al die raw mysql statements moeten omzetten naar iets anders. Terwijl als je classes zou gebruiken, dan hoef je alleen maar je object declaratie te wijzigen (als de functie namen uiteraard hetzelfde zijn, wat ik zelf altijd wel zo maak).

[Rense Klinkenberg]

Wat is het nut van een database layer, waardoor je makkelijk een andere database kan gebruiken, als de queries die je uitvoert mysql-specifiek zijn. Er wordt bijvoorbeeld erg vak gebruik gemaakt van de md5() functie van mysql, maar die bestaat niet in postgresql bijv.

Verder bied mysql ook niet de mogelijkheid tot subselects (en dan heb ik het over de 'stable' versies), waardoor je dat dus moet emuleren in je script. Als je zo'n script zou porten naar postgresql zou je enorm veel performance verlies hebben.

Mijn conclusie na jaren php'en is eigenlijk dat een database layer wel handig is voor de onderhoudbaarheid van de scripts, maar dat het geen wondermiddel is om er voor te zorgen dat je snel naar een andere database kan overstappen.

Verdr wil ik nog even opmerken dat je, zoals AMC al zie, beter kan kijken naar PEAR DB: a unified API for accessing SQL-databases. De clases van het PEAR project worden nl. gemaakt door vaak erg ervaren programmeurs en verder heeft het PEAR project ook een ingebouwde error_handling die meer is dan alleen een false retourneren.

[Verwijderd]

PEAR DB is inderdaad een mogelijke optie. Een andere kandidaat is het ADODB gebeuren ( http://php.weblogs.com/adodb ) welke nog een aantal leuke en handige aanvullingen heeft (welke volgens puristen waarschijnlijk niet in een abstractielaag thuis horen maar die je ook niet hoeft te gebruiken, gewoon die klassen niet includen)
Zoals standaard een aantal html formulier, en tabel functies en klassen en sessiehandlers op basis van ADODB.
En tevens een klasse heeft welke ADODB compatible maakt met PEAR DB.
Het heet ADODB omdat de syntaxis van de API veel op ADO lijkt.
Tevens maakt postnuke gebruik van een (oudere) versie van ADODB. Ze hebben deze verkozen na een aantal van dit soort dingen getest te hebben. ADODB was volgens hun naast andere voordelen sneller dan PEAR DB. Maar de betrouwbaarheid van de testen die ze gedaan hebben weet ik niet.

[Verwijderd]

Manuzhai - Wat bedoel je met het inleveren van flexibiliteit?

[paulh]

ik zou de update en de insert een stuk makkelijker vinden als je een array met waardes daar naar toe zou kunnen sturen. Dan hoef je niet zelf dat insert of update statement op te bouwen.

[Verwijderd]

Lijkt me juist niet handig, omdat je dan niet de query voor je ziet als je aan het programmeren bent, bovendien kost het weer performance als je de query dynamisch opsteld in de functie.