PDO :: fetchAll vs. PDO :: fetch in einer Schleife

Question

Nur eine kurze Frage.

Gibt es Leistungsunterschiede zwischen der Verwendung von PDO :: fetchAll() und PDO :: fetch() in einer Schleife (für große Ergebnismengen)?

Ich hole in Objekte einer benutzerdefinierten Klasse, wenn das einen Unterschied macht.

Meine anfängliche ungebildete Annahme war, dass fetchAll möglicherweise schneller ist, weil PDO mehrere Operationen in einer Anweisung durchführen kann, während mysql_query nur eine ausführen kann. Allerdings habe ich wenig Ahnung von inneren Funktionen von PDO und die Dokumentation sagt nichts darüber, und ob fetchAll() einfach eine PHP-seitige Schleife ist, die in ein Array ausgegeben wird.

Irgendwelche Hilfe?

Answer 1

Kleiner Benchmark mit 200k zufälligen Datensätzen. Wie erwartet, ist die Methode fetchAll schneller, benötigt aber mehr Speicher.

Result : 
fetchAll : 0.35965991020203s, 100249408b 
fetch : 0.39197015762329s, 440b 

Der Benchmark-Code verwendet:

<?php 
// First benchmark : speed 
$dbh = new PDO('mysql:dbname=testage;dbhost=localhost', 'root', ''); 
$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 
$sql = 'SELECT * FROM test_table WHERE 1'; 
$stmt = $dbh->query($sql); 
$data = array(); 
$start_all = microtime(true); 
$data = $stmt->fetchAll(); 
$end_all = microtime(true); 

$stmt = $dbh->query($sql); 
$data = array(); 
$start_one = microtime(true); 
while($data = $stmt->fetch()){} 
$end_one = microtime(true); 

// Second benchmark : memory usage 
$stmt = $dbh->query($sql); 
$data = array(); 
$memory_start_all = memory_get_usage(); 
$data = $stmt->fetchAll(); 
$memory_end_all = memory_get_usage(); 

$stmt = $dbh->query($sql); 
$data = array(); 
$memory_end_one = 0; 
$memory_start_one = memory_get_usage(); 
while($data = $stmt->fetch()){ 
    $memory_end_one = max($memory_end_one, memory_get_usage()); 
} 

echo 'Result : <br/> 
fetchAll : ' . ($end_all - $start_all) . 's, ' . ($memory_end_all - $memory_start_all) . 'b<br/> 
fetch : ' . ($end_one - $start_one) . 's, ' . ($memory_end_one - $memory_start_one) . 'b<br/>'; 

Answer 2

Eine Sache über PHP, die ich gefunden habe, um wahr zu sein fast immer ist, dass eine Funktion, die Sie selbst implementieren wird fast immer langsamer sein als das PHP-Äquivalent. Dies liegt daran, dass, wenn etwas in PHP implementiert ist, es nicht alle Kompilierzeit-Optimierungen, die C hat (in denen PHP geschrieben ist), aufweist und es einen hohen Aufwand an PHP-Funktionsaufrufen gibt.

Answer 3

@Arkh

// $data in this case is an array of rows; 

$data = $stmt->fetchAll(); 


// $data in this case is just one row after each loop; 

while($data = $stmt->fetch()){} 


// Try using 

$i = 0; 

while($data[$i++] = $stmt->fetch()){} 

Die Speicher Differenz neglijable werden sollte

Answer 4

Als Mihai Stancu zu sagen war, ist es fast keinen Unterschied Speicher obwohl fetchAll fetch + while schlägt.

Result : 
fetchAll : 0.160676956177s, 118539304b 
fetch : 0.121752023697s, 118544392b 

bekam ich die Ergebnisse oben, während korrekt ausgeführt wird:

$i = 0; 
while($data[$i++] = $stmt->fetch()){ 
    // 
} 

So ist die fetchAll weniger Speicher verbraucht, sondern holen + während schneller! :)

Answer 5

Ich weiß, das ist ein altes Thema, aber ich laufe über diese mit der gleichen Frage. Nachdem ich meinen eigenen einfachen "Benchmark" ausgeführt und gelesen habe, was andere hier geschrieben haben, bin ich zu dem Schluss gekommen, dass dies keine exakte Wissenschaft ist und obwohl man sich bemühen sollte, den Qualitäts-, Licht-Code zu schreiben, hat es keinen Sinn, am Anfang zu viel Zeit zu verschwenden von dem Projekt.

Mein Vorschlag ist: Sammeln Sie Daten, die durch den Code ausgeführt wird für eine Weile und dann die Optimierung starten (in der Beta?).

In meinem einfachen Benchmark (nur getestete Ausführungszeit) habe ich Ergebnisse, die zwischen 5% und 50% BEIDE Wege variieren. Ich führe beide Optionen im selben Skript aus, aber wenn ich fetch + führe, war es früher schneller als fetchall und umgekehrt. (Ich weiß, ich hätte sie einfach laufen lassen und ein paar hundert Mal den Median und den Mittelwert erhalten und dann vergleichen sollen, aber ich habe zu Beginn festgestellt, dass es in meinem Fall zu früh ist, damit anzufangen.)

Answer 6

Aber sicher, wenn Sie die abgerufenen Daten in einem Array speichern, wird die Speicherauslastung gleich sein?

<?php 
define('DB_HOST', 'localhost'); 
define('DB_USER', 'root'); 
define('DB_PASS', ''); 
// database to use 
define('DB', 'test'); 
try 
{ 
    $dbh = new \PDO('mysql:dbname='. DB .';host='. DB_HOST, DB_USER, DB_PASS); $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 
    $sql = 'SELECT * FROM users WHERE 1'; 
    $stmt = $dbh->query($sql); 
    $data = array(); 
    $start_all = microtime(true); 
    $data = $stmt->fetchAll(); 
    $end_all = microtime(true); 

    $stmt = $dbh->query($sql); 
    $data = array(); 
    $start_one = microtime(true); 
    while($data = $stmt->fetch()){} 
    $end_one = microtime(true); 

    // Second benchmark : memory usage 
    $stmt = $dbh->query($sql); 
    $data = array(); 
    $memory_start_all = memory_get_usage(); 
    $data = $stmt->fetchAll(); 
    $memory_end_all = memory_get_usage(); 

    $stmt = $dbh->query($sql); 
    $data = array(); 
    $memory_end_one = 0; 
    $memory_start_one = memory_get_usage(); 
    while($data[] = $stmt->fetch()){ 
    $memory_end_one = max($memory_end_one, memory_get_usage()); 
    } 

    echo 'Result : <br/> 
    fetchAll : ' . ($end_all - $start_all) . 's, ' . ($memory_end_all - $memory_start_all) . 'b<br/> 
    fetch : ' . ($end_one - $start_one) . 's, ' . ($memory_end_one - $memory_start_one) . 'b<br/>'; 
} 
catch (PDOException $e) 
{ 
    echo $e->getMessage(); 
} 
?> 

Result : 
fetchAll : 2.6941299438477E-5s, 9824b 
fetch : 1.5974044799805E-5s, 9824b 

Answer 7

Alle Benchmarks, über denen der "memory footprint" gemessen wird, sind aus dem einfachen Grund eigentlich falsch.

PDO lädt standardmäßig alle Dinge in den Speicher und es ist egal, ob Sie fetch oder fetchAll verwenden. Um wirklich Vorteile der ungepufferte Abfrage erhalten Sie PDO anweisen sollten ungepufferten Abfragen zu verwenden:

$db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);

In diesem Fall werden Sie großen Unterschied in dem Speicherbedarf des Skripts