Ich habe zwei Tabellen, die so aufgebaut sind:
--------------------
fotos:
id, url, user

users:
id, name
--------------------
Ich möchte jetzt Fotos aus der ersten Tabelle ausgeben und dabei den Namen des Users anzeigen. Dieser ist jedoch nur in der zweiten Tabelle vorhanden. Welche der drei Möglichkeiten ist für diese Abfrage die schnellste und bei welcher ist die Datenbank-Belastung am geringsten? Danke für die Hilfe im Voraus!
--------------------
$a1 = "SELECT url, user FROM fotos";
$a2 = mysql_query($a1);
while ($a3 = mysql_fetch_object($a2)) {
$b1 = "SELECT name FROM com_users WHERE id = ".$a3->user;
$b2 = mysql_query($b1);
$b3 = mysql_fetch_object($b2);
// In $a3 sind jetzt die Foto-Daten und in $b3 die User-Daten
}
--------------------
$a1 = "SELECT url, name FROM fotos, users WHERE fotos.user = users.id";
$a2 = mysql_query($a1);
$a3 = mysql_fetch_object($a2);
// In $a3 sind jetzt alle Daten
--------------------
$a1 = "SELECT url, name FROM fotos JOIN users ON fotos.user = users.id";
$a2 = mysql_query($a1);
$a3 = mysql_fetch_object($a2);
// In $a3 sind jetzt alle Daten

pack alles in eine for schleife die 100000 durchgänge macht und stop die zeit. mach das mit allen 3 möglichkeiten.

ich tippe allerdings auf den join

OK, danke schonmal!

Also rein logisch müsste die erste Methode ja die langsamste sein. Denn da werden erst einmal die Foto-Daten ausgelesen, dann für jedes Foto noch einmal extra die User-Daten. Bei 100 Fotos sind das 101 Abfragen. Stimmt das so?

Bei den Methoden 2 und 3 gibt es bei 100 Fotos nur 1 Abfrage, oder? Dann müssten die letzten beiden Methoden ja eindeutig schneller sein...
Aber wo ist überhaupt der Unterschied zwischen den Methoden 2 und 3? Gibt es überhaupt welche bei Geschwindigkeit und Last für die Datenbank?

Jeder Kontextwechsel zwischen der Wirtssprache (hier: PHP) und dem Datenbank-Prozeß ist aufwendig.

Damit ist die erste Lösung sehr schlecht, weil sie bei 100 Fotos 101 Kontextwechsel erfordert.

Die Lösungen 2 und 3 sollten normalerweise von einem Optimierer als identisch erkannt und auf denselben Ablaufplan abgebildet werden.

Unter dem Gesichtspunkt der Lesbarkeit (und um bei komplexeren Abfragen zwischen Verknüpfungen und eigentlichen Where-Kriterien zu unterscheiden) ziehe ich es allerdings vor, grundsätzlich Joins zu verwenden und die Komma-Kombination auf jene Fälle zu beschränken, in denen man tatsächlich jede Zeile der ersten Tabelle mit jeder Zeile der zweiten Tabelle kombinieren möchte.

Bei komplexeren Abfragen werden üblicherweise erst die Where-Bedingungen ausgewertet, um die Einzeltabellen möglichst zu verkleinern. Erst auf die kleinen Ergebnisse wird Join angewandt.

Super, danke. Jetzt weiß ich schonmal, dass die letzten beiden Methoden besser sind. Ich habe jetzt mein komplettes System auf die Joins umgestelt.
Ich hatte auch mal was von Left- und Right-Joins gelesen. Was ist das denn dann genau? Die Dokumentation von MySQL dazu hab ich nicht verstanden.

OK, wie soll das denn genau aussehen in der Abfrage? Kannst du bitte mal ein Beispiel schreiben?

Das machst nicht Du, sondern das macht normalerweise der Optimierer innerhalb der Datenbank-Software.

Stell dir vor, Du kombinierst zwei Tabellen mit jeweils zehntausend Zeilen. Dann wäre es unsinnig, zunächst alle Zeilen miteinander zu kombinieren und dann über die Where-Bedingungen die meisten wieder rauszuschmeißen.

Stattdessen sucht der Optimierer erst nach jenen Where-Bedingungen, die über Konstanten laufen. Damit verkleinern sich die Tabellen, die anschließend gejoint werden.

Achso
Danke, jetzt habe ich mein Script - denke ich - gut optimiert. Das mit den JOINS ist ja auch ganz einfach.