MySQL vs MongoDB 1000 reads

Question

I have been very excited about MongoDb and have been testing it lately. I had a table called posts in MySQL with about 20 million records indexed only on a field called 'id'.

I wanted to compare speed with MongoDB and I ran a test which would get and print 15 records randomly from our huge databases. I ran the query about 1,000 times each for mysql and MongoDB and I am suprised that I do not notice a lot of difference in speed. Maybe MongoDB is 1.1 times faster. That's very disappointing. Is there something I am doing wrong? I know that my tests are not perfect but is MySQL on par with MongoDb when it comes to read intensive chores.

Note:

• I have dual core + ( 2 threads ) i7 cpu and 4GB ram
• I have 20 partitions on MySQL each of 1 million records

Sample Code Used For Testing 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; }  ?> 

Sample Code For Testing 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; } ?> 

Answer 1

MongoDB is not magically faster. If you store the same data, organised in basically the same fashion, and access it exactly the same way, then you really shouldn't expect your results to be wildly different. After all, MySQL and MongoDB are both GPL, so if Mongo had some magically better IO code in it, then the MySQL team could just incorporate it into their codebase.

People are seeing real world MongoDB performance largely because MongoDB allows you to query in a different manner that is more sensible to your workload.

For example, consider a design that persisted a lot of information about a complicated entity in a normalised fashion. This could easily use dozens of tables in MySQL (or any relational db) to store the data in normal form, with many indexes needed to ensure relational integrity between tables.

Now consider the same design with a document store. If all of those related tables are subordinate to the main table (and they often are), then you might be able to model the data such that the entire entity is stored in a single document. In MongoDB you can store this as a single document, in a single collection. This is where MongoDB starts enabling superior performance.

In MongoDB, to retrieve the whole entity, you have to perform:

• One index lookup on the collection (assuming the entity is fetched by id)
• Retrieve the contents of one database page (the actual binary json document)

So a b-tree lookup, and a binary page read. Log(n) + 1 IOs. If the indexes can reside entirely in memory, then 1 IO.

In MySQL with 20 tables, you have to perform:

• One index lookup on the root table (again, assuming the entity is fetched by id)
• With a clustered index, we can assume that the values for the root row are in the index
• 20+ range lookups (hopefully on an index) for the entity's pk value
• These probably aren't clustered indexes, so the same 20+ data lookups once we figure out what the appropriate child rows are.

So the total for mysql, even assuming that all indexes are in memory (which is harder since there are 20 times more of them) is about 20 range lookups.

These range lookups are likely comprised of random IO — different tables will definitely reside in different spots on disk, and it's possible that different rows in the same range in the same table for an entity might not be contiguous (depending on how the entity has been updated, etc).

So for this example, the final tally is about 20 times more IO with MySQL per logical access, compared to MongoDB.

This is how MongoDB can boost performance in some use cases.