Name: Erhöhung der Komplexität Abfragen in relationalen (MySQL) und NoSQL (MongoDB und existieren) Größe wachsenden ISO/EN 13606 standardisierte EHR Datenbanken (Video) | JoVE Journal
Uploaded: 2018-03-19T14:30:00.000+00:00
Duration: 7 min 26 s
Description: Erfahren Sie, wie Sie die Rechenkomplexität von relationalen und NoSQL-Datenbanksystemen vergleichen. Diese Methode analysiert Antwortzeiten komplexer Abfragen in MySQL und MongoDB bei wachsenden Datenbankgrößen.

ai_agent_IP

ai_agent

maintenance

instantTrialDurationMinutes

isBiopharma

enableNewMyJoveSectionDesign

educationFeatures

seoMetaApi

ai_copilot_institution_blacklist

ai_chat_institution_blacklist

freeAccessWindow

ssoRoleCapture

scheduledMaintenanceBanner

joveLabsFeatures

disable_autoplay_for_bots

extended_trial_duration

5 minutes

playerTrialDesktop

Die Autoren möchten Dr Dipak Kalra, Leiter der Task Force EHRCom danken, die der standard ISO/EN-13606 und sein Team vom University College London für ihre freundliche Genehmigung verwenden Sie das ISO/EN 13606 W3C XML-Schema definiert.
Diese Arbeit wurde unterstützt von Instituto de Salud Carlos III [Grantnummern PI15/00321, PI15/00003, PI1500831, PI15CIII/00010 und RD16CIII].

1. erstellen Sie eine relationale MySQL-DBMS um drei doppelte Größe EHR standardisierte Extrakte Datenbanken speichern
<ol><li>Importieren des W3C (World Wide Web Consortium) XML-Schema entspricht der ISO/EN13606 RM und ISO21090 Datentypen in einer "Java IDE" (Integrated Development Environment). Hinweis: ISO steht für International Standards Organization. EN steht für Europäische Norm.</li>
	<li>Die JAXB (Java XML Binding)-Plug-in in der IDE ausgeführt; Dies führt zu Java-Klassen entsprechend der Struktur der Elemente der EHR Auszüge XML-Dateien.</li>
	<li>Kennzeichnen Sie manuell die Java-Klassen mit JPA Etiketten produziert. Diese Bezeichnungen beziehen sich auf die Kardinalitäten und andere Beziehungen zwischen den relationalen Tabellen der MySQL-Datenbank.</li>
	<li>Importieren Sie die Bibliotheken der JPA (Java Persistence API) in der IDE und führen Sie die Methode, die eine MySQL -Datenbank aus den tagged Java-Klassen aufbaut.</li>
	<li>Erstellen Sie drei Verzeichnisse mit 5.000, 10.000 und 20.000 realistische EHR XML-Dateien extrahiert.</li>
	<li>Führen Sie die PPV-Methode um ein XML-Extrakt in MySQL DBMS auf den Extrakten des Verzeichnisses 5.000 Extrakte zu laden.</li>
	<li>Wiederholen Sie Schritt 1.6 zweimal, einmal mit 10.000 Extrakte Verzeichnis und einmal mit dem 20.000 Extrakte-Verzeichnis.</li>
</ol>2. bauen Sie ein NoSQL MongoDB DBMS um drei doppelte Größe EHR standardisierte Extrakte Datenbanken speichern
<ol><li>Jeder Prozess der drei Verzeichnisse mit 5.000, 10.000 und 20.000 realistische EHR Auszüge XML-Dateien mit einem standard-Programm zum XML-Dateien konvertieren in JSON-Dateien, wie z. B. json.org.XML. Drei Verzeichnisse mit 5.000, 10.000 und 20.000 JSON-Dateien sollte hergestellt werden.</li>
	<li>Starten einer MongoDB-GUI (grafische Benutzeroberfläche, siehe Tabelle der Materialien).</li>
	<li>Starten Sie den MongoDB 2.6 Server Ausführung des Mongod Programms aus einem DOS (Disk Operating System)-System-Fenster.</li>
	<li>Verbinden Sie die MongoDB-GUI mit dem "localhost" Server über Port 27017.<ol>
<li>Wählen Sie im Menü "verbinden".</li>
		<li>Geben Sie einen Namen für die Verbindung (zum Beispiel "first").</li>
		<li>Schreiben Sie Localhost:27017 in der DB-Server-Textfeld.</li>
		<li>Drücken Sie die Schaltfläche "verbinden"; ein Baum mit aktuellen Datenbanken sollte auf der linken Seite angezeigt werden.</li>
	</ol>
</li>
	<li>Erstellen Sie eine Datenbank mit 5.000 standardisierte EHR Extrakte.<ol>
<li>Klicken Sie auf den Namen der Verbindung an der Spitze des Baumes auf der linken Seite.</li>
		<li>Wählen Sie im Menü "Datei".</li>
		<li>Wählen Sie "Datenbank hinzufügen".</li>
		<li>Geben Sie den Namen der Datenbank im Dialogfeld, das angezeigt wird.</li>
		<li>Klicken Sie auf OK.</li>
	</ol>
</li>
	<li>Erstellen Sie eine Auflistung mit 5.000 standardisierte EHR Extrakte.<ol>
<li>Klicken Sie auf den Namen der Datenbank in der Baumstruktur auf der linken Seite.</li>
		<li>Wählen Sie Menü "Datenbank".</li>
		<li>Wählen Sie "AddCollection".</li>
		<li>Geben Sie den Namen der Sammlung in das Dialogfeld, das angezeigt wird.</li>
		<li>Klicken Sie auf " Erstellen".</li>
		<li>Klicken Sie auf den Namen der Sammlung.</li>
		<li>Wählen Sie im Menü "Importieren".</li>
		<li>Wählen Sie die Optionsschaltfläche ''JSON - Mongo Schale / / Mongoexport ".</li>
		<li>Klicken Sie auf "nächste".</li>
		<li>Drücken Sie den Button "Source-Dateien hinzufügen".</li>
		<li>Navigieren Sie auf dem Computer mithilfe des Dialogfelds.</li>
		<li>Offen das Verzeichnis mit 5.000 JSON-Dateien extrahieren.</li>
		<li>Wählen Sie alle Dateien im Verzeichnis.</li>
		<li>Klicken Sie auf "Öffnen". Die Liste der JSON-Dateien sollten im Import-Dialog angezeigt.</li>
		<li>Klicken Sie auf "nächste"; auf der linken Seite erscheint eine Vorschau der neuen Kollektion in der Datenbank.</li>
		<li>Klicken Sie auf "nächste".</li>
		<li>Drücken Sie auf "Import starten". Der Fortschritt des Importvorgangs erscheint unten auf der linken Seite, die Anzahl der importierten Dateien und die verstrichene Zeit angibt.</li>
	</ol>
</li>
	<li>Wiederholen Sie die Schritte 5 und 6, eine Sammlung von 10.000 standardisierte EHR Extrakte zu bauen.</li>
	<li>Wiederholen Sie die Schritte 5 und 6, eine Sammlung von 20.000 standardisierte EHR Extrakte zu bauen.</li>
</ol>3. Aufbau einer NoSQL existieren DBMS zu drei doppelte Größe standardisiert EHR extrahiert Datenbanken
<ol><li>Starten Sie die Datenbank bestehen .</li>
	<li>Öffnen Sie mit dem Datenbank-Symbol der Java-Admin-Client.</li>
	<li>Geben Sie das Administratorkennwort ein.</li>
	<li>Drücken Sie die Schaltfläche "verbinden".</li>
	<li>Erstellen Sie eine Auflistung mit 5.000 standardisierte EHR Extrakte.<ol>
<li>Wählen Sie in der Symbolleiste das Menü "Erstellen einer neuen Sammlung".</li>
		<li>Geben Sie im Dialogfeld, das angezeigt wird den Namen der neuen Kollektion.</li>
		<li>Klicken Sie auf "akzeptieren"; die neue Kollektion erscheint.</li>
		<li>Wählen Sie den Namen der Sammlung.</li>
		<li>Wählen Sie in der Symbolleiste das Menü "Dateien speichern in der Datenbank".</li>
		<li>Navigieren Sie auf dem Computer mithilfe des Dialogfeldes.</li>
		<li>Wählen Sie das Verzeichnis mit 5.000 standardisierten XML-Extrakt Dateien.</li>
		<li>Klicken Sie auf "Wählen Sie die Dateien oder Verzeichnisse speichern". Beachten Sie, dass ein Dialogfenster zeigt den Fortschritt der Dateien und der Prozentsatz der Datenbank erstellt.</li>
	</ol>
</li>
	<li>Wiederholen Sie Schritt 5, um eine Auflistung mit 10.000 EHR standardisierte Extrakte bauen.</li>
	<li>Wiederholen Sie Schritt 5, um eine Auflistung mit 20.000 EHR standardisierte Extrakte bauen.</li>
