faster - MySQL vs MongoDB 1000 lecturas
mongodb vs sqlite (7)
He estado muy entusiasmado con MongoDb y lo he estado probando últimamente. Tuve una tabla llamada publicaciones en MySQL con alrededor de 20 millones de registros indexados solo en un campo llamado ''id''.
Quería comparar la velocidad con MongoDB y ejecuté una prueba que obtendría e imprimiría 15 registros al azar de nuestras enormes bases de datos. Hice la consulta unas mil veces para mysql y MongoDB y estoy sorprendido de que no noto mucha diferencia en la velocidad. Tal vez MongoDB es 1.1 veces más rápido. Eso es muy decepcionante. ¿Hay algo que estoy haciendo mal? Sé que mis pruebas no son perfectas pero MySQL está a la par con MongoDb cuando se trata de leer tareas intensivas.
Nota:
- Tengo dual core + (2 hilos) i7 cpu y 4GB ram
- Tengo 20 particiones en MySQL cada una de 1 millón de registros
Código de muestra utilizado para probar MongoDB
<?php
function microtime_float()
{
list($usec, $sec) = explode(" ", microtime());
return ((float)$usec + (float)$sec);
}
$time_taken = 0;
$tries = 100;
// connect
$time_start = microtime_float();
for($i=1;$i<=$tries;$i++)
{
$m = new Mongo();
$db = $m->swalif;
$cursor = $db->posts->find(array(''id'' => array(''$in'' => get_15_random_numbers())));
foreach ($cursor as $obj)
{
//echo $obj["thread_title"] . "<br><Br>";
}
}
$time_end = microtime_float();
$time_taken = $time_taken + ($time_end - $time_start);
echo $time_taken;
function get_15_random_numbers()
{
$numbers = array();
for($i=1;$i<=15;$i++)
{
$numbers[] = mt_rand(1, 20000000) ;
}
return $numbers;
}
?>
Código de muestra para probar MySQL
<?php
function microtime_float()
{
list($usec, $sec) = explode(" ", microtime());
return ((float)$usec + (float)$sec);
}
$BASE_PATH = "../src/";
include_once($BASE_PATH . "classes/forumdb.php");
$time_taken = 0;
$tries = 100;
$time_start = microtime_float();
for($i=1;$i<=$tries;$i++)
{
$db = new AQLDatabase();
$sql = "select * from posts_really_big where id in (".implode('','',get_15_random_numbers()).")";
$result = $db->executeSQL($sql);
while ($row = mysql_fetch_array($result) )
{
//echo $row["thread_title"] . "<br><Br>";
}
}
$time_end = microtime_float();
$time_taken = $time_taken + ($time_end - $time_start);
echo $time_taken;
function get_15_random_numbers()
{
$numbers = array();
for($i=1;$i<=15;$i++)
{
$numbers[] = mt_rand(1, 20000000);
}
return $numbers;
}
?>
¿Tiene concurrencia, es decir, usuarios simultáneos? Si solo ejecuta 1000 veces la consulta directa, con un solo subproceso, casi no habrá diferencia. Demasiado fácil para estos motores :)
PERO le sugiero encarecidamente que cree una sesión de prueba de carga real, lo que significa usar un inyector como JMeter con 10, 20 o 50 usuarios AL MISMO TIEMPO para que realmente pueda ver una diferencia (intente incrustar este código dentro de una página web JMeter podría consultar).
Acabo de hacerlo hoy en un solo servidor (y una colección / tabla simple) y los resultados son bastante interesantes y sorprendentes (MongoDb fue realmente más rápido en escritura y lectura, en comparación con el motor MyISAM y el motor InnoDb).
Esto realmente debería ser parte de su prueba: concurrencia y motor MySQL. Luego, las necesidades de diseño y aplicación de datos / esquemas son, por supuesto, requisitos enormes, más allá de los tiempos de respuesta. Avísame cuando obtengas resultados, ¡también necesito comentarios sobre esto!
Aquí hay una pequeña investigación que exploró RDBMS vs NoSQL usando MySQL vs Mongo, las conclusiones fueron en línea con la respuesta de @Sean Reilly. En resumen, el beneficio proviene del diseño, no de una diferencia de velocidad bruta. Conclusión en la página 35-36:
RDBMS vs NoSQL: Comparación de rendimiento y escalado
El proyecto probó, analizó y comparó el rendimiento y la escalabilidad de los dos tipos de bases de datos. Los experimentos realizados incluyeron diferentes números y tipos de consultas, algunas más complejas que otras, para analizar cómo se escalaron las bases de datos con una mayor carga. El factor más importante en este caso fue que el tipo de consulta utilizado como MongoDB podría manejar consultas más complejas más rápido debido principalmente a su esquema más simple al sacrificio de la duplicación de datos, lo que significa que una base de datos NoSQL puede contener grandes cantidades de duplicados de datos. Aunque se podría usar un esquema directamente migrado desde el RDBMS, esto eliminaría la ventaja de la representación de datos subyacentes de MongoDB de los subdocumentos que permitían el uso de menos consultas hacia la base de datos cuando se combinaban las tablas. A pesar de la mejora de rendimiento que MongoDB tuvo sobre MySQL en estas consultas complejas, cuando el punto de referencia modeló la consulta de MySQL de manera similar a la consulta compleja de MongoDB mediante el uso de SELECTs MySQL anidados obtuvo mejores resultados, aunque en un mayor número de conexiones los dos se comportaron de manera similar. El último tipo de consulta de referencia fue la consulta compleja que contenía dos UNIONES y una subconsulta que mostró la ventaja que MongoDB tiene sobre MySQL debido a su uso de subdocumentos. Esta ventaja viene con el costo de la duplicación de datos, lo que provoca un aumento en el tamaño de la base de datos. Si tales consultas son típicas en una aplicación, entonces es importante considerar las bases de datos NoSQL como alternativas teniendo en cuenta el costo de almacenamiento y el tamaño de la memoria resultante del mayor tamaño de la base de datos.
En un solo servidor, MongoDb no sería más rápido que mysql MyISAM en lectura y escritura, dado que los tamaños de la tabla / documento son pequeños de 1 GB a 20 GB.
MonoDB será más rápido en Reducción paralela en clústeres de varios nodos, donde Mysql NO puede escalar horizontalmente.
Fuente: https://github.com/webcaetano/mongo-mysql
10 filas
mysql insert: 1702ms
mysql select: 11ms
mongo insert: 47ms
mongo select: 12ms
100 filas
mysql insert: 8171ms
mysql select: 10ms
mongo insert: 167ms
mongo select: 60ms
1000 filas
mysql insert: 94813ms (1.58 minutes)
mysql select: 13ms
mongo insert: 1013ms
mongo select: 677ms
10.000 filas
mysql insert: 924695ms (15.41 minutes)
mysql select: 144ms
mongo insert: 9956ms (9.95 seconds)
mongo select: 4539ms (4.539 seconds)
MongoDB no es mágicamente más rápido. Si almacena los mismos datos, organizados básicamente de la misma manera, y accede a ellos exactamente de la misma manera, entonces realmente no debería esperar que sus resultados sean muy diferentes. Después de todo, tanto MySQL como MongoDB son GPL, por lo que si Mongo tuviera un código IO mágicamente mejor, entonces el equipo de MySQL podría incorporarlo en su base de código.
La gente está viendo el rendimiento de MongoDB en el mundo real en gran parte porque MongoDB le permite realizar consultas de una manera diferente que es más sensible a su carga de trabajo.
Por ejemplo, considere un diseño que conserva mucha información sobre una entidad complicada de una manera normalizada. Esto podría usar fácilmente docenas de tablas en MySQL (o cualquier db relacional) para almacenar los datos en forma normal, con muchos índices necesarios para asegurar la integridad relacional entre tablas.
Ahora considere el mismo diseño con un almacén de documentos. Si todas esas tablas relacionadas están subordinadas a la tabla principal (y con frecuencia lo están), entonces podría ser capaz de modelar los datos de tal manera que toda la entidad se almacene en un solo documento. En MongoDB puede almacenar esto como un solo documento, en una sola colección. Aquí es donde MongoDB comienza a permitir un rendimiento superior.
En MongoDB, para recuperar toda la entidad, debe realizar:
- Una búsqueda de índice en la colección (suponiendo que la entidad se recupera por ID)
- Recupere el contenido de una página de base de datos (el documento binario json real)
Así que una búsqueda de b-tree, y una página binaria de lectura. Log (n) + 1 IOs. Si los índices pueden residir completamente en la memoria, entonces 1 IO.
En MySQL con 20 tablas, tienes que realizar:
- Una búsqueda de índice en la tabla raíz (nuevamente, asumiendo que la entidad es recuperada por id)
- Con un índice agrupado, podemos suponer que los valores para la fila raíz están en el índice
- Más de 20 búsquedas de rango (esperemos en un índice) para el valor pk de la entidad
- Probablemente no sean índices agrupados, por lo que las mismas más de 20 búsquedas de datos una vez que averiguamos cuáles son las filas secundarias apropiadas.
Por lo tanto, el total de mysql, incluso suponiendo que todos los índices están en la memoria (lo cual es más difícil ya que hay 20 veces más) es de aproximadamente 20 búsquedas de rango.
Estas búsquedas de rango probablemente se componen de E / S aleatorias: las diferentes tablas definitivamente residirán en diferentes lugares en el disco, y es posible que diferentes filas en el mismo rango en la misma tabla para una entidad no sean contiguas (dependiendo de cómo haya sido la entidad). actualizado, etc).
Entonces, para este ejemplo, la cuenta final es aproximadamente 20 veces más IO con MySQL por acceso lógico, en comparación con MongoDB.
Así es como MongoDB puede mejorar el rendimiento en algunos casos de uso .
man ,,, la respuesta es que básicamente estás probando PHP y no una base de datos.
no se moleste en iterar los resultados, ya sea comentando la impresión o no. hay un pedazo de tiempo
foreach ($cursor as $obj)
{
//echo $obj["thread_title"] . "<br><Br>";
}
mientras que la otra parte es gastar robando un montón de números de rand.
function get_15_random_numbers()
{
$numbers = array();
for($i=1;$i<=15;$i++)
{
$numbers[] = mt_rand(1, 20000000) ;
}
return $numbers;
}
entonces hay una gran diferencia b / w implosión y en.
y finalmente lo que está pasando aquí. Parece que se crea una conexión cada vez, por lo tanto, se prueba el tiempo de conexión más el tiempo de consulta.
$m = new Mongo();
vs
$db = new AQLDatabase();
por lo tanto, su 101% más rápido podría llegar a ser 1000% más rápido para la consulta subyacente despojada de jazz.
urghhh
https://github.com/reoxey/benchmark
punto de referencia
comparación de velocidad de MySQL y MongoDB en GOLANG1.6 y PHP5
Sistema utilizado para la evaluación comparativa: DELL cpu i5 4ta generación 1.70Ghz * 4 ram 4GB GPU ram 2GB
Comparación de velocidad de RDBMS frente a NoSQL para INSERTAR, SELECCIONAR, ACTUALIZAR, BORRAR y ejecutar un número diferente de filas 10,100,1000,10000,100000,1000000
El idioma utilizado para ejecutar es: PHP5 y el lenguaje más rápido de Google GO 1.6
________________________________________________
GOLANG with MySQL (engine = MyISAM)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
INSERT
------------------------------------------------
num of rows time taken
------------------------------------------------
10 1.195444ms
100 6.075053ms
1000 47.439699ms
10000 483.999809ms
100000 4.707089053s
1000000 49.067407174s
SELECT
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 872.709µs
SELECT & DISPLAY
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 20.717354746s
UPDATE
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 2.309209968s
100000 257.411502ms
10000 26.73954ms
1000 3.483926ms
100 915.17µs
10 650.166µs
DELETE
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 6.065949ms
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
________________________________________________
GOLANG with MongoDB
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
INSERT
------------------------------------------------
num of rows time taken
------------------------------------------------
10 2.067094ms
100 8.841597ms
1000 106.491732ms
10000 998.225023ms
100000 8.98172825s
1000000 1m 29.63203158s
SELECT
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 5.251337439s
FIND & DISPLAY (with index declared)
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 21.540603252s
UPDATE
------------------------------------------------
num of rows time taken
------------------------------------------------
1 1.330954ms
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
________________________________________________
PHP5 with MySQL (engine = MyISAM)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
INSERT
------------------------------------------------
num of rows time taken
------------------------------------------------
10 0.0040680000000001s
100 0.011595s
1000 0.049718s
10000 0.457164s
100000 4s
1000000 42s
SELECT
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 <1s
SELECT & DISPLAY
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 20s
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
________________________________________________
PHP5 with MongoDB
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
INSERT
------------------------------------------------
num of rows time taken
------------------------------------------------
10 0.065744s
100 0.190966s
1000 0.2163s
10000 1s
100000 8s
1000000 78s
FIND
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 <1s
FIND & DISPLAY
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 7s
UPDATE
------------------------------------------------
num of rows time taken
------------------------------------------------
1000000 9s