Estou muito empolgado com o MongoDb e tenho testado recentemente. Eu tinha uma tabela chamada posts no MySQL com cerca de 20 milhões de registros indexados apenas em um campo chamado 'id'.
Eu queria comparar a velocidade com o MongoDB e fiz um teste que obteria e imprimiria 15 registros aleatoriamente em nossos enormes bancos de dados. Executei a consulta cerca de 1.000 vezes cada uma para mysql e MongoDB e estou surpreso por não notar muita diferença de velocidade. Talvez o MongoDB seja 1,1 vezes mais rápido. Isso é muito decepcionante. Existe algo que estou fazendo de errado? Eu sei que meus testes não são perfeitos, mas o MySQL é parecido com o MongoDb quando se trata de ler tarefas intensivas.
Nota:
- Tenho dual core + (2 threads) i7 cpu e 4GB de RAM
- Eu tenho 20 partições no MySQL cada um dos 1 milhão de registros
Código de exemplo usado para testar o 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 exemplo para testar o 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;
}
?>
fonte
Respostas:
O MongoDB não é magicamente mais rápido. Se você armazena os mesmos dados, organizados basicamente da mesma maneira e os acessa exatamente da mesma maneira, não deve esperar que seus resultados sejam totalmente diferentes. Afinal, MySQL e MongoDB são ambos GPL, portanto, se o Mongo tivesse algum código de IO magicamente melhor, a equipe do MySQL poderia incorporá-lo à sua base de código.
As pessoas estão vendo o desempenho do MongoDB no mundo real, em grande parte porque o MongoDB permite que você consulte de uma maneira diferente, mais sensível à sua carga de trabalho.
Por exemplo, considere um design que persistisse com muitas informações sobre uma entidade complicada de maneira normalizada. Isso poderia facilmente usar dezenas de tabelas no MySQL (ou qualquer banco de dados relacional) para armazenar os dados na forma normal, com muitos índices necessários para garantir a integridade relacional entre as tabelas.
Agora considere o mesmo design com um repositório de documentos. Se todas essas tabelas relacionadas estiverem subordinadas à tabela principal (e geralmente são), você poderá modelar os dados para que toda a entidade seja armazenada em um único documento. No MongoDB, você pode armazenar isso como um único documento, em uma única coleção. É aqui que o MongoDB começa a permitir um desempenho superior.
No MongoDB, para recuperar toda a entidade, você deve executar:
Portanto, uma pesquisa em árvore b e uma página binária são lidas. Log (n) + 1 E / S. Se os índices puderem residir inteiramente na memória, 1 IO.
No MySQL com 20 tabelas, você deve executar:
Portanto, o total para o mysql, mesmo assumindo que todos os índices estejam na memória (o que é mais difícil, pois há 20 vezes mais deles) é de cerca de 20 pesquisas de intervalo.
Essas pesquisas de intervalo provavelmente são compostas por E / S aleatórias - tabelas diferentes definitivamente residem em pontos diferentes no disco, e é possível que linhas diferentes no mesmo intervalo na mesma tabela para uma entidade possam não ser contíguas (dependendo de como a entidade foi atualizado etc.).
Portanto, neste exemplo, a contagem final é cerca de 20 vezes mais IO com MySQL por acesso lógico, em comparação com o MongoDB.
É assim que o MongoDB pode aumentar o desempenho em alguns casos de uso .
fonte
Você tem simultaneidade, ou seja, usuários simultâneos? Se você executar 1000 vezes a consulta diretamente, com apenas um encadeamento, quase não haverá diferença. Muito fácil para esses mecanismos :)
Mas sugiro fortemente que você crie uma sessão de teste de carga real, o que significa usar um injetor como o JMeter com 10, 20 ou 50 usuários AO MESMO TEMPO para que você possa realmente ver a diferença (tente incorporar esse código dentro de uma página da Web JMeter poderia consultar).
Eu fiz isso hoje em um único servidor (e uma coleção / tabela simples) e os resultados são bastante interessantes e surpreendentes (o MongoDb foi realmente mais rápido em gravações e leituras, comparado ao mecanismo MyISAM e ao mecanismo InnoDb).
Isso realmente deve fazer parte do seu teste: mecanismo de concorrência e MySQL. Então, as necessidades de aplicativos e design de dados / esquema são, obviamente, enormes requisitos, além do tempo de resposta. Deixe-me saber quando você obtiver resultados, também estou precisando de informações sobre isso!
fonte
Fonte: https://github.com/webcaetano/mongo-mysql
10 linhas
100 linhas
1000 linhas
10.000 linhas
fonte
man ,,, a resposta é que você está basicamente testando PHP e não um banco de dados.
não se incomode em repetir os resultados, comentando a impressão ou não. há um pedaço de tempo.
enquanto o outro pedaço gasta gerando vários números aleatórios.
então há uma grande diferença b / w implodir e dentro
e finalmente o que está acontecendo aqui. parece criar uma conexão a cada vez, assim testando o tempo de conexão mais o tempo de consulta.
vs
portanto, seu 101% mais rápido pode ser 1000% mais rápido para a consulta subjacente sem jazz.
urghhh.
fonte
https://github.com/reoxey/benchmark
referência
comparação de velocidade do MySQL e MongoDB em GOLANG1.6 e PHP5
sistema usado para benchmark: DELL cpu i5 4th gen 1.70Ghz * 4 ram 4GB GPU ram 2GB
Comparação de velocidade de RDBMS vs NoSQL para INSERT, SELECT, UPDATE, DELETE executando um número diferente de linhas 10,100,1000,10000,100000,1000000
O idioma usado para executar é: PHP5 e o idioma mais rápido do Google GO 1.6
fonte
Aqui está uma pequena pesquisa que explorou RDBMS vs NoSQL usando MySQL vs Mongo, as conclusões foram alinhadas com a resposta de @Sean Reilly. Em resumo, o benefício vem do design, e não de uma diferença bruta de velocidade. Conclusão nas páginas 35-36:
RDBMS vs NoSQL: comparação de desempenho e dimensionamento
fonte
No servidor único, o MongoDb não seria mais rápido que o mysql MyISAM em leitura e gravação, dado que os tamanhos de tabela / documento são pequenos de 1 GB a 20 GB.
O MonoDB será mais rápido no Parallel Reduce em clusters de vários nós, onde o Mysql NÃO pode ser dimensionado horizontalmente.
fonte