[STUFF] MySQLConnector Klasse

[menty]

Hi folks,

hier noch mal ne schicke MySQL Klasse...

PHP-Code:

class MySQLConnector {

    var $resConnection;
    
    function MySQLConnector ($cfg) {
        
        $this->resConnection = mysql_connect($cfg["mysql"]["host"], $cfg["mysql"]["user"], $cfg["mysql"]["pass"])
           or die("Could not connect : " . mysql_error());
        mysql_select_db($cfg["mysql"]["db"], $this->resConnection)
            or die("Could not select database");
    }
    
    function Query($strQueryString)    {
        $result = mysql_query($strQueryString, $this->resConnection)
            or die("Could not query : " . mysql_error());
        $return = array();
        $i = 0;
        while($row = mysql_fetch_array($result, MYSQL_ASSOC)) {
            $return[$i] = $row;
            $i++;
        }
        return $return;
    }
    
    function NoneQuery($strNoneQueryString) {
        $result = mysql_query($strNoneQueryString, $this->resConnection)
            or die("Could not execute : " . mysql_error());
        return $result;
    }
    
    function Close() {
        mysql_close($this->resConnection);
    }
} 


dazu dann ne schöne config datei

PHP-Code:

$cfg = array();
$cfg["mysql"] = array();
$cfg["mysql"]["host"] = "localhost";
$cfg["mysql"]["db"] = "foo";
$cfg["mysql"]["user"] = "blub";
$cfg["mysql"]["pass"] = "bla"; 


und das ganze instanzieren mit

PHP-Code:

$MySQL = new MySQLConnector($cfg); 


Queries dann einfach mit

PHP-Code:

$query = "SELECT....";
$result = $MySQL->Query($query); 


erstellen, gibt n array zurück.

für alle non-querys dann die entsprechende methode anwenden.


grüße
markus

[rechtschreibfan]

hi, nur eine frage:
warum erfindest du das rad neu?

http://pear.php.net/package/DB
http://adodb.sourceforge.net/

der verzicht auf eigene klassen und die verwendung von bereits ordentlich getesteten und funktionierenden libraries erhöht die wiederverwendbarkeit deines codes in anderen projekten enorm.

[menty]

hi, nur eine frage:
warum erfindest du das rad neu?

http://pear.php.net/package/DB
http://adodb.sourceforge.net/

der verzicht auf eigene klassen und die verwendung von bereits ordentlich getesteten und funktionierenden libraries erhöht die wiederverwendbarkeit deines codes in anderen projekten enorm.

weil ich so besseres verständnis für die programmiersprache bekomme.
desweiteren hat diese klasse in verschiedenen projekten schon einsatz gefunden und bis lang ihren dienst noch nicht versagt.

alles was ich machen muss ist die config datei anpassen und die klasse includen.

somit ist das ding waserfest

grüße
markus

Ich hab mal einen Datenbankabstraktionslayer geschrieben, der mit MySQL, MS-SQL und PostgreSQL arbeiten kann.

class.Database.php

PHP-Code:

<?php

require_once("dbConfig.php");

/**
 * Database (PHP 5)
 * 
 * Datenbankabstraktionslayer, der eine Verbindung zu einem MySQL-, MS-SQL-
 * oder PostgreSQL-Server aufbauen kann und grundlegende
 * Datenbankzugriffsfunktionen bietet
 * 
 */
class Database {
    
    /** Resource-Link fuer die Datenbankverbindung */
    protected $connection;
    
    /**
     * Konstruktor, der eine Verbindung zum Datenbankserver herstellt und die
     * uebergebene Datenbank auswaehlt
     * 
     * @return    void
     */
    public function __construct() {
        global $dbConfig;
        
        $connectString = "\$this->connection = @".$dbConfig["type"]."_connect(";
        if ($dbConfig["type"] == "mysql" || $dbConfig["type"] == "mssql") {
            $connectString .= $dbConfig["host"].", ".$dbConfig["username"].", ".$dbConfig["password"];
        }
        if ($dbConfig["type"] == "pg") { 
            $connectString .= "\"host=".$dbConfig["host"]." ";
            $connectString .= "port=5432 ";
            $connectString .= "dbname=".$dbConfig["databaseName"]." ";
            $connectString .= "user=".$dbConfig["username"]." ";
            $connectString .= "password=".$dbConfig["password"]."\"";
        }
        $connectString .= ");";
        eval($connectString);
        
        if ($dbConfig["type"] == "mysql" || $dbConfig["type"] == "mssql") {
            $dbSelectionString = $dbConfig["type"]."_select_db(\"";
            $dbSelectionString .= $dbConfig["databaseName"]."\", \$this->connection";
            $dbSelectionString .= ");";
            eval($dbSelectionString);
        }
        
        if (!is_resource($this->connection)) {
            $exceptionString = "Can't connect to database using \"".$connectString."\".";
            throw new Exception($exceptionString);
        }
    }
    
