MySQL vs MongoDB 1000 liest


320

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;
}
?>

11
Wie sind die tatsächlichen Zeiten?
Abe Petrillo

30
Ich bin kein DBA, daher ist dies ein Kommentar, keine Antwort, aber Geschwindigkeit sollte bei der Auswahl zwischen MySQL und MongoDB nicht im Vordergrund stehen. Dinge wie schemaless vs. Schema (dh wie oft muss sich Ihr Datenschema ändern) und Skalierung in der Größe (dh wie einfach ist es, Ihre Daten so zu sharden, dass für einen typischen Lesevorgang nur Daten von einem Server erforderlich sind) sind für eine Auswahl wichtiger so was.
Rossdavidh

17
Wie kann es beim Lesen schneller sein? Es liest von einem mechanischen Gerät. Gleich wie MySQL. Es hängt von der Geschwindigkeit des Geräts selbst ab. Sie können keine seltsame Magie über Code anwenden, um die Grenzen der Hardware zu überschreiten.
NB

7
Diese Frage erinnert mich nur daran: mongodb-is-web-scale.com
oligofren

13
Die Leute irren sich, dass sie das Gefühl haben, mit dem einen oder anderen zu gehen. Sie benötigen sowohl Mikrowelle als auch Backofen in Ihrer Küche. Man kann einfach nicht sagen, dass ich nur den einen oder anderen benutzen werde. Anwendungsfälle für beide Systeme sind unterschiedlich. Wenn Sie ACID für einen Teil Ihrer App benötigen, verwenden Sie RDBMS. Wenn Sie sich nicht um Konsistenz und Einschränkungen kümmern und Ihre Entitäten als alle in einer (Sammlungen) gespeichert werden können, verwenden Sie MongoDB. Am Ende verwenden Sie ein Hybridsystem. Entscheidend ist, was wo gespeichert werden soll.
Teoman Shipahi

Antworten:


643

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 .


43
Was ist, wenn wir nur eine Haupttabelle in MySQL setzen?
Ariso

98
@ariso: Dies ist eine Optimierung durch Denormalisierung. Es kann eine Leistungssteigerung bewirken. Wenn Sie dies jedoch tun, verlieren Sie Ihr klares Design und die gesamte Leistung (ganz zu schweigen von den meisten Funktionen) einer relationalen Datenbank. Und es funktioniert nur wirklich, bis Sie das Spaltenlimit erreicht haben.
Sean Reilly

7
@ SeanReilly Ihr Beispiel mit Entitäten (sollte mit Objekten bearbeitet werden, es gibt keine entitätsorientierte Programmierung :)) ist ungültig. Wie Ariso sagte, können Sie ein Objekt serialisieren und in der Datenbank speichern und bei Bedarf deserialisieren (jede Form der Serialisierung). Die wahre Kraft persistierender Objekte liegt in oodbms und nicht in documnet db-Systemen. Aber ich stimme zu, dass jeder seinen eigenen Zweck und seine eigenen Stärken hat (aber Ihr Beispiel verschleiert mehr die Vision und Relevanz dieses Themas).
Geo C.

9
20 Joins, würde ich sagen, sind höchstwahrscheinlich nicht die beste Abfrage für das beste Datenbankschema, das dies möglicherweise sein könnte.
Audrius Meskauskas

8
@ SeanReilly Ich fand dein Beispiel sehr hilfreich. Sie können eine spezielle Schnittstelle zu MySQL erstellen, die Objekte automatisch in Tabellen serialisiert und deserialisiert und sich wie Mongodb verhält. Aber warum nicht einfach etwas verwenden, das speziell dafür entwickelt wurde? Auch Ihre Verwendung von "Entität" ist sinnvoll. Der Punkt ist, dass Sie die Daten als Dokumente und nicht als Felder in einer Tabelle organisieren. Ob das Dokument ein Objekt ist, das in einer OO-Sprache erstellt wurde, spielt für das Beispiel keine Rolle.
BHS

57

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!


42
Können Sie Ihre Ergebnisse teilen?
Imran Omar Bukhsh

1
Ja, Ergebnisse dazu werden sehr hilfreich sein
Vasil Popov

3
Dies würde sich sicherlich nur skalieren lassen ... wenn es Äpfel zu Äpfeln wären, wie sie im Rest dieses Themas gesagt haben. Wenn es also im Durchschnitt x ausführt und jetzt aus mehreren Quellen simuliert, erklären Sie bitte, warum Mongo schneller wäre. Sagen wir einfach, um der Vereinbarung willen, dass MySQL für eine einzelne Anfrage durchschnittlich schneller war ... warum sollte Mongo jetzt für mehrere schneller werden? Ich finde das nicht sehr wissenschaftlich. Ich sage, der Test ist gültig. Aber ich bin mir nicht so sicher, wie groß der Unterschied wäre, wenn Sie Äpfel mit Äpfeln vergleichen würden, wie der Rest des Themas erklärt.
Seabizkit