</ol>4. design und 6 Komplexität steigt Abfragen ausführen, in den 3 relationale MySQL-Datenbanken
<ol><li>Entwerfen Sie sechs Komplexität steigt Abfragen nach den Archetypen von der EHR-Extrakte verwendet.</li>
	<li>Ein SQL-Skript mit der ersten Abfrage auf die MySQL-Datenbank zu programmieren. Die SQL-Anweisung muss auf die spezielle Struktur der MySQL Datenbank aufgrund der Extrakte Standardisierung (Archetypen) einstellen. Die Datenbank bildet die gesamte Struktur der Extrakte. Infolgedessen ist die SQL-Abfrage ziemlich komplex.</li>
	<li>Identifizieren Sie die Attribute der Datenbanken, die würde die Reaktionszeit der Abfragen beschleunigen, wenn ein Index auf sie gebaut wurde, dann solche Indizes zu konstruieren, obwohl die meisten Indizes automatisch durch das DBMS erstellt werden.</li>
	<li>Wenn eine Abfrage nicht automatisch erstellten Indexdatei benötigt, es manuell zu erstellen.<ol>
<li>Verbinden Sie mit dem MySQL-Server (zusätzliche Abbildung1).</li>
		<li>Wählen Sie und klicken Sie auf den Namen der Datenbank auf der linken Seite.</li>
		<li>Wählen Sie und klicken Sie auf die relationale Tabelle indizierte Feld Speicherort.</li>
		<li>Klicken Sie auf die Registerkarte "Struktur".</li>
		<li>Wählen Sie und klicken Sie auf die Spalte wo der Index erstellt wird.</li>
		<li>Klicken Sie auf "Index". Beachten Sie, dass der SQL-Satz erstellen des Index angezeigt wird, erscheint eine Meldung, dass der Satz erfolgreich erstellt wurde.</li>
	</ol>
</li>
	<li>Die erste Abfrage ausführen.<ol>
<li>Wählen Sie und klicken Sie auf den Namen der Datenbank auf der linken Seite.</li>
		<li>Klicken Sie auf die Registerkarte "SQL".</li>
		<li>Schreiben Sie oder fügen Sie den SQL-Code der ersten Abfrage (siehe ergänzende Abbildung2).</li>
		<li>Drücken Sie "weiter". Beachten Sie, dass das erste Bild der Ergebnisliste, zusammen mit einer Nachricht mit der Ausführungszeit der Abfrage erscheint.</li>
		<li>Wiederholen Sie die Ausführung 5 Mal und berechnen Sie die durchschnittliche Antwortzeit.</li>
	</ol>
</li>
	<li>Wiederholen Sie Schritt 5 mit 2 bis 6 Abfragen.</li>
	<li>Den gesamten Prozess dreimal mit der 5.000, 10.000 und 20.000 Datenbanken extrahiert.</li>
</ol>5. entwerfen und in den 3 NoSQL MongoDB-Datenbanken 6 Komplexität steigt Abfragen ausführen
<ol><li>Die MongoDB-GUI zu starten (siehe Tabelle der Materialien).</li>
	<li>Starten Sie den MongoDB 2.6 Server Ausführung des Mongod -Programms von einem DOS-System-Fenster (siehe ergänzende Abbildung 3).</li>
	<li>Folgen Sie Schritt 2.4, MongoDB GUI Verbindung zum "localhost" Server Port 27017 verwendet.</li>
	<li>Wählen Sie und erweitern Sie die MongoDB-Datenbank auf der linken Seite.</li>
	<li>Wählen Sie die Sammlung.</li>
	<li>Klicken Sie auf das Menü "Sammlung" in der Symbolleiste.</li>
	<li>Die ersten MongoDB-Abfrage ausführen.<ol>
<li>Doppelklicken Sie auf die Schaltfläche "Abfrage-Generator".</li>
		<li>Doppelklicken Sie auf das "Abfragefeld" von den Abfrage-Generator auf der rechten Seite.</li>
		<li>Schreiben Sie das Feld der MongoDB-Abfrage in das Textfeld Feld ein, von den Abfrageeditor (siehe ergänzende Abbildung 4).</li>
		<li>Schreiben Sie den Wert der MongoDB-Abfrage in das Textfeld Wert der Abfrageeditor. Hinweis: Diese Abfrage sollte sein etwas wie {"ns3:EHRExtract.allCompositions.content.items.parts.parts.name.ns2:originalText. Wert":"Descripcion"}. Das Feld der Wert zitiert und durch Semikolon voneinander getrennt.</li>
		<li>Doppelklicken Sie auf das Projektionsfeld des Abfrage-Generator</li>
		<li>Schreiben Sie die erste Projektion in der Projektion Textbox (siehe ergänzende Abbildung 5).</li>
		<li>Doppelklicken Sie auf das Projektionsfeld, eine neue Projektion Textfeld hinzuzufügen.</li>
		<li>Schreiben Sie die zweite Projektion in der Projektion Textbox. Hinweis: Eine Projektion wählt einen Teil des Dokuments durch die Abfrage abgerufen. Diese sollte etwas wie {"Ns3:EHRExtract. allCompositions.content.items.parts.parts.value.value": 1} und {" ns3: EHRExtract.all Compositions.content.items.parts.parts.value.nullFlavor ": 1}</li>
		<li>Klicken Sie auf den blauen Play-Button zum Ausführen der Abfrage.</li>
		<li>Visualisieren Sie den Abfragecode in der Registerkarte "Abfragecode".</li>
		<li>Zeigen Sie die Details des Ergebnisses in der Registerkarte Erklärung: Anzahl der Ergebnisse, Ausführungszeit in Millisekunden.</li>
		<li>Zeigen Sie an, erweitern Sie und prüfen Sie die Ergebnisse in der Registerkarte "Ergebnis".</li>
		<li>Wenn weitere Verarbeitung der Abfrage erforderlich ist, schreiben Sie eine Java-Programm mit dem MongoDB-Java-Treiber mit der Abfrage und eine Methode, die Ergebnisse zu verarbeiten.</li>
		<li>Wiederholen Sie die Ausführung 5 Mal und berechnen Sie die durchschnittliche Antwortzeit.</li>
	</ol>
</li>
	<li>Treten Sie 5.7 für die verbleibenden 2 bis 6 Abfragen.</li>
	<li>Wiederholen Sie der gesamte Prozess in die 5.000, 10.000 und 20.000 MongoDB Datenbanken extrahiert.</li>
</ol>(6) entwerfen und ausführen in den 3 NoSQL existieren Datenbanken 6 zunehmende Komplexität Abfragen
<ol><li>Starten Sie die existieren DBMS.</li>
	<li>Öffnen Sie die Java-Admin-Client.</li>
	<li>Drücken Sie die Taste "verbinden mit der Datenbank".</li>
	<li>Wählen Sie die Datenbank, und klicken Sie darauf.</li>
	<li>Klicken Sie auf das Menü "Datenbank mit XPath"; Sie gelangen auf das Dialogfenster Consult.</li>
	<li>Die ersten XPath-Abfrage ausführen (siehe ergänzende Abbildung 6).<ol>
<li>Schreiben Sie oder fügen Sie den XPath-Code der ersten Abfrage im oberen Teil des Dialogfelds.</li>
		<li>Klicken Sie auf das Menü "Ausführen" in der Symbolleiste des Dialogfensters.</li>
		<li>XML-Ergebnisse mithilfe der Registerkarte "XML" im unteren Teil des Dialogfelds angezeigt.</li>
		<li>Anzahl der Ergebnisse und Erstellung und Ausführungszeit am unteren Rand das Dialogfeld anzeigen.</li>
		<li>Wiederholen Sie die Ausführung 5 Mal und berechnen Sie die durchschnittliche Antwortzeit.</li>
	</ol>
</li>
	<li>Wiederholen Sie Schritt 6 für 2 bis 6 Abfragen.</li>
	<li>Tun Sie den gesamten Prozess dreimal für die 5.000, 10.000 und 20.000 Extrakte Datenbanken vorhanden sind.</li>
</ol>(7) entwerfen und Ausführen einer Parallelität Experiment mit MySQL und MongoDB 5.000 extrahiert Datenbanken
Hinweis: Die eXist-Datenbank wurde aus dem Experiment zu diesem Zeitpunkt wegen schlechter Leistung in den vorhergehenden Experimenten entfernt.
<ol><li>Wählen Sie die Abfragen mit den drei kürzester Zeit Antworten in den vorherigen Experimenten mit 5.000 Extrakte Datenbanken (in der Regel unter mehrere Sekunden).</li>
	<li>Identifizieren und entsprechende Attributindizes für Abfragen, bei Bedarf manuell zu erstellen.</li>
	<li>Programm zwei Java multithread-Anwendungen, eine für MySQL und die andere für MongoDB; jede Anwendung wird drei Threads mit verschiedenen Priorität, eine für jede Abfrage, die in Schritt 1 ausgewählt haben.</li>
	<li>Führen und die CPU (Central Processing Unit) Verteilung verwenden für jeden Thread (Abfrage) zu berechnen.</li>
	<li>Führen Sie jede multithread-Anwendung, klicken Sie auf die Schaltfläche "ausführen" fünfmal während jeder Spanne 10-min und berechnen die meisten hingerichteten (höchste Priorität) durchschnittliche Durchsatz und die durchschnittliche Reaktionszeit der drei Abfragen Abfragen.</li>
	<li>Die Abfragen in der Ausführung, mit Prioritäten und Ausführungszeit anzeigen</li>
	<li>Durchschnittlichen Durchsatz und die durchschnittliche Antwortzeit eines jeden der drei Abfragen zu berechnen.</li>