    /**
     * Liest die kompletten Datensaetze, die der Bedingung entsprechen, aus der
     * angegebenen Table und gibt einen Array, der die Datensaetze als einzelne
     * Assoziativ-Arrays enthaelt, zurueck
     * 
     * @param    string    Table, aus der die Datensaetze gelesen werden sollen
     * @param    string    Bedingung fuer die Abfrage
     * @return    array    Array mit allen Datensaetzen
     */
    public function select($table, $condition = "") {
        global $dbConfig;
        
        $query = "SELECT * FROM ".$table;
        if ($condition != "") {
            $query .= " ".$condition.";";
        } else {
            $query .= ";";
        }
        
        $queryString = "\$result = @".$dbConfig["type"]."_query(";
        if ($dbConfig["type"] == "mysql" || $dbConfig["type"] == "mssql") {
            $queryString .= "\$query, \$this->connection";
        }
        if ($dbConfig["type"] == "pg") {
            $queryString .= "\$this->connection, \$query";
        }
        $queryString .= ");";
        eval($queryString);
        
        if (!isset($result) || !is_resource($result)) {
            $exceptionString = "Can't select data from ".$table." using \"".$queryString."\".";
            throw new Exception($exceptionString);
        }
        
        $ret = array();
        $loopString = "while (\$row = ".$dbConfig["type"]."_fetch_assoc(\$result)) { ";
        $loopString .= "array_push(\$ret, \$row); ";
        $loopString .= "}";
        eval($loopString);
        
        return $ret;
    }
    
    /**
     * Schreibt einen neuen Datensatz in die Datenbank und gibt zurueck, ob der
     * Datensatz eingefuegt werden konnte
     * 
     * @param    string        Table, in die der Datensatz geschrieben werden soll
     * @param    array        Assoziativ-Array, der den Datensatz enthaelt
     * @return    boolean        Gibt an, ob der Datensatz eingefuegt werden konnte
     */
    public function insert($table, $dataSet) {
        global $dbConfig;
        
        $fields = array_keys($dataSet);
        $values = array_values($dataSet);
        
        $insertData = array();
        foreach ($values as $val) {
            if (!is_numeric($val)) {
                $val = addslashes($val);
            }
            array_push($insertData, $val);
        }
        
        $query = "INSERT INTO ".$table." (";
        $query .= implode(", ", $fields);
        $query .= ") VALUES('";
        $query .= implode("', '", $values);
        $query .= "');";
        
        $queryString = "\$result = @".$dbConfig["type"]."_query(";
        if ($dbConfig["type"] == "mysql" || $dbConfig["type"] == "mssql") {
            $queryString .= "\$query, \$this->connection";
        }
        if ($dbConfig["type"] == "pg") {
            $queryString .= "\$this->connection, \$query";
        }
        $queryString .= ");";
        eval($queryString);
        
        if (!isset($result) || !is_bool($result)) {
            $exceptionString = "Can't insert data into ".$table." using \"".$queryString."\".";
            throw new Exception($exceptionString);
        }
        
        return $result;
    }
    
    /**
     * Aendert eine beliebige Anzahl von Daten in einem beliebigen Datensatz und
     * gibt zurueck, ob der Datensatz geaendert werden konnte
     * 
     * @param    string        Table, in die der Datensatz geschrieben werden soll
     * @param    array        Assoziativ-Array, der die Daten enthaelt
     * @param    array        Array mit den Bedingungen fuer die Abfrage
     * @return    boolean        Gibt an, ob die Daten geaendert werden konnten
     */
    public function update($table, $dataSet, $conditions) {
        global $dbConfig;
        
        $updates = array();
        foreach ($dataSet as $field => $value) {
            if (!is_numeric($value)) {
                $value = addslashes($value);
            }
            array_push($updates, $field." = '".$value."'");
        }
        
        $whereClause = array();
        foreach ($conditions as $field => $value) {
            if (!is_numeric($value)) {
                $value = addslashes($value);
            }
            array_push($whereClause, $field." = ".$value);
        }
        
        $query = "UPDATE ".$table." SET ";
        $query .= implode(", ", $updates);
        $query .= " WHERE ";
        $query .= implode(" AND ", $whereClause).";";
        
        $queryString = "\$result = ".$dbConfig["type"]."_query(";
        if ($dbConfig["type"] == "mysql" || $dbConfig["type"] == "mssql") {
            $queryString .= "\$query, \$this->connection";
        }
        if ($dbConfig["type"] == "pg") {
            $queryString .= "\$this->connection, \$query";
        }
        $queryString .= ");";
        eval($queryString);
        
        if (!isset($result) || !is_bool($result)) {
            $exceptionString = "Can't update data in ".$table." using \"".$queryString."\".";
            throw new Exception($exceptionString);
        }
        
        return $result;
    }
    
