MySQL vs MongoDB 1000 liest

Ich war sehr aufgeregt über MongoDb und habe es in letzter Zeit getestet. Ich hatte eine Tabelle namens posts in MySQL mit ungefähr 20 Millionen Datensätzen, die nur in einem Feld namens 'id' indiziert waren.

Ich wollte die Geschwindigkeit mit MongoDB vergleichen und führte einen Test durch, bei dem 15 Datensätze zufällig aus unseren riesigen Datenbanken abgerufen und gedruckt wurden. Ich habe die Abfrage für MySQL und MongoDB jeweils etwa 1.000 Mal ausgeführt und bin überrascht, dass ich keinen großen Geschwindigkeitsunterschied bemerke. Vielleicht ist MongoDB 1,1-mal schneller. Das ist sehr enttäuschend. Gibt es etwas, was ich falsch mache? Ich weiß, dass meine Tests nicht perfekt sind, aber MySQL ist MongoDb ebenbürtig, wenn es darum geht, intensive Aufgaben zu lesen.

Hinweis:

• Ich habe Dual Core + (2 Threads) i7 CPU und 4 GB RAM
• Ich habe 20 Partitionen auf MySQL mit jeweils 1 Million Datensätzen

Beispielcode zum Testen von 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;
}

?>

Beispielcode zum Testen von 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;
}
?>

MongoDB ist nicht magisch schneller. Wenn Sie dieselben Daten speichern, im Grunde auf dieselbe Weise organisiert sind und genau auf dieselbe Weise darauf zugreifen, sollten Sie wirklich nicht erwarten, dass Ihre Ergebnisse stark voneinander abweichen. Schließlich sind MySQL und MongoDB beide GPL. Wenn Mongo also einen magisch besseren E / A-Code enthält, kann das MySQL-Team ihn einfach in seine Codebasis integrieren.

Die Menschen sehen die Leistung von MongoDB in der realen Welt hauptsächlich, weil Sie mit MongoDB auf eine andere Art und Weise abfragen können, die für Ihre Arbeitslast sinnvoller ist.

Stellen Sie sich zum Beispiel ein Design vor, das auf normalisierte Weise viele Informationen über eine komplizierte Entität enthält. Dies könnte leicht Dutzende von Tabellen in MySQL (oder einer relationalen Datenbank) verwenden, um die Daten in normaler Form zu speichern, wobei viele Indizes erforderlich sind, um die relationale Integrität zwischen Tabellen sicherzustellen.

Betrachten Sie nun das gleiche Design mit einem Dokumentenspeicher. Wenn alle diese zugehörigen Tabellen der Haupttabelle untergeordnet sind (und dies häufig der Fall ist), können Sie die Daten möglicherweise so modellieren, dass die gesamte Entität in einem einzigen Dokument gespeichert wird. In MongoDB können Sie dies als einzelnes Dokument in einer einzelnen Sammlung speichern. Hier beginnt MongoDB, überlegene Leistung zu ermöglichen.

In MongoDB müssen Sie Folgendes ausführen, um die gesamte Entität abzurufen:

• Eine Indexsuche für die Sammlung (vorausgesetzt, die Entität wird von id abgerufen)
• Rufen Sie den Inhalt einer Datenbankseite ab (das eigentliche binäre JSON-Dokument).

Also eine B-Tree-Suche und eine Binärseite lesen. Protokoll (n) + 1 E / A. Wenn sich die Indizes vollständig im Speicher befinden können, dann 1 E / A.

In MySQL mit 20 Tabellen müssen Sie Folgendes ausführen:

• Eine Indexsuche in der Stammtabelle (wiederum unter der Annahme, dass die Entität von id abgerufen wird)
• Bei einem Clustered-Index können wir davon ausgehen, dass sich die Werte für die Stammzeile im Index befinden
• Über 20 Bereichssuchen (hoffentlich in einem Index) für den pk-Wert der Entität
• Dies sind wahrscheinlich keine Clustered-Indizes, daher werden dieselben 20+ Daten gesucht, sobald wir die entsprechenden untergeordneten Zeilen herausgefunden haben.