</ol>

<ol><li>Codd, E. F. <a target="_blank" href="https://cs.uwaterloo.ca/~david/cs848s14/codd-relational.pdf">A relational model for large shared data banks.</a> Comm ACM. 13 (6), 377-387 (1970).</li>
<li>Kalra, D., Lloyd, D. <a target="_blank" href="http://scholar.google.com/scholar?hl=en&safe=off&q=author%3aKalra%2C+D+%22ISO+13606+electronic+health+record+communication+part+1%3A+reference+model%22">ISO 13606 electronic health record communication part 1: reference model</a>. , ISO. Geneva. ISO 13606-1 (2008).</li>
<li>Kalra, D., et al. <a target="_blank" href="http://scholar.google.com/scholar?hl=en&safe=off&q=author%3aKalra%2C+D+%22Electronic+health+record+communication+part+2%3A+archetype+interchange+specification%22">Electronic health record communication part 2: archetype interchange specification</a>. , ISO. Geneva. ISO 13606-2 (2008).</li>
<li>Kalra, D., Beale, T., Heard, S. <a target="_blank" href="https://www.ncbi.nlm.nih.gov/pubmed/16160223">The openEHR foundation.</a> Stud. Health Technol. Inform. 115, 153-173 (2005).</li>
<li>Health Level seven. Health Level Seven International. , Available from:
 <a target="_blank" href="http://www.hl7.org">http://www.hl7.org</a> (2017).</li>
<li>Beale, T. <a target="_blank" href="https://www.researchgate.net/publication/237033734_Archetypes_Constraint-based_Domain_Models_for_Future-proof_Information_Systems">Archetypes: constraint-based domain models for future proof information systems.</a> OOPSLA, Workshop Behav Semant. , (2002).</li>
<li>Sánchez-de-Madariaga, R., et al. <a target="_blank" href="http://www.ncbi.nlm.nih.gov/pubmed?term=((Examining+database+persistence+of+ISO%2FEN+13606+standardized+electronic+health+record+extracts%3A+relational+vs.+NoSQL+approaches%5BTitle%5D)+AND+%22BMC+Medical+Informatics+and+Decision+Making%22%5BJournal%5D)">Examining database persistence of ISO/EN 13606 standardized electronic health record extracts: relational vs. NoSQL approaches.</a> BMC Medical Informatics and Decision Making. 32 (2), 493-503 (2017).</li>
<li>Ireland, C., Bowers, D., Newton, M., Waugh, K. <a target="_blank" href="https://www.researchgate.net/publication/42800142_Understanding_object-relational_mapping_A_framework_based_approach">Understanding object-relational mapping: a framework based approach.</a> Int. J. Adv. Softw. 2, 202-216 (2009).</li>
<li>Node+Path Persistence. , Available from:
 <a target="_blank" href="https://openehr.atlassian.net/wiki/spaces/dev/pages/6553626/Node+Path+Persistence">https://openehr.atlassian.net/wiki/spaces/dev/pages/6553626/Node+Path+Persistence</a> (2017).</li>
<li>Wang, L., Min, L., Wang, R., et al. <a target="_blank" href="http://www.ncbi.nlm.nih.gov/pubmed?term=((Archetype+relational+mapping+-+a+practical+openEHR+persistence+solution%5BTitle%5D)+AND+%22BMC+Medical+Informatics+and+Decision+Making%22%5BJournal%5D)">Archetype relational mapping - a practical openEHR persistence solution.</a> BMC Medical Informatics and Decision Making. 15, 88(2015).</li>
<li>Kaur, K., Rani, R. <a target="_blank" href="http://ieeexplore.ieee.org/document/7063177/">Managing data in healthcare information systems: many models, one solution.</a> Computer. March. , 52-59 (2015).</li>
<li>Sabo, C., Pop, P. C., Valean, H., Danciulescu, D. <a target="_blank" href="https://link.springer.com/chapter/10.1007/978-3-319-53480-0_1">An innovative approach to manage heterogeneous information using relational database systems.</a> Advances in Intelligent Systems and Computing. 557, Springer. (2017).</li>
</ol>

Die Autoren haben nichts preisgeben. In diesen Experimenten verwendeten Datensätze wurden durch mehrere spanische Krankenhäuser unter Lizenz für diese Experimente zur Verfügung gestellt und sind daher nicht öffentlich zugänglich. Das ISO/EN 13606 RM XML-Schema sorgte das University College London Centre for Health Informatics & multiprofessionelle Bildung (Glockenspiel).

Dieses Protokoll zeigt, dass rein relationale ORM-Systemen nicht praktisch für einzelne Patienten Abfragen (Q1, Q3 und Q4) scheinen, da die Reaktionszeiten sind langsamer, wahrscheinlich aufgrund einer hohen Anzahl von relationalen Tabellen viele teure Join-Operationen durchführen, und aufgrund der Storage-System durch die spezifische Art der Datenbank verwendet. NoSQL-Datenbanken speichern Daten in ein Dokument-basierte Mode, während relationale Systeme eine tabellenbasierten Mode verwenden, die jedes Dokument in der gesamten Datenbank verbreitet. NoSQL-Systeme zeigen eine lineare Steigung mit MongoDB Durchführung wesentlich schneller als DBMS vorhanden sind. Parallelität MongoDB verhält sich auch viel besser als relationale MySQL ORM7.
Dieses Protokoll stellt eine Problembehandlung Protokoll für die Ergebnisse, die in7 bezüglich der ORM-MySQL-DBMS. Das MySQL-System wurde auf die neueste Version aktualisiert und die Ergebnisse wurden geringfügig geändert. Darüber hinaus ist wie MongoDB ist, dass sie Konsistenz bewahren können, wenn medizinische Informationen7 speichern, denn wenn ein EHR Auszug aktualisiert wird, ist es nicht überschrieben, sondern eine ganze neue mit den neuen Daten zu extrahieren ein kritischer Punkt im Dokument-basierte NoSQL-Systeme erzeugt und im System gespeichert und der Stammwürze wird beibehalten. Dies ist eine strenge Anforderung von medizinischen Informationen, weil einige Ärzte wichtige medizinische Entscheidungen auf Basis der ursprünglichen Daten gebildet haben können.
Die verbesserte relationalen ARM System drastisch verringert sich die Anzahl der relationalen Tabellen und relationalen Leistung verbessert. Da es das relationale Schema ändert, medizinische Informationen im Besitz der Extrakte kann abgefragt werden, jedoch Auszüge nicht in ihrer genauen ursprünglichen Form wiederhergestellt werden.
Für sehr große Datenbanken in sekundären verwenden (Forschung), es nicht klar ist, welche Datenbank-System besser geeignet ist, da die All-Patient-Abfragen (Q2 und Q5) besser in ORM als NoSQL-Systeme Verhalten, aber diese Systeme eine bessere als die vereinfachte Leistung relationalen Systeme im 12. Wir betrachten Q6 eine spezielle Abfrage zwischen klinischen Praxis und sekundäre verwenden, deren Verhalten durch die Ergebnisse dieser Experimente bestimmt werden kann.
Eine Einschränkung der Methode ist jedoch die Nichtverfügbarkeit von direkten Experimenten vergleichen das verbesserte relationalen ARM-System mit NoSQL MongoDB über einzelne Patienten, medizinische Praxis Abfragen mit exakt die gleichen Daten in das Protokoll verwendet. Wir erhalten die Ergebnisse, die Interpolation von Tabelle 3 und Tabelle 5 über einzelne Patienten Abfragen, bis das Experiment auch optimierte ARM in das Protokoll durchgeführt wurde. Wir verlassen diese Experimente für zukünftige Anwendungen. Ein wichtiger Schritt im Rahmen des Protokolls ist die Auswahl der kostenlosen Datenbank, ähnliche Software-Versionen der letzten Jahre, so dass wir die genaue State-of-the-Art der drei Technologien vergleichen kann.
Dies ist einer der ersten Versuche, relationale direkt zu vergleichen und NoSQL-Systeme mit tatsächlichen, realistisch, standardisierte medizinische Informationen. Jedoch hängt am jeweiligen System verwendet werden stark von der tatsächlichen Szenario und Problem gelöst8sein.