    /**
     * Loescht eine beliebige Anzahl von Datensaetzen und gibt zurueck, ob die
     * Datensaetze geloescht werden konnten
     * 
     * @param    string        Table, aus der Datensaetze geloescht werden sollen
     * @param    array        Array mit den Bedingungen fuer die Abfrage
     * @return    boolean        Gibt an, ob die Datensaetze geloescht werden konnten
     */
    public function delete($table, $conditions) {
        global $dbConfig;
        
        $whereClause = array();
        foreach ($conditions as $field => $value) {
            if (!is_numeric($value)) {
                $value = addslashes($value);
            }
            array_push($whereClause, $field." = ".$value);
        }
        
        $query = "DELETE FROM ".$table." WHERE ";
        $query .= implode(" AND ", $whereClause).";";
        
        $queryString = "\$result = ".$dbConfig["type"]."_query(";
        if ($dbConfig["type"] == "mysql" || $dbConfig["type"] == "mssql") {
            $queryString .= "\$query, \$this->connection";
        }
        if ($dbConfig["type"] == "pg") {
            $queryString .= "\$this->connection, \$query";
        }
        $queryString .= ");";
        eval($queryString);
        
        if (!isset($result) || !is_bool($result)) {
            $exceptionString = "Can't delete row in ".$table." using \"".$queryString."\".";
            throw new Exception($exceptionString);
        }
        
        return $result;
    }
    
    /**
     * Destruktor, der die Verbindung zum Datenbankserver schliesst
     * 
     * @return void
     */
    public function __destruct() {
        global $dbConfig;
        
        if (is_resource($this->connection)) {
            $closeString = "@".$dbConfig["type"]."_close(\$this->connection);";
            eval($closeString);
        }
    }
    
}

?>

dbConfig.php

PHP-Code:

<?php

/**
 * Konfigurationsdatei fuer die Klasse Database
 * 
 */

/**
 * Typ des Datenbankservers und Prefix fuer die datenbankspezifischen
 * Funktionen:
 * mysql = MySQL-Server
 * mssql = MS-SQL-Server
 * pg = PostgreSQL- Server
 */
$dbConfig["type"] = "mysql";

/** Hostname des Datenbankserver */
$dbConfig["host"] = "localhost";

/** Username fuer die Datenbankverbindung */
$dbConfig["username"] = "lars";

/** Passwort fuer die Datenbankverbindung */
$dbConfig["password"] = "lars";

/** Name der Datenbank */
$dbConfig["databaseName"] = "";

?>

Vielleicht kanns mal jemand brauchen.

Lars

[menty]

hmmm... du arbeitest dort in der klasse mit globals, meines wissens nach sollte das aus sicherheitsgründen vermieden werden.

du könntest statt dessen $dbConfig beim instanzieren der Klasse an den konstruktor übergeben, welcher sie als klasseneigenschaft den methoden zur verfügung stellt.

ansonsten sieht das gut aus

grüße
markus

hmmm... du arbeitest dort in der klasse mit globals, meines wissens nach sollte das aus sicherheitsgründen vermieden werden.

Wenn Du auf äußere Variablen innerhalb von Funktionen zugreifst, mußt Du diese zu Beginn nur mit global deklarieren. Siehe dazu: http://de.php.net/language.variables.scope

Soweit ich weiß, existiert da kein Sicherheitsproblem. Was Du meinst ist wahrscheinlich die register_globals-Geschichte. Das hat damit aber nichts zu tun.

Gruß,
Lars

[menty]

PHP-Code:

class Database {  
/** Resource-Link fuer die Datenbankverbindung */ 
protected $connection; 
var $cfg; 
/** 
 * Konstruktor, der eine Verbindung zum Datenbankserver herstellt und die 
 * uebergebene Datenbank auswaehlt 
 * 
 * @return****void 
 */ 
public function __construct($cfg) { 
        $this->cfg = $cfg;
        //..... 


meinte das so

dann brauchst du in der klasse nur auf $this->cfg verweisen...

Klar, das geht genau so gut. Wenn Du mit global arbeitest, kannst Du die Klasse einfach mit

PHP-Code:

$db = new Database(); 


instanzieren ohne noch den Array übergeben zu müssen. Vor allem musst Du so in Klassen, in denen Du auf die Database-Klasse zugreifst auch nur diese einbinden und nicht noch die Config.

Es reicht also ein

PHP-Code:

require_once("class.Database.php"); 


Bei Deiner Version mußt Du immer

PHP-Code:

require_once("class.Database.php");
require_once("dbConfig.php"); 


benutzen.

Ist aber letztlich Geschmackssache . Ich wollte nur drauf hinweisen, daß die Verwendung von global keine sicherheitsrelevanten Probleme bereitet.

Gruß,
Lars

[menty]

ok, da gebe ich dir recht

grüße
markus

[elias]

markus idee war schon richtig - globals sollten vermieden werden- und zwar
aus gründen der verkapselung, stabilität und sauberkeit.
da man auf globalen von überall aus zugreifen kann, wird es zu problemen
kommen wenn deine variable verändert wird. und eine variable namens
'dbConfig' könnte jeder zweite in seinem script haben.

die variablen immer als parameter zu übergeben ist da zwar deutlich
sauberer, aber teilweise auch sehr unübersichtlich und umständlich.
eine einfache lösung wäre zb eine klasse 'DB_MarkusConfig' zu erstellen
welche von 'Database' erbt und die nötigen variablen zur verfügung
stellt.