Die Summe für MySQL, selbst wenn angenommen wird, dass sich alle Indizes im Speicher befinden (was schwieriger ist, da es 20-mal mehr davon gibt), beträgt ungefähr 20 Bereichssuchen.

Diese Bereichssuchen bestehen wahrscheinlich aus zufälligen E / A-Vorgängen. Verschiedene Tabellen befinden sich definitiv an verschiedenen Stellen auf der Festplatte, und es ist möglich, dass verschiedene Zeilen im gleichen Bereich in derselben Tabelle für eine Entität nicht zusammenhängend sind (abhängig davon, wie die Entität war aktualisiert usw.).

In diesem Beispiel beträgt die endgültige Anzahl etwa 20-mal mehr E / A mit MySQL pro logischem Zugriff als in MongoDB.

Auf diese Weise kann MongoDB in einigen Anwendungsfällen die Leistung steigern .

Haben Sie Parallelität, dh gleichzeitige Benutzer? Wenn Sie die Abfrage nur 1000 Mal direkt mit nur einem Thread ausführen, gibt es fast keinen Unterschied. Zu einfach für diese Motoren :)

ABER ich empfehle dringend, dass Sie eine echte Lasttestsitzung erstellen, dh einen Injektor wie JMeter mit 10, 20 oder 50 Benutzern gleichzeitig verwenden, damit Sie wirklich einen Unterschied erkennen können (versuchen Sie, diesen Code in eine Webseite JMeter einzubetten könnte abfragen).

Ich habe es heute auf einem einzelnen Server (und einer einfachen Sammlung / Tabelle) gemacht und die Ergebnisse sind sehr interessant und überraschend (MongoDb war beim Schreiben und Lesen wirklich schneller als die MyISAM-Engine und die InnoDb-Engine).

Dies sollte wirklich Teil Ihres Tests sein: Parallelität & MySQL-Engine. Dann sind Daten- / Schemadesign und Anwendungsanforderungen natürlich enorme Anforderungen, die über die Antwortzeiten hinausgehen. Lassen Sie mich wissen, wenn Sie Ergebnisse erhalten, ich brauche auch Eingaben dazu!

Quelle: https://github.com/webcaetano/mongo-mysql

10 Reihen

mysql insert: 1702ms
mysql select: 11ms

mongo insert: 47ms
mongo select: 12ms

100 Zeilen

mysql insert: 8171ms
mysql select: 10ms

mongo insert: 167ms
mongo select: 60ms

1000 Zeilen

mysql insert: 94813ms (1.58 minutes)
mysql select: 13ms

mongo insert: 1013ms
mongo select: 677ms

10.000 Zeilen

mysql insert: 924695ms (15.41 minutes)
mysql select: 144ms

mongo insert: 9956ms (9.95 seconds)
mongo select: 4539ms (4.539 seconds)

Mann ,,, die Antwort ist, dass Sie im Grunde PHP testen und keine Datenbank.

Machen Sie sich nicht die Mühe, die Ergebnisse zu wiederholen, egal ob Sie den Druck auskommentieren oder nicht. Es gibt ein Stück Zeit.

   foreach ($cursor as $obj)
    {
        //echo $obj["thread_title"] . "<br><Br>";
    }

während der andere Teil damit verbringt, ein paar Rand-Zahlen zu sammeln.

function get_15_random_numbers()
{
    $numbers = array();
    for($i=1;$i<=15;$i++)
    {
        $numbers[] = mt_rand(1, 20000000) ;

    }
    return $numbers;
}

dann gibt es einen großen Unterschied s / w implodieren und in.

und schließlich, was hier los ist. Es sieht so aus, als würde jedes Mal eine Verbindung erstellt, sodass die Verbindungszeit plus die Abfragezeit getestet werden.