NoSQL (nicht nur SQL) DBMS sind vor kurzem als Alternative zu herkömmlichen relationalen DBMS (RDBMS) entstanden. RDBMS haben die Art und Weise beherrscht seit Jahrzehnten in Datenbanksystemen gespeichert wurden. Gut untersucht und verstanden relationale Algebra und Analysis haben die Effizienz und Konsistenz der RDBMS1garantiert. NoSQL-Systeme werden nicht Ersatz für relationale Systeme, aber sie könnte vorteilhaft Verhalten in bestimmten Situationen und unter verschiedenen Bedingungen.
Einige dieser bestimmten Szenarien und Bedingungen treten beim Entwerfen der Datenbank-Persistenz von Electronic Health Record (EHR) Systeme zur Verwaltung und Speicherung von medizinischen Informationen. Um interoperable und nachhaltig in der Praxis mehrere internationale Standards wie ISO/EN 13606, OpenEHR und HL72,3,4wurden,5 verwendet, um EHR Extrakte zu standardisieren.
Verschiedene Standards wie ISO/EN 13606 und OpenEHR haben Informationen und wissen in zwei verschiedenen Ebenen der Abstraktion, vertreten durch Referenz-Modell (RM) und spezielle Datenstrukturen genannt Archetypengetrennt. Diese Trennung ist oft das duale Modell genannt und EPA-Systemen semantisch interoperabel und medizinischem Wissen ohne Neuprogrammierung des Gesamtsystems EHR und infolgedessen zu entwickeln sein ermöglicht werden, wartbar und nachhaltig in der Praxis6 . Das duale Modell umgesetzt in standardisierten EPA-Systemen erfordert jedoch, dass die Organisation von Informationen einer bestimmten Struktur folgt, und dies hat tiefgreifende Auswirkungen auf die Weise ist der Datenbankebene Persistenz des Systems gestaltete7.
Objekt-relationale Mapping (ORM)-8 ist eine Methodik zur Umsetzung eines EPA-Systems mit dem relationalen Datenbank-Paradigma. ORM Karten ausführlich die Struktur der standardisierten EHR Extrakte XML (eXtensible Markup Language) Dateien vom System für eine relationale Datenbank verwendet. ORM baut viele relationale Tabellen umfassend entsprechend der Struktur der standardisierten EHR Auszüge XML-Dateien. Diese relationalen Tabellen sind durch viele Fremdschlüssel verknüpft und das resultierende System möglicherweise nicht sehr effizient.
Mehreren relationalen Verbesserungen in ORM sind vorgeschlagen worden. OpenEHR der Knoten + Pfad9 reduziert die Anzahl der relationalen Tabellen von serialisieren Teilstrukturen der Gesamtextrakt XML-Datei in BLOBs (binary Großobjekte). Allerdings verursacht diese Vereinfachung komplexer Abruf Logik, komplexe Abfragen zu beschädigen. Archetyp Relational Mapping (ARM)10 generiert ein Datenbankmodell angetrieben von Archetypen, Bau eines neuen relationalen Schemas basierend auf Zuordnungen zwischen Archetypen und relationalen Tabellen. Einige der nicht-medizinischen Informationen der EHR-Extrakt deshalb verloren.
Viele dokumentbasierte NoSQL-Datenbanken speichern Sie ganze Dokumente als gesamte BLOBs unter Beachtung einer ursprünglichen XML oder JSON (JavaScript Objekt Notation) Format. Dies bedeutet, dass keine relationalen Tabellen aufgebaut sind. Diese NoSQL-Datenbanken haben kein Schema, und sie unterstützen keine Verknüpfungen oder (Säure) Eigenschaften11, d. h., Unteilbarkeit, Konsistenz, Isolation oder Haltbarkeit. Dadurch können sie sehr ineffizient sein, wenn ein Element eines Dokuments verweist auf Elemente des gleichen oder anderen Schriftstücke unter Verwendung einen Dereferenzierung Link. Dies geschieht, weil, um Konsistenz zu gewährleisten, müssen die Gesamtheit der referenzierten Dokumente sequentiell abgearbeitet werden. Eine nicht-relationale Datenbank kann jedoch noch angemessen, wenn die Hauptaufgabe, durchgeführt durch das DBMS eine dokumentbasierte Aufgabe ist. Und zwar deshalb, weil Daten in Form mehr eng Annäherung sein getreues Abbild dokumentenbasierte NoSQL-Datenbank verwenden bleiben können, obwohl dies auch aufgrund der speziellen Ausdauer-Politik erreicht, indem EHR medizinische Unterlagen (siehe Diskussion).
Diese Methoden soll mehrere Experimente durchführen, um die Umsetzung der Persistenzschicht eine standardisierte EHR-System mit drei verschiedenen DBMS vergleichen zu präsentieren: eine relationale (MySQL) und zwei NoSQL (dokumentbasierte MongoDB und native XML vorhanden sein). Ihre Rechenkomplexität wurde berechnet und verglichen mit drei verschiedenen zunehmende Größe Datenbanken und sechs verschiedene größer werdende Komplexität Abfragen. Die drei Datenbankserver wurden installiert und lokal auf demselben Computer wo die Abfragen ausgeführt wurden konfiguriert. Tabelle der Materialien für technische Details anzeigen.
Parallelität Experimente wurden auch durchgeführt, um die Leistung der relationalen MySQL und NoSQL MongoDB DBMS zu vergleichen. Die beschriebenen ORM-Verbesserungen (Knoten + Pfad und ARM) wurden auch mit entsprechenden entsprechende Ergebnisse aus der Literatur10verglichen.
Datenbank-Management-Systeme werden kontinuierlich weiterentwickelt, mit einer rasanten Geschwindigkeit. Niemand würde diese exponentielle Entwicklung denken, wenn das einzige vorhandene Paradigma das relationale Modell war. Um ein Beispiel zu nennen, siehe z. B.12, wo wurde ein Modell vorgeschlagen, Reaktionszeit verbesserte relationale Datenbanken Beibehaltung der ACID-Eigenschaften zu implementieren.

<table><tbody><tr><td>MySQL 5.7.20</td><td></td><td></td><td>MySQL Experimente</td></tr><tr><td>Red Hat Enterprise Linux Server Release 7.4 (Maipo), 2,60 GHz, RAM 16 GB</td><td></td><td></td><td></td></tr><tr><td>MongoDB 2.6</td><td></td><td></td><td>MongoDB Experimente</td></tr><tr><td>Windows 7, 2,66 GHz, RAM 12 GB&nbsp;</td><td></td><td></td><td></td></tr><tr><td>eXist 3.0RC1</td><td></td><td></td><td>eXist experimentiert</td></tr><tr><td>Windows 7, 2,66 GHz, RAM 12 GB&nbsp;</td><td></td><td></td><td></td></tr><tr><td>Studio 3T 5.5.1</td><td>3T Software Labs Gmbh</td><td></td><td>MongoDB GUI</td></tr></tbody></table>

erhöhung der komplexität abfragen in relationalen (mysql) und nosql (mongodb und existieren) größe wachsenden iso/en 13606 standardisierte ehr datenbanken

Executing Complexity-Increasing Queries in Relational (MySQL) and NoSQL (MongoDB and EXist) Size-Growing ISO/EN 13606 Standardized EHR Databases

Diese Forschung zeigt ein Protokoll zur Bewertung der Rechenkomplexität Abfragen relationale und nicht relationale (NoSQL (nicht nur Structured Query Language)) standardisierte elektronische Aufzeichnung (EHR) medizinische Informationen Datenbanksysteme (DBMS). Es verwendet einen Satz von drei Verdoppelung große Datenbanken, d.h. Datenbanken speichern von 5000, 10.000 und 20.000 realistische standardisiert EHR Extrakte, in drei verschiedenen Datenbankmanagementsysteme (DBMS): relationale MySQL Objekt-relationale Mapping (ORM) dokumentbasierte NoSQL MongoDB und native extensible Markup Language (XML) NoSQL vorhanden sind.
Die durchschnittlichen Antwortzeiten auf sechs Komplexität steigt Abfragen wurden berechnet, und die Ergebnisse zeigten ein lineares Verhalten in der NoSQL-Fällen. Im Feld NoSQL präsentiert MongoDB eine viel flachere lineare Steigung als eXist.
NoSQL-Systeme möglicherweise auch besser geeignet zu standardisierten medizinischen Informationssystemen aufgrund des besonderen Charakters der Update-Richtlinien von medizinischen Informationen, was die Konsistenz und Effizienz der NoSQL-Datenbanken gespeicherten Daten nicht beeinflussen sollte.
Eine Einschränkung dieses Protokolls ist die fehlende direkte Ergebnisse der verbesserten relationalen Systemen wie Archetyp relational Mapping (ARM) mit den gleichen Daten. Jedoch die Interpolation der Verdoppelung Größe Datenbankergebnisse zu denen in der Literatur vorgestellt und andere veröffentlichten Ergebnisse legt nahe, dass NoSQL-Systeme in vielen Szenarien und zu lösenden Probleme besser geeignet sein könnte. Z. B. NoSQL eignet sich möglicherweise für Dokumenten-basierte Aufgaben wie EHR Extrakte verwendet in klinische Praxis, Ausgabe und Visualisierung oder Situationen, wo das Ziel ist nicht nur, medizinische Abfrageinformationen, sondern auch um die EHR in genau ihrer ursprünglichen Form wiederherzustellen.

