✔ MySQL-Daten auslesen mit OOP

[Koehdaniel]

Hallo allerseits

Ich habe vor 2 Wochen mit der Objektorientierten Programmierung angefangen,
und wollte nun meine SQL-Daten damit auslesen.

Ohne OOP würde ich das so machen:

$code = mysql_query("select * from example where Name='Test';");
while($zeile = mysql_fetch_array($code))
{
	$ID = $zeile["ID"];
	$Name = $zeile["Name"];
}

Mein Ansatz mit OOP:

class sql{
	static $sql;
	
	function sql_code($code){
		$this->sql = $code;
	}
	function sql_auslesen($row){
		$code = mysql_query($this->sql);
		while($zeile = mysql_fetch_array($code))
		{
			return $zeile[$row];
		}
	}
}

$sql = new sql;
$sql->sql_code("select * from example where Name='Test';");
$ID = $sql->sql_auslesen("ID");
$Name = $sql->sql_auslesen("Name");

Allerdings wird bei meiner OOP-Variante ja jedes mal eine neue While-Schleife ausgeführt.
Kann man das irgendwie umgehen?
Vielen Dank im Vorraus.
--
Mit freundlichen Grüßen
Daniel K.

 

[jannicars]

Einfach den Output der Schleife in eine globale Variable packen und dann könnte man mit einer neuen Funktion die einfach auslesen.
Halt fast genauso wie bei $sql.

 

[Koehdaniel]

Wie genau meinst du das?
So?

class sql{
    static $sql;
    public $werte;
    
    function sql_code($code){
        $this->sql = $code;
    }
    function sql_auslesen($row){
        $code = mysql_query($this->sql);
        while($zeile = mysql_fetch_array($code))
        {
            $werte = $werte . "|" . $zeile[$row];
        }
		$this->werte = explode("|", $this->werte);
    }
    function sql_werte($row){
        $arrnum = array_search($row, $this->werte);
		return $this->werte[$arrnum];
    }
}

Aber dann hab ich doch auch die ganzen schleifen...

...
[Ca. 10 Minuten später]
...

Juhuu!!
Es klappt ^^
Du hast mich auf ne Idee gebracht
Ich führ jetz ne while schleife in der while schleife aus, die -- ach guckt einfach selber ^^

class sql{
    static $sql;
    public $rows;
    public $werte;
    
    function sql_code($code){
        $this->sql = $code;
    }
    function sql_auslesen($rows){
		$this->rows = explode("|", $rows);
		$rows_num = count($this->rows);
		
        $code = mysql_query($this->sql);
        while($zeile = mysql_fetch_array($code))
        {
			$i = 0;
			while($i < $rows_num){
	            $this->werte = $this->werte . $zeile[$this->rows[$i]] . "|";
				$i++;
			}
        }
		$this->werte = explode("|", $this->werte);
    }
    function sql_werte($row){
        $arrnum = array_search($row, $this->rows);
		return $this->werte[$arrnum];
    }
}

$sql = new sql;
$sql->sql_code("select * from example where name='Test';");
$sql->sql_auslesen("ID|name");
$ID = $sql->sql_werte("ID");
$Name = $sql->sql_werte("name");

echo $ID . $Name;

Viiiiieelen Danke
--
MfG Daniel

 

[jannicars]

So ähnlich wie das 2.te meinte ich es.
Mit 2 Schleifen verkomplizierst du das doch nur unnötig.
Vielleicht kann ich dir morgen nochmal ein codebeispiel bringen, wie ich es genau meinte.

 

[Koehdaniel]

Das wäre sehr nett
Vielen Dank schonmal im Vorraus.

 

[saftmeister]

Kurze Zwischenfrage: Warum nimmst du nicht PDO wenn du es mit OOP machen willst?

 

[Koehdaniel]

hab grad mal gegooglet um zu gicken was das is...
Ich versteh nur Bahnhof

Die Klasse ist also schon standartmäßig bei PHP5 drinne,
muss also nur nen Objekt anlegen, und dann?

 

[jannicars]

Nutz doch einfach mysqli - ist MySQL nur halt oop.
Tutorial:
http://www.tutorials.de/content/1168-php-mysqli-query-absetzen.html

 

[saftmeister]

Du legst ein PDO-Objekt an und darüber kannst du dann so tolle Sachen machen wie Prepared Statements. Beispiel anhand deines Codes:

// Verbindung aufbauen
$db = new PDO('mysql:dbname=testdb;host=127.0.0.1', 'benutzername', 'passwort');
if(!$db) {
  die('Verbindung zur Datenbank fehlgeschlagen');
}
// Exceptions einschalten; sobald ein Fehler auftritt wird eine Exception geworfen
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

// Prepared Statement vorbereiten
$statement = $db->prepare('SELECT * FROM example WHERE Name = ?');

// Variable Werte ins Statement einfügen
$statement->bindValue(1, 'Test');

// Statement ausführen
$statement->execute();

// Resultate abholen
$result = $statement->fetchObject();

// Resultat anzeigen
echo $result->Name;
// Zu Debugging-Zwecken noch mal ein var_dump

var_dump($result);

Ist schon ein Unterschied, wenn man das über PDO macht, ich rate allerdings dazu, denn man weiß nie, warum es sich lohnt, es einzusetzen. Ich zähle mal ein paar Gründe auf:

- Übersichtlichkeit im Code (ist für mich persönlich das wichtigste)
- Einigermaßen Sicherheit, was SQL-Injections angeht (wegen Prepared Statements)
- Sehr flexibel, was das Backend angeht; Man kann relativ einfach die Datenbank austauschen (z.B. von MySQL zu PostgreSQL)
- Performance-Gewinne bei Statements innerhalb von Schleifen (wenn man mal mehrere Datensätzen abholen will)

Jede vernünftige Programmiersprache bietet heutzutage Prepared Statements an, und das ist auch gut so.

Wenn du zu den Punkten oder allgemein Fragen hast, kannst du sie gerne stellen. Wenn du dafür (noch) nicht bereit bist, kannst du meine Versuche, dich zu etwas professionelleren Code zu bewegen, ignorieren

 

[Koehdaniel]

// Resultate abholen
$result = $statement->fetchObject();

// Resultat anzeigen
echo $result->Name;

Aber wenn ich das richtig verstehe kann man hier doch nur 1 Zeile auslesen,
also wenn ich SELECT * FROM test WHERE Ort='Hannover' mache und es mehrer Benutzer
aus diesem Ort gibt, zeigt er mir doch nur einen an, oder?
Ich müsste dann doch ne while-schleife machen, oder?

Außerdem sieht mir persönlich mysqli auf den ersten Blick übersichtlicher aus..