36

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)

91
15 min, um 10.000 Zeilen einzufügen? Das ist eine sehr anämische MySQL-Datenbank. Nach meiner Erfahrung leuchtet mein Telefon mit Beschwerden auf, wenn sich eine solche Operation einer Dauer von 1 Sekunde nähert. :)
Mordechai

1
Xtreme Biker werfen Sie einen Blick auf den Link. Ich habe den Test von anderen Personen mit anderen Einstellungen gepostet.
user2081518

14
Ein paar Punkte: 1) MySQL muss richtig optimiert und konfiguriert werden, es gibt viele verschiedene Möglichkeiten, große Datenmengen einzufügen, und richtig kann es 0,1% der 15 Minuten dauern, siehe diese Seite zum Beispiel. 2) MongoDB schreibt die Daten nicht sofort auf die Festplatte, weshalb sie schneller "aussehen". Wenn Ihr Computer jedoch abstürzt, gehen die Daten verloren. 3) Lesen ist viel schneller in MySQL
elipoultorak

81
15min für 10.000 Zeilen? Sie haben jede Zeile eingegeben? =))))
Iurie Manea

6
Jeder, der glaubt, dass es 1,7 Sekunden dauert, zehn Zeilen in MySQL einzufügen, verdient den Schmerz, den er von Mongo bekommt
John Haugeland

20

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.


4
Natürlich kann die Codierungspraxis in jeder Situation einen großen Unterschied machen, aber dies ist nicht spezifisch für irgendeine Art von Sprache, API oder Erweiterung. Das Generieren der Zufallszahlen vor dem Starten des Timers macht einen Unterschied, aber die meiste Zeit innerhalb des Prozesses ist zweifellos von den Datenbanktransaktionen abhängig. Die Generierung von Zufallszahlen ist trivial, SQL- und NoSQL-Datenbanken nicht.
JSON

1
Wählen Sie nicht die Rand-Nummer. Offensichtlich haben Sie die Verbindung jedes Mal verpasst. Alle Probleme führen dazu, dass etwas anderes als beabsichtigt getestet wird.
Gabe Rainbow

2
Nein, habe es nicht verpasst. MySQL schließt die Verbindung erst, wenn das Skript beendet ist, es sei denn, mysqli_close () wird aufgerufen. Andernfalls wird durch wiederholte Aufrufe von mysqli_connect () nur die vorhandene mysql-Ressource aus der aktuellen Ressourcentabelle abgerufen, anstatt eine neue Verbindungsprozedur festzulegen. Ich bin nicht genau sicher, was das AQLDatabase-Objekt ist, aber wenn es die MySQL-Bibliothek verwendet (was es wahrscheinlich tut), wird es das gleiche Verhalten haben. Die MongoDB-Erweiterung verwendet Verbindungspooling. Daher tritt dasselbe Grundprinzip auf, wenn eine Mongodb-Verbindung mehr als einmal in einem Skript erstellt wird.
JSON

Ich bin damit einverstanden, dass sein Benchmark anders hätte durchgeführt werden können, aber er spiegelt die gleichen grundlegenden Ergebnisse wider wie andere MySQL vs Mongo-Bänke, die ich gesehen habe. Mongo ist normalerweise schneller beim Einfügen (viel schneller für einfachere Einfügungen) und MySQL ist normalerweise schneller bei der Auswahl.
JSON

zugegeben, ich war zu mürrisch; Es war diese HTML-Zeichenfolge von "<br>", die mich wirklich "herausgefordert" hat. Sie brauchen keinen hübschen Druck in Tests. Selbst wenn man es wiederholt, scheint es ein PHP-Test und kein Datenbanktest zu sein. Insgesamt bedeutet dieser AQLDatabase-Moment "möglicherweise / vielleicht" ... mehr Inhaltsstoffe bedeuten mehr Unbekannte.
Gabe Rainbow

17

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

Myisam ist nicht innodb, auch welche Mongodb-Version und Speicher-Engine?

1
Es ist wichtig, MySQL- und MongoDB-Versionen anzugeben.
Miron

1
Verwenden Sie MyISAM nicht. Verwenden Sie gestapelte Einsätze!
Rick James

MySQL ist schneller als Mongodb in Insert Query?! Es scheint nicht wahr zu sein, bis MySQL Spalten und Neubeziehungen vorbereiten muss. MySQL-Auswahl ist schneller als Mongodb-Auswahl, aber in der Einfüge-Abfrage ist Mongo schneller
Exind

6

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.


-6

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.


5
Können Sie Beweise oder weitere Details liefern, um dies zu belegen?
Steve Westbrook

Kann nicht horizontal skaliert werden? Was ist mit NDB? DRBD unterstützt MySQL?
Ernestas

Das ist nicht wahr. MongoDB hat ein Dokumentlimit von 16MD. MySQL kann viel mehr haben, wenn Sie
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.