PDO :: fetchAll so với PDO :: tìm nạp trong vòng lặp

Question

Chỉ là một câu hỏi nhanh.

Có sự khác biệt về hiệu suất nào giữa việc sử dụng PDO :: fetchAll() và PDO :: fetch() trong một vòng lặp (đối với các tập kết quả lớn) không?

Tôi đang tìm nạp các đối tượng của lớp do người dùng xác định, nếu điều đó tạo ra bất kỳ sự khác biệt nào.

Giả định ban đầu chưa được học của tôi là fetchAll có thể nhanh hơn vì PDO có thể thực hiện nhiều thao tác trong một câu lệnh trong khi mysql_query chỉ có thể thực hiện một câu lệnh. Tuy nhiên tôi có ít kiến ​​thức về các hoạt động bên trong của PDO và tài liệu không nói bất cứ điều gì về điều này, và có hay không fetchAll() chỉ đơn giản là một vòng lặp PHP được bán vào một mảng.

Bất kỳ trợ giúp nào?

Answer 1

Ít điểm chuẩn với 200 nghìn bản ghi ngẫu nhiên. Theo dự kiến, phương thức fetchAll nhanh hơn nhưng yêu cầu nhiều bộ nhớ hơn.

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

Mã benchmark được sử dụng:

<?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

Một điều về PHP mà tôi thấy là đúng là hầu hết luôn là là một hàm bạn thực hiện chính mình sẽ hầu như luôn chậm hơn so với PHP tương đương. Điều này là do khi một cái gì đó được thực hiện trong PHP, nó không có tất cả các tối ưu hóa thời gian biên dịch mà C có (được viết bằng PHP) và có phí cao trong các cuộc gọi hàm PHP.

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()){} 

Sự khác biệt bộ nhớ nên trở thành neglijable

Answer 4

Như Mihai Stancu đã nói, hầu như không có sự khác biệt bộ nhớ mặc dù fetchAll beats fetch + while.

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

tôi có kết quả trên với chạy trong khi một cách chính xác:

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

Vì vậy, các fetchAll tiêu thụ ít bộ nhớ, nhưng lấy + khi là nhanh hơn! :)

Answer 5

Tôi biết đây là chủ đề cũ, nhưng tôi chạy ngang qua câu hỏi này có cùng một câu hỏi. Sau khi chạy cái “điểm chuẩn” đơn giản của riêng tôi và đọc những gì người khác viết ở đây tôi đi đến kết luận rằng đây không phải là khoa học chính xác và trong khi người ta nên cố gắng viết chất lượng, mã sáng, không có điểm lãng phí quá nhiều thời gian khi bắt đầu của dự án.

Đề xuất của tôi là: Thu thập dữ liệu bằng cách chạy mã (trong bản beta?) Trong một thời gian và sau đó bắt đầu tối ưu hóa.

Trong điểm chuẩn đơn giản của tôi (chỉ thử nghiệm thời gian thực hiện) tôi đã có kết quả khác nhau giữa 5% và 50% BOTH cách. Tôi chạy cả hai tùy chọn trong cùng một tập lệnh, nhưng khi tôi chạy tìm nạp + trong khi đầu tiên nó đã nhanh hơn fetchall và ngược lại. (Tôi biết tôi nên chạy chúng đơn và vài trăm lần lấy trung bình và trung bình và sau đó so sánh, nhưng - như tôi đã nói lúc đầu - tôi kết luận rằng trong trường hợp của tôi còn quá sớm để bắt đầu làm như vậy.)

Answer 6

Nhưng chắc chắn nếu bạn đang lưu trữ dữ liệu đã tìm nạp trong một mảng, mức sử dụng bộ nhớ sẽ bằng nhau?

<?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

tất cả các điểm chuẩn ở trên đo lường "dấu chân bộ nhớ" thực sự không chính xác vì lý do rất đơn giản.

PDO theo mặc định không tải tất cả mọi thứ vào bộ nhớ và nó không quan tâm nếu bạn sử dụng tìm nạp hoặc fetchAll. Để thực sự có được lợi ích của việc truy vấn unbuffered bạn nên hướng dẫn PDO để sử dụng các truy vấn không có bộ đệm:

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

Trong trường hợp đó, bạn sẽ thấy sự khác biệt lớn trong bộ nhớ dấu chân của kịch bản