Sechs verschiedene Abfragen durchgeführt auf realistische standardisierte EHR-Extrakte, die Informationen über die Probleme des Patienten, einschließlich Namen, erste und letzte Termine und Schweregrad, sind in Tabelle 1dargestellt.
Durchschnittliche Reaktionszeiten der sechs Abfragen in den drei verdoppelt Größe Datenbanken in jeder DBMS sind in Tabellen 2-4gezeigt. Zahlen 1 bis 6 zeigen die gleichen Ergebnisse grafisch (beachten Sie, dass die vertikalen Achsen sehr unterschiedliche Maßstäben in diese Zahlen).
Das starke lineare Verhalten der Rechenaufwand ist offensichtlich in alle Abfragen der NoSQL-Datenbanken, obwohl mit entsprechender Vorsicht aufgrund der relativ geringen Größe der 3 Datensätze verwendet. Die relationale Datenbank ORM zeigt jedoch ein unklares lineares Verhalten. MongoDB-Datenbank hat eine viel flachere Steigung als die eXist-Datenbank.
Ergebnisse durch die verbesserte relationale Systeme diskutiert in der Einleitung, veröffentlicht in der Literatur finden Sie in Tabelle 5. Interpolation MongoDB Ergebnisse aus Tabelle 3 mit ähnlichen Abfragen und Datenbankgrößen ARM Ergebnisse aus Tabelle 5 ist gleich beide Datenbanksysteme im 1. Quartal, sondern begünstigt MongoDB in Q3.
Die Ergebnisse der Experimente Parallelität finden Sie in Tabelle 5 und Tabelle6. MongoDB schlägt MySQL sowohl im Durchsatz und die Antwortzeit. In der Tat MongoDB verhält sich besser in Parallelität als isoliert und steht als beeindruckende Datenbank bei gleichzeitiger Ausführung.
<img alt="Figure 1" class="xfigimg" src="/files/ftp_upload/57439/57439fig1.jpg"> Abbildung 1 : Algorithmische Komplexität der ORM MySQL, MongoDB, und es gibt DBMS für Abfragen Q1 und Q4. Diese Zahl von7 mit Creative Commons-Lizenz (http://creativecommons.org/ licenses/by/4.0/) verändert wurde und zeigt Reaktionszeiten in Sekunden für 5.000, 10.000 und 20.000 Größe EHR Datenbanken für jedes DBMS und Abfragen Q1 und Q4 extrahiert. <a href="//cloudflare.jove.com/files/ftp_upload/57439/57439fig1large.jpg" target="_blank">Bitte klicken Sie hier für eine größere Version dieser Figur.</a>
<img alt="Figure 2" class="xfigimg" src="/files/ftp_upload/57439/57439fig2.jpg"> Abbildung 2 : Algorithmische Komplexität der ORM MySQL DBMS für Abfrage Q2. Diese Abbildung zeigt Reaktionszeiten in Sekunden für 5.000, 10.000 und 20.000 Größe EHR ORM MySQL-Datenbank für die Abfrage Q2 extrahiert. <a href="//cloudflare.jove.com/files/ftp_upload/57439/57439fig2large.jpg" target="_blank">Bitte klicken Sie hier für eine größere Version dieser Figur.</a>
<img alt="Figure 3" class="xfigimg" src="/files/ftp_upload/57439/57439fig3.jpg"> Abbildung 3 : Algorithmische Komplexität von MongoDB und DBMS für Abfragen Q2 und Q5 gibt es. Diese Zahl von7 mit Creative Commons-Lizenz geändert wurde (http://creativecommons.org/licenses/ durch / 4.0) und zeigt Reaktionszeiten in Sekunden für 5.000, 10.000 und 20.000 Größe EHR Extrakte Datenbanken für jedes DBMS und Abfragen Q2 und Q5. <a href="//cloudflare.jove.com/files/ftp_upload/57439/57439fig3large.jpg" target="_blank">Bitte klicken Sie hier für eine größere Version dieser Figur.</a>
<img alt="Figure 4" class="xfigimg" src="/files/ftp_upload/57439/57439fig4.jpg"> Abbildung 4 : Algorithmische Komplexität der ORM MySQL DBMS für Abfragen Q3 und Q5. Zeigt Reaktionszeiten in Sekunden für 5.000, 10.000 und 20.000 Größe EHR Datenbanken für jedes DBMS und Abfragen Q3 und Q5 extrahiert. <a href="//cloudflare.jove.com/files/ftp_upload/57439/57439fig4large.jpg" target="_blank">Bitte klicken Sie hier für eine größere Version dieser Figur.</a>
<img alt="Figure 5" class="xfigimg" src="/files/ftp_upload/57439/57439fig5.jpg"> Abbildung 5: algorithmische Komplexität der eXist und MongoDB DBMS für Abfrage Q3. Diese Zahl von7 mit Creative Commons-Lizenz (http://creativecommons.org/licenses/ durch/4.0 /) verändert wurde und zeigt Reaktionszeiten in Sekunden für 5.000, 10.000 und 20.000 Größe EHR Datenbanken für jedes DBMS und Abfrage Q3 extrahiert. <a href="//cloudflare.jove.com/files/ftp_upload/57439/57439fig5large.jpg" target="_blank">Bitte klicken Sie hier für eine größere Version dieser Figur.</a>
<img alt="Figure 6" class="xfigimg" src="/files/ftp_upload/57439/57439fig6.jpg"> Abbildung 6 : Algorithmische Komplexität der ORM MySQL vorhanden und MongoDB DBMS für Abfragen Q6. Diese Zahl von7 mit Creative Commons-Lizenz (http://creativecommons.org/licenses/ durch/4.0 /) verändert wurde und zeigt Reaktionszeiten in Sekunden für 5.000, 10.000 und 20.000 Größe EHR Datenbanken für jedes DBMS und Abfrage Q6 extrahiert. <a href="//cloudflare.jove.com/files/ftp_upload/57439/57439fig6large.jpg" target="_blank">Bitte klicken Sie hier für eine größere Version dieser Figur.</a>
<table border="1" fo:keep-together.within-page="1" fo:keep-with-next.within-page="always"><tbody>
<tr>
<td></td>
			<td>Abfrage</td>
		</tr>
<tr>
<td>Q1</td>
			<td>Alle Probleme des einzelnen Patienten zu finden</td>
		</tr>
<tr>
<td>Q2</td>
			<td>Finden Sie alle Probleme aller Patienten</td>
		</tr>
<tr>
<td>Q3</td>
			<td>Anfangsdatum, Lösungsdatum und Schweregrad zu finden</td>
		</tr>
<tr>
<td></td>
			<td>ein einzelnes Problem eines einzelnen Patienten</td>
		</tr>
<tr>
<td>Q4</td>
			<td>Anfangsdatum, Lösungsdatum und Schweregrad zu finden</td>
		</tr>
<tr>
<td></td>
			<td>alle Probleme Problem eines einzelnen Patienten</td>
		</tr>
<tr>
<td>Q5</td>
			<td>Anfangsdatum, Lösungsdatum und Schweregrad zu finden</td>
		</tr>
<tr>
<td></td>
			<td>alle Probleme Problem aller Patienten</td>
		</tr>
<tr>
<td>Q6</td>
			<td>Alle Patienten mit Problem "Pharyngitis", zu finden</td>
		</tr>
<tr>
<td></td>
			<td>Datum erste &gt; = 16. Oktober 2007 ", Lösungsdatum</td>
		</tr>
<tr>
<td></td>
			<td>&lt; = 5. Juni 2008 "und Schweregrad"hoch"</td>
		</tr>
</tbody></table>Tabelle 1: die sechs Abfragen durchgeführt auf der relationalen und NoSQL-Datenbanken mit standardisierten EHR Auszüge über die Probleme der Patienten. Diese Tabelle wurde aus7 mit Creative Commons-Lizenz (http://creativecommons.org/ licenses/by/4.0/) geändert und zeigt die sechs Komplexität wächst Abfragen auf die drei Größe wachsenden Datenbanken für jedes DBMS, ausgedrückt in natürlichen durchgeführt Sprache.
<table border="1" fo:keep-together.within-page="1" fo:keep-with-next.within-page="always"><tbody>
<tr>
<td>ORM/MySQL</td>
			<td>5000 Dokumente</td>
			<td>10.000 Dokumente</td>
			<td>20.000 Dokumente</td>
		</tr>
<tr>
<td>1. Quartal (s)</td>
			<td>25.0474</td>
			<td>32.6868</td>
			<td>170.7342</td>
		</tr>
<tr>
<td>2. Quartal (s)</td>
			<td>0,0158</td>
			<td>0.0147</td>
			<td>0.0222</td>
		</tr>
<tr>
<td>3. Quartal (s)</td>
			<td>3.3849</td>
			<td>6.4225</td>
			<td>207.2348</td>
		</tr>
<tr>
<td>4. Quartal (s)</td>
			<td>33.5457</td>
			<td>114.6607</td>
			<td>115.4169</td>
		</tr>
<tr>
<td>Q5 (s)</td>
			<td>9.6393</td>
			<td>74.3767</td>
			<td>29.0993</td>
		</tr>
<tr>
<td>Q6 (s)</td>
			<td>1.4382</td>
			<td>2.4844</td>
			<td>183.4979</td>
		</tr>
<tr>
<td>Datenbankgröße</td>
			<td>4,6 GB</td>
			<td>9,4 GB</td>
			<td>19.4 GB</td>
		</tr>
<tr>
<td>Gesamtextrakte</td>
			<td>5000</td>
			<td>10.000</td>
			<td>20.000</td>
		</tr>
</tbody></table>Tabelle 2: durchschnittliche Reaktionszeiten in Sekunden der sechs Abfragen auf Verdoppelung Größe Datenbanken der ORM MySQL relationalen DBMS. Diese Tabelle zeigt sechs Reaktionszeiten für jede Abfrage für die drei Verdoppelung große Datenbanken mit der ORM MySQL relationalen DBMS und die Speichergröße der drei Datenbanken.
<table border="1" fo:keep-together.within-page="1" fo:keep-with-next.within-page="always"><tbody>
<tr>
<td>MongoDB</td>
			<td>5000 Dokumente</td>
			<td>10.000 Dokumente</td>
			<td>20.000 Dokumente</td>
			<td>Neigung (*10exp(-6))</td>
		</tr>
<tr>
<td>1. Quartal (s)</td>
			<td>0.046</td>
			<td>0.057</td>
			<td>0.1221</td>
			<td>5.07</td>
		</tr>
<tr>
<td>2. Quartal (s)</td>
			<td>34.5181</td>
			<td>68.6945</td>
			<td>136.2329</td>
			<td>6,780.99</td>
		</tr>
<tr>
<td>3. Quartal (s)</td>
			<td>0,048</td>
			<td>0.058</td>
			<td>0.1201</td>
			<td>4.81</td>
		</tr>
<tr>
<td>4. Quartal (s)</td>
			<td>0,052</td>
			<td>0.061</td>
			<td>o.1241</td>
			<td>4.81</td>
		</tr>
<tr>
<td>Q5 (s)</td>
			<td>38.0202</td>
			<td>75.4376</td>
			<td>149.933</td>
			<td>7460.85</td>
		</tr>
<tr>
<td>Q6 (s)</td>
			<td>9.5153</td>
			<td>18.5566</td>
			<td>36.7805</td>
			<td>1,817.68</td>
		</tr>
<tr>
<td>Datenbankgröße</td>
			<td>1,95 GB</td>
			<td>3,95 GB</td>
			<td>7,95 GB</td>
			<td></td>
		</tr>
<tr>
<td>Gesamtextrakte</td>
			<td>5000</td>
			<td>10.000</td>
			<td>20.000</td>
			<td></td>
		</tr>
</tbody></table>Tabelle 3: durchschnittliche Reaktionszeiten in Sekunden der sechs Abfragen auf Verdoppelung Größe Datenbanken MongoDB NoSQL DBMS. Diese Tabelle wurde von7 mit Creative Commons-Lizenz (http://creativecommons.org/ licenses/by/4.0/) geändert und zeigt die sechs Reaktionszeiten der einzelnen Abfragen für die drei Verdoppelung große Datenbanken mit NoSQL MongoDB DBMS und die Speichergröße die drei Datenbanken. Die lineare Steigung der einzelnen Abfragen wird ebenfalls angezeigt.
<table border="1" fo:keep-together.within-page="1" fo:keep-with-next.within-page="always"><tbody>
<tr>
<td>gibt es</td>
			<td>5000 Dokumente</td>
			<td>10.000 Dokumente</td>
			<td>20.000 Dokumente</td>
			<td>Neigung (*10exp(-6))</td>
		</tr>
<tr>
<td>1. Quartal (s)</td>
			<td>0.6608</td>
			<td>3.7834</td>
			<td>7.3022</td>
			<td>442.76</td>
		</tr>
<tr>
<td>2. Quartal (s)</td>
			<td>60.7761</td>
			<td>129.3645</td>
			<td>287.362</td>
			<td>15,105.73</td>
		</tr>
<tr>
<td>3. Quartal (s)</td>
			<td>0.6976</td>
			<td>1,771</td>
			<td>4.1172</td>
			<td>227.96</td>
		</tr>
<tr>
<td>4. Quartal (s)</td>
			<td>0.6445</td>
			<td>3.7604</td>
			<td>7.3216</td>
			<td>445.17</td>
		</tr>
<tr>
<td>Q5 (s)</td>
			<td>145.3373</td>
			<td>291.2502</td>
			<td>597.7216</td>
			<td>30,158.93</td>
		</tr>
<tr>
<td>Q6 (s)</td>
			<td>68.3798</td>
			<td>138.9987</td>
			<td>475.2663</td>
			<td>27,125.82</td>
		</tr>
<tr>
<td>Datenbankgröße</td>
			<td>1,25 GB</td>
			<td>2,54 GB</td>
			<td>5,12 GB</td>
			<td></td>
		</tr>
<tr>
<td>Gesamtextrakte</td>
			<td>5000</td>
			<td>10.000</td>
			<td>20.000</td>
			<td></td>
		</tr>
</tbody></table>Tabelle 4: durchschnittliche Reaktionszeiten in Sekunden der sechs Abfragen auf Verdoppelung Größe Datenbanken der gibt NoSQL DBMS. Diese Tabelle aus7 mit Creative Commons-Lizenz (http://creativecommons.org/ licenses/by/4.0/) verändert wurde und zeigt, dass die sechs Reaktionszeiten der einzelnen Abfragen für die drei Verdoppelung mittlere Datenbanken unter Verwendung der NoSQL DBMS und die Speichergröße des vorhanden die drei Datenbanken. Die lineare Steigung der einzelnen Abfragen wird ebenfalls angezeigt.
<table border="1" fo:keep-together.within-page="1" fo:keep-with-next.within-page="always"><tbody>
<tr>
<td></td>
			<td>ARM-Papier</td>
			<td>ARM (s)</td>
			<td>Knoten + Pfad (s)</td>
		</tr>
<tr>
<td>Q1</td>
			<td>Abfrage 2.1</td>
			<td>0.191</td>
			<td>24.866</td>
		</tr>
<tr>
<td>Q3</td>
			<td>Abfrage 3.1</td>
			<td>0,27</td>
			<td>294.774</td>
		</tr>
<tr>
<td></td>
			<td>Datenbankgröße</td>
			<td>2,90 GB</td>
			<td>43,87 GB</td>
		</tr>
<tr>
<td></td>
			<td>Gesamtextrakte</td>
			<td>29.743</td>
			<td>29.743</td>
		</tr>
</tbody></table>Tabelle 5: durchschnittliche Reaktionszeiten in Sekunden von Abfragen ähnlich Q1 und Q3 der bessere relationale Systeme präsentiert 10 . Diese Tabelle aus7 mit Creative Commons-Lizenz (http://creativecommons.org/ licenses/by/4.0/) verändert wurde und zeigt die beiden die meisten ähnlichen Abfragen zu Q1 und Q3 präsentiert in10 entspricht zwei verbesserte relationale Datenbanksysteme und ihre Reaktionszeiten. Die zwei Datenbankgrößen werden auch angezeigt.
<table border="1" fo:keep-together.within-page="1" fo:keep-with-next.within-page="always"><tbody>
<tr>
<td>ORM/MySQL</td>
			<td>Durchsatz</td>
			<td>Reaktionszeit</td>
		</tr>
<tr>
<td>1. Quartal (s)</td>
			<td>4,711.60</td>
			<td>0.0793</td>
		</tr>
<tr>
<td>3. Quartal (s)</td>
			<td>4,711.60</td>
			<td>0.1558</td>
		</tr>
<tr>
<td>4. Quartal (s)</td>
			<td>4,711.60</td>
			<td>0.9674</td>
		</tr>
</tbody></table>Tabelle 6: durchschnittliche Durchsatz und Reaktion Zeit in Sekunden von Abfragen Q1, Q3 und Q4 der ORM MySQL relationalen DBMS in gleichzeitige Ausführung. Diese Tabelle wurde aus7 mit Creative Commons-Lizenz (http://creativecommons.org/ licenses/by/4.0/) geändert und zeigt den höchsten durchschnittlichen Durchsatz die drei Single-Patienten Abfragen und ihre durchschnittliche Reaktionszeiten in der gleichzeitigen Ausführung-Experiment mit dem ORM MySQL relationale System.
<table border="1" fo:keep-together.within-page="1" fo:keep-with-next.within-page="always"><tbody>
<tr>
<td>MongoDB</td>
			<td>Durchsatz</td>
			<td>Reaktionszeit</td>
		</tr>
<tr>
<td>1. Quartal (s)</td>
			<td>178,672.60</td>
			<td>0,003</td>
		</tr>
<tr>
<td>3. Quartal (s)</td>
			<td>178,672.60</td>
			<td>0.0026</td>
		</tr>
<tr>
<td>4. Quartal (s)</td>
			<td>178,672.60</td>
			<td>0.0034</td>
		</tr>
</tbody></table>Tabelle 7: durchschnittliche Durchsatz und Reaktion Zeit in Sekunden der Abfragen Q1, Q3 und Q4 MongoDB NoSQL DBMS in gleichzeitige Ausführung. Diese Tabelle wurde aus7 mit Creative Commons-Lizenz (http://creativecommons.org/ licenses/by/4.0/) geändert und zeigt den höchsten durchschnittlichen Durchsatz die drei Single-Patienten Abfragen und ihre durchschnittliche Reaktionszeiten in der gleichzeitigen Ausführung-Experiment mit dem MongoDB NoSQL-System.
Ergänzende Abbildung1: der Screenshot zeigt die Software-Bildschirm, um mit dem MySQL-Server verbinden. <a href="//cloudflare.jove.com/files/ftp_upload/57439/Supplementary_Figure_1.png" target="_blank">Klicken Sie bitte hier, um diese Zahl zu downloaden.</a>
Ergänzende Abbildung2: der Screenshot zeigt die SQL-Schnittstelle an dem MySQL-Server, wo wurde die erste SQL-Abfrage geschrieben. <a href="//cloudflare.jove.com/files/ftp_upload/57439/Supplementary_Figure_2.png" target="_blank">Klicken Sie bitte hier, um diese Zahl zu downloaden.</a>
Ergänzende Abbildung 3: The MongoDB 2.6 "localhost" Server gestartet wird, verwenden ein DOS-System-Fenster durch Ausführen von Server-Mongod. <a href="//cloudflare.jove.com/files/ftp_upload/57439/Supplementary_Figure_3.png" target="_blank">Klicken Sie bitte hier, um diese Zahl zu downloaden.</a>
Ergänzende Abbildung 4: der Screenshot zeigt die Abfrage in die Textfelder des Abfrage-Generator geschrieben, wie in Schritten 5.7.1 durch 5.7.4 gezeigt. Der Screenshot zeigt Schritt 5.7.3. <a href="//cloudflare.jove.com/files/ftp_upload/57439/Supplementary_Figure_4.png" target="_blank">Klicken Sie bitte hier, um diese Zahl zu downloaden.</a>
Ergänzende Abbildung 5: der Screenshot zeigt den Schritt 5.7.6. <a href="//cloudflare.jove.com/files/ftp_upload/57439/Supplementary_Figure_5.png" target="_blank">Klicken Sie bitte hier, um diese Zahl zu downloaden.</a>
Ergänzende Abbildung 6: der Screenshot zeigt das Schreiben von der XPath-Abfrage im obere Teil des Dialogfelds. <a href="//cloudflare.jove.com/files/ftp_upload/57439/Supplementary_Figure_6.png" target="_blank">Klicken Sie bitte hier, um diese Zahl zu downloaden.</a>

Diese Studie vergleicht relationale und nicht relationale (NoSQL) standardisierten medizinischen Informationssystemen. Der Rechenaufwand der Antwortzeiten von Abfragen von solchen Datenbankmanagementsysteme (DBMS) wird anhand der Verdoppelung mittlere Datenbanken berechnet. Diese Ergebnisse helfen, die Diskussion über die Angemessenheit der einzelnen Datenbank-Ansätze für verschiedene Szenarien und Probleme.

Erhöhung der Komplexität Abfragen in relationalen (MySQL) und NoSQL (MongoDB und existieren) Größe wachsenden ISO/EN 13606 standardisierte EHR Datenbanken

This research shows a protocol to assess the computational complexity of querying relational and non-relational (NoSQL (not only Structured Query ...

Das übergeordnete Ziel dieses Experiments ist es, die Rechenkomplexität von relationalen und nicht-relationalen, nicht nur strukturierten Abfragesprachen- oder NoSQL-Datenbanksystemen, gemessen an ihren Antwortzeiten, mit der Komplexität von Abfragen zu vergleichen. Diese Methode kann dabei helfen, wichtige Fragen im Bereich der Datenbankmanagementsysteme zu beantworten, z. B. welche Art von Abfragen für welche Art von Datenbanksystemen besser geeignet sind. Der Hauptvorteil dieser Technik besteht darin, dass sie die Antwortzeiten auf Abfragen für doppelte Datenbanken jedes Typs zusammen mit der zu berechnenden Rechenkomplexität vergleicht. Diese Methode kann also Einblicke in MySQL, MongoDB und überschüssige Datenbanksysteme geben.Es kann auch auf andere relationale, dokumentenbasierte und native XML-Systeme wie SQL Server und Base X angewendet werden. Wir haben zum ersten Mal gehört, dass sie dort für diese Methode verwendet werden, wenn wir ein persistentes System für ein elektronisches Patientenaktensystem auswählen müssen. Zum Entwerfen und Ausführen von komplexitätssteigernden Abfragen mit nicht automatisch erstellten Indizes in einer relationalen MySQL-Datenbank. Stellen Sie eine Verbindung zum MySQL-Server her und wählen Sie den Datenbanknamen aus.Wählen Sie die relationale Tabelle im Indexfeld aus und öffnen Sie die Registerkarte Struktur. Wählen Sie die Spalte aus, in der der Index erstellt werden soll, und klicken Sie auf Index. Der SQL-Satz, der den Index bildet, wird angezeigt, gefolgt von einer Meldung, die besagt, dass der Satz erfolgreich erstellt wurde.Um die erste Abfrage auszuführen, wählen Sie den Datenbanknamen aus und öffnen Sie die Registerkarte SQL. Geben Sie den SQL-Code der ersten Abfrage ein, klicken Sie auf Weiter. Der erste Bildschirm der Ergebnisliste wird mit der Meldung über die Ausführungszeit der Abfrage angezeigt.Um komplexitätssteigernde Abfragen und eine nicht-relationale, nicht nur NoSQL-Mongo-Datenbank zu entwerfen und auszuführen, starten Sie die Mongo-Datenbank-Grafikbenutzerschnittstelle und den Mongo-Datenbank-2.6-Server, der das Mongo-Programm aus einem DOS-Systemfenster ausführt. Verbinden Sie die grafische Benutzerschnittstelle der Mongo-Datenbank über Port 27017 mit dem lokalen Hostserver und wählen Sie das Menü Verbinden. Geben Sie einen Namen für die Verbindung ein, geben Sie den Speicherort des lokalen Hosts in das Textfeld des Datenbankservers ein und klicken Sie dann auf Verbinden.Es sollte ein Baum mit den aktuellen Datenbanken angezeigt werden. Erweitern Sie die Mongo-Datenbank. Wählen Sie die gewünschte Sammlung aus und öffnen Sie das Sammlungsmenü.Um die erste Mongo-Datenbankabfrage auszuführen, doppelklicken Sie auf den Abfrage-Generator und die Schaltflächen Abfragefeld. Geben Sie die Felder der Mongo-Datenbankabfrage in das Textfeld "Felder" des Abfragebereichs und den Wert der Abfrage in das Textfeld "Wert" des Abfragebereichs ein. Doppelklicken Sie auf das Projektionsfeld des Abfrage-Generators, und geben Sie die erste Projektion in das Textfeld Projektion ein.Doppelklicken Sie auf das Projektionsfeld, um ein neues Projektionstextfeld hinzuzufügen, und geben Sie die zweite Projektion ein, dann klicken Sie auf Wiedergabe, um die Abfrage auszuführen und den Abfragecode auf der Registerkarte Abfragecode zu visualisieren. Die Details des Ergebnisses werden auf der Registerkarte "Erklären" und "Ergebnisse" angezeigt. Um Abfragen mit zunehmender Komplexität in einer NoSQL EXist-Datenbank zu entwerfen und auszuführen, starten Sie die EXist-Datenbank und öffnen Sie den Java-Admin-Client.Klicken Sie auf, stellen Sie eine Verbindung zur Datenbank her und wählen Sie die Datenbank aus. Klicken Sie auf, Datenbank mit X-Pfad konsultieren. Das Dialogfeld "Konsultieren" wird angezeigt.Führen Sie dann die erste X-Pfad-Abfrage aus. In dieser Tabelle werden sechs verschiedene Abfragen gezeigt, die an realistischen, standardisierten Auszügen aus elektronischen Patientenakten durchgeführt wurden, die Informationen über die Probleme der Patienten enthalten, einschließlich ihrer Namen, Anfangs- und Enddaten und ihres Schweregrads. Die durchschnittliche Antwortzeit der sechs Abfragen und der drei Datenbanken mit doppelter Größe in jedem Datenbankmanagementsystem zeigt ein langes lineares Verhalten der Rechenkomplexität in allen Abfragen der nicht-relationalen Datenbanken, das in der Analyse relationaler objektrelationaler Mapping-Datenbanken nicht beobachtet wird.Das Interpolieren von Mongo-Datenbankergebnissen mit ähnlichen Abfragen und Datenbankgrößen von relationalen Zuordnungsergebnissen des Archetyps erzeugt in beiden Datenbanksystemen gleiche Ergebnisse für die erste Abfrage, jedoch mit günstigeren Ergebnissen, die unter Verwendung der Mongo-Datenbank für die dritte Abfrage bestimmt werden. In den Parallelitätsexperimenten ist die Mongo-Datenbank der MySQl-Datenbank sowohl in Bezug auf den Durchsatz als auch auf die Antwortzeiten vorzuziehen, wobei sich die Mongo-Datenbank bei Parallelität besser verhält als bei einer Isolation und bei gleichzeitiger Ausführung eine beeindruckende Datenbank darstellt. Nun, ich dachte, es ist wichtig, daran zu denken, alle Server lokal auf denselben Computern zu verwalten, auf denen der Client die Abfragen ausführt.Nach diesem Verfahren können andere Methoden, wie z. B. die Verwendung anderer Arten von Datenbanksystemen, durchgeführt werden, um zusätzliche Fragen zu beantworten, z. B. ob eine Art von Datenbank sowohl bei einzelnen als auch bei allen Patientenanfragen existieren und gewinnen kann. Nach ihrer Entwicklung ebnete diese Technik den Weg für Forscher auf dem Gebiet der algorithmischen Komplexität, vergleichende Datenbankleistungen in verschiedenen Arten von Datenbanksystemen zu untersuchen. Nachdem Sie sich dieses Video angesehen haben, sollten Sie ein gutes Verständnis dafür haben, wie Sie komplexitätssteigernde Abfragen in Datenbanken mit wachsender Größe von Datenbanksystemen sehr unterschiedlicher Art ausführen können.

executing-complexity-increasing-queries-relational-mysql-nosql

Research

Forschung

JoVE Journal

Medicine

Medizin

Wir präsentieren Ihnen ein Protokoll und zugehörigen Programmcode sowie Metadaten Proben, eine Cloud-basierte automatische Identifikation von Phrasen-Kategorie Verband, einzigartige Konzepte in ausgewählten Knowledge Benutzerdomäne in der biomedizinischen Literatur zu unterstützen. Die Satz-Kategorie Assoziation quantifiziert durch dieses Protokoll kann eingehende Analyse im Bereich ausgewählten Knowledge erleichtern.

Cloud-basierte Phrase Mining und Analyse von Benutzer-definierten Satz-Kategorie Assoziation in biomedizinischen Veröffentlichungen

Viele Forscher generieren "mittelgroße", datenarme und mehrdimensionale Daten, die mit Datenbanken und nicht mit Tabellenkalkulationen effizienter verwaltet werden können. Hier bieten wir einen konzeptionellen Überblick über Datenbanken, einschließlich der Visualisierung mehrdimensionaler Daten, verknüpfen von Tabellen in relationalen Datenbankstrukturen, Der Zuordnung halbautomatischer Datenpipelines und der Verwendung der Datenbank zur Klärung der Bedeutung von Daten.

Datenbanken zur effizienten Verwaltung von mittelgroßen, niedrigen Geschwindigkeiten und multidimensionalen Daten im Tissue Engineering

TBase kombiniert eine elektronische Gesundheitsakte mit einer innovativen Forschungsdatenbank für Nierentransplantatempfänger. TBase basiert auf einer In-Memory-Datenbankplattform, die mit verschiedenen Krankenhaussystemen verbunden ist und für die regelmäßige ambulante Versorgung verwendet wird. Es integriert automatisch alle relevanten klinischen Daten, einschließlich transplantationsspezifischer Daten, und erstellt eine einzigartige Forschungsdatenbank.

TBase - eine integrierte elektronische Gesundheitsakte und Forschungsdatenbank für Nierentransplantationsempfänger

gP2S ist eine Webanwendung zur Verfolgung von KryoEM-Experimenten. Die Hauptfunktionen werden ebenso beschrieben wie die Schritte, die zum Installieren und Konfigurieren der Anwendung erforderlich sind. Nach der Konfiguration ermöglicht die Anwendung die genaue Aufzeichnung von Metadaten, die mit negativen Flecken und KryoEM-Experimenten verbunden sind.

gP2S, ein Informationsmanagementsystem für KryoEM-Experimente

Postoperativen Ileus (POI) ist eine Komplikation der Bauchchirurgie führt zu einer erhöhten Morbidität und einen längeren Krankenhausaufenthalt. Da prophylaktische oder therapeutische Strategien fehlen verstärkte Forschung notwendig ist. Deshalb haben wir eine standardisierte und machbar Mausmodell, um die Pathophysiologie von POI zu untersuchen und mögliche therapeutische Optionen zu studieren.

Functional Assessment of Darmmotilität und Darmwand Entzündung in Nagetiere: Analysen in einem standardisierten Modell der intestinalen Manipulation

Läsion Explorer (LE) ist eine regional entwickelt, um Hirngewebe und subkortikalen Hyper Läsion Volumetrie von strukturellen MRT der Alzheimer-Krankheit und normalen älteren erhalten halbautomatisch, Bildverarbeitungs-Pipeline. Um ein hohes Maß an Genauigkeit und Zuverlässigkeit zu gewährleisten, ist das folgende eine Video-geführt, standardisiertes Protokoll für LE manuellen Verfahren.

Läsion Explorer: Ein Video-geführt, standardisiertes Protokoll für genaue und zuverlässige MRI-abgeleiteten Volumetrics in der Alzheimer-Krankheit und Normale Ältere

Wir beschreiben einen Innen, portable, standardisierte Kurs, der verwendet werden kann, Hindernisvermeidung bei Personen, die ultra Vision zu bewerten. Der Kurs ist relativ kostengünstig, einfach zu verwalten und hat sich gezeigt, zuverlässig und reproduzierbar sein.

Eine standardisierte Hindernisparcours für die Bewertung der visuellen Funktion in Ultra Low Vision and Artificial Vision-

Dieses Protokoll beschreibt eine Osteosynthesetechnik, die einen intramedullären Verriegelungsnagel zur standardisierten Fixierung von Femurosteotomien verwendet, die zur Analyse der normalen und defekten Knochenheilung bei Mäusen verwendet werden kann.

Eine intramedulläre Verriegelungsnagel für Standardisierte Fixierung von Femur Osteotomien zur Analyse von normalen und Defekte Knochenheilung bei Mäusen

Hier präsentieren wir Ihnen ein standardisiertes Protokoll um die nasale Potentialdifferenz (NPD) zu messen. Zystische Fibrose transmembranen Leitwert Regulator (CFTR) und epitheliale Natrium-Kanal (ENaC)-Funktion werden ausgewertet von der Änderung in der Spannung über die nasale Epithel nach Superfusion von Lösungen, die Ionen-Kanal Aktivität ändern vorausgesetzt, eine Ergebnis Maßnahme.

Standardisierte Messung der Nasenschleimhaut berührt Potential Unterschied (NPD)

Literaturdatenbanken werden häufig verwendet, um Publikationen in einem bestimmten Fach, einer Disziplin, einem Land oder einer Region der Welt zu bewerten, eine Praxis, die als bibliometrische Analyse bekannt ist. Das aktuelle Protokoll beschreibt, wie PubMed, Scopus und Web of Science-Datenbanken für bibliometrische Analysen verwendet werden.

Vergleichen der bibliometrischen Analyse mit PubMed-, Scopus- und Web of Science-Datenbanken

Erfahren Sie, wie Sie die Rechenkomplexität von relationalen und NoSQL-Datenbanksystemen vergleichen. Diese Methode analysiert Antwortzeiten komplexer Abfragen in MySQL und MongoDB bei wachsenden Datenbankgrößen.

Erhöhung der Komplexität Abfragen in relationalen (MySQL) und NoSQL (MongoDB und existieren) Größe wachsenden ISO/EN 13606 standardisierte EHR Datenbanken (Video) | JoVE Journal

Erhöhung der Komplexität Abfragen in relationalen (MySQL) und NoSQL (MongoDB und existieren) Größe wachsenden ISO/EN 13606 standardisierte EHR Datenbanken

Weitere Videos entdecken