¿No deberían las declaraciones preparadas ser mucho más rápidas?

Question

$s = explode (" ", microtime()); 
$s = $s[0]+$s[1]; 
$con = mysqli_connect ('localhost', 'test', 'pass', 'db') or die('Err'); 

for ($i=0; $i<1000; $i++) { 

    $stmt = $con -> prepare(" SELECT MAX(id) AS max_id , MIN(id) AS min_id FROM tb "); 
    $stmt -> execute(); 
    $stmt->bind_result($M,$m); 
    $stmt->free_result(); 
    $rand = mt_rand($m , $M).'<br/>'; 

    $res = $con -> prepare(" SELECT * FROM tb WHERE id >= ? LIMIT 0,1 "); 
    $res -> bind_param("s", $rand); 
    $res -> execute(); 
    $res->free_result(); 
} 

$e = explode (" ", microtime()); 
$e = $e[0]+$e[1]; 
echo number_format($e-$s, 4, '.', ''); 

// and: 

$link = mysql_connect ("localhost", "test", "pass") or die(); 
mysql_select_db ("db") or die ("Unable to select database".mysql_error()); 

for ($i=0; $i<1000; $i++) { 
    $range_result = mysql_query(" SELECT MAX(`id`) AS max_id , MIN(`id`) AS min_id FROM tb "); 
    $range_row = mysql_fetch_object($range_result); 
    $random = mt_rand($range_row->min_id , $range_row->max_id); 
    $result = mysql_query(" SELECT * FROM tb WHERE id >= $random LIMIT 0,1 "); 
} 

declaraciones defenitly preparados son mucho más seguras sino también en todas partes se dice que son mucho más rápidos pero en mi prueba en el código anterior tengo: - 2,45 seg para comandos preparados - 5.05 seg para la segunda ejemplo

¿Qué crees que estoy haciendo mal? ¿Debo usar la segunda solución o debo tratar de optimizar la preparación?

Answer 1

Lo que está haciendo mal es que está preparando el enunciado mil veces y solo ejecuta cada enunciado preparado una vez. Debe prepararlo una vez y ejecutarlo mil veces.

Answer 2

No es beneficioso preparar una instrucción dentro de un ciclo para una sola ejecución. Solo estás agregando sobrecarga. Use declaraciones preparadas para consultas que ejecute repetidamente, generalmente con diferentes parámetros.

Answer 3

Además de las respuestas anteriores ...

veo que está utilizando MySQL y por debajo es el enlace desde allí como a las declaraciones preparadas: http://dev.mysql.com/tech-resources/articles/4.1/prepared-statements.html

Un extracto de allí:

El aumento en el rendimiento en las declaraciones preparadas puede provenir de algunas características diferentes. En primer lugar, es necesario analizar solo la consulta una sola vez. Cuando inicialmente prepara la declaración, MySQL analizará la declaración para verificar la sintaxis y configurar la consulta que se ejecutará. Luego, si ejecuta la consulta muchas veces, ya no tendrá esa sobrecarga. Esta pre-análisis puede conducir a un aumento de la velocidad si es necesario ejecutar la misma consulta muchas veces

Answer 4

@silversy -

fundamentos Loop 101 (o llanura de codificación 101): código de lazo invariante movimiento de los bucles . ¿Por qué prepararías la declaración en el bucle cuando no toma parámetros que dependen del bucle en sí?

Por supuesto que va a chupar gónadas si utiliza comandos preparados si se les prepara con cada iteración del bucle. La sobrecarga que observa está en la declaración que se prepara inicialmente en lugar de en su ejecución.

Haga de nuevo el código de la siguiente manera, y volver a intentarlo de nuevo:

$stmt = $con -> prepare(" SELECT MAX(id) AS max_id , MIN(id) AS min_id FROM tb "); 
$res = $con -> prepare(" SELECT * FROM tb WHERE id >= ? LIMIT 0,1 "); 

for ($i=0; $i<1000; $i++) { 

    $stmt -> execute(); 
    $stmt->bind_result($M,$m); 
    $stmt->free_result(); 
    $rand = mt_rand($m , $M).'<br/>'; 

    $res -> bind_param("s", $rand); 
    $res -> execute(); 
    $res->free_result(); 
} 

---

---

La advertencia aquí, sin embargo, es que la diferencia entre una declaración preparada y uno no preparados se hace despreciable como el tiempo de cálculo para ejecutar la consulta y recuperar los datos se hace grande.

Sólo para tirar algunos números ficticios de mi @@@ por el bien de la ilustración:

decir que la consulta en sí y el ir a buscar los datos de la toma 0.01sec (llamamos a esto). Además, se imagina que la construcción y la ejecución del código detrás de una declaración preparada toma 0.01sec (X) y para la 0.05seg consulta sin preparación o 5 * 0,01 seg (Y = 5 * X).La ración entre el código preparado y sin preparación sería:

(A + Y)/(A + X) = 0.06sec/0.02sec = 3 -> unprepared execution is three times slower 

Y vamos a suponer que por otra consulta, el tiempo de ir a buscar (debido al volumen de datos o rendimiento de la red) es 10seg (1000 * 0.01sec). Entonces la relación cambia

(A + Y)/(A + X) = 10.05sec/10.01sec ~=~ 1.004 

Son casi indistinguibles. Lo que estoy tratando de decir es que sí, las declaraciones preparadas son más rápidas (y que debe usarlas), PERO la prueba que está implementando no es necesariamente una buena forma de averiguarlo o de evaluar su valor. Debes tener en cuenta otros factores para medir realmente el rendimiento que estás exprimiendo.