$m = new Mongo();

vs.

$db = new AQLDatabase();

Ihre 101% schnellere Abfrage könnte sich für die zugrunde liegende Abfrage ohne Jazz als 1000% schneller herausstellen.

urghhh.

https://github.com/reoxey/benchmark

Benchmark

Geschwindigkeitsvergleich von MySQL & MongoDB in GOLANG1.6 & PHP5

System für Benchmark verwendet: DELL CPU i5 4. Generation 1,70 GHz * 4 RAM 4 GB GPU RAM 2 GB

Geschwindigkeitsvergleich von RDBMS mit NoSQL für INSERT, SELECT, UPDATE, DELETE, wobei eine unterschiedliche Anzahl von Zeilen ausgeführt wird 10.100.1000.10000.100000.1000000

Die zur Ausführung verwendete Sprache ist: PHP5 & Google schnellste Sprache 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

Hier ist eine kleine Untersuchung , die RDBMS vs NoSQL mit MySQL vs Mongo untersuchte. Die Schlussfolgerungen stimmten mit der Antwort von @Sean Reilly überein. Kurz gesagt, der Vorteil liegt im Design, nicht in einem Geschwindigkeitsunterschied. Schlussfolgerung auf Seite 35-36:

RDBMS vs NoSQL: Leistungs- und Skalierungsvergleich

Das Projekt testete, analysierte und verglich die Leistung und Skalierbarkeit der beiden Datenbanktypen. Die durchgeführten Experimente umfassten das Ausführen verschiedener Anzahlen und Arten von Abfragen, von denen einige komplexer als andere sind, um zu analysieren, wie die Datenbanken mit zunehmender Last skaliert wurden. Der wichtigste Faktor in diesem Fall war der Abfragetyp, der verwendet wurde, da MongoDB komplexere Abfragen schneller verarbeiten konnte, hauptsächlich aufgrund seines einfacheren Schemas beim Opfer der Datenverdoppelung, was bedeutet, dass eine NoSQL-Datenbank möglicherweise große Mengen an Datenvervielfältigungen enthält. Obwohl ein direkt aus dem RDBMS migriertes Schema verwendet werden könnte, würde dies den Vorteil der zugrunde liegenden Datendarstellung von Unterdokumenten durch MongoDB beseitigen, die die Verwendung weniger Abfragen an die Datenbank beim Kombinieren von Tabellen ermöglichte.Trotz des Leistungsgewinns, den MongoDB gegenüber MySQL in diesen komplexen Abfragen hatte, zeigte MySQL am besten, wenn der Benchmark die MySQL-Abfrage ähnlich wie die komplexe MongoDB-Abfrage unter Verwendung verschachtelter SELECTs modellierte, obwohl sich die beiden bei einer höheren Anzahl von Verbindungen ähnlich verhielten. Der letzte Abfragetyp, bei dem es sich um eine komplexe Abfrage handelte, die zwei JOINS und eine Unterabfrage enthielt, zeigte den Vorteil, den MongoDB gegenüber MySQL aufgrund der Verwendung von Unterdokumenten hat. Dieser Vorteil geht zu Lasten der Datenverdoppelung, die zu einer Erhöhung der Datenbankgröße führt. Wenn solche Abfragen in einer Anwendung typisch sind, ist es wichtig, NoSQL-Datenbanken als Alternativen zu betrachten und dabei die Kosten für Speicher und Speicher zu berücksichtigen, die sich aus der größeren Datenbank ergeben.

Auf einem einzelnen Server wäre MongoDb sowohl beim Lesen als auch beim Schreiben nicht schneller als MySQL MyISAM, da die Tabellen- / Dokumentgrößen zwischen 1 GB und 20 GB liegen.
MonoDB ist bei paralleler Reduzierung auf Multi-Node-Clustern schneller, bei denen MySQL NICHT horizontal skalieren kann.