bachelor-thesis/chapters/thesis/chapter06.tex

243 lines
18 KiB
TeX
Raw Normal View History

2024-07-31 22:12:53 +02:00
% !TeX root = ../../thesis.tex
\chapter{Evaluierung}
\label{ch:evaluation}
2024-09-13 13:21:22 +02:00
Nun werden die durchgeführten Anpassungen anhand ihre Effektivität betrachtet und unter welchen äußeren Einflüssen
diese eine Optimierung darstellen. Weiterhin werden die Nachteile der Anpassungen überprüft und und bei der Betrachtung
2024-09-27 20:58:59 +02:00
der Effektivität mit beachtet.
2024-09-13 13:21:22 +02:00
2024-09-28 13:33:24 +02:00
Es wurden die Konfigurationen der Caches von OpenJPA, \ac{JPA} und \ac{EJB} aktiviert und deren Auswirkung betrachtet. Bei den
Caches, bei denen eine Größe angebbar ist, wurde zusätzlich mit der Anzahl variiert, um zu ermitteln, in welchem Umfang
2024-09-28 16:16:31 +02:00
sich diese auswirken. Des Weiteren wird die Art der Programmierung für die Abfragen betrachtet, ob signifikante
2024-09-22 19:32:07 +02:00
Unterschiede in der Performance und der Abarbeitung erkennbar sind. Als weiteren Punkt werden die Abfragen an die
2024-09-28 13:33:24 +02:00
Datenbank untersucht, um zu ermitteln, ob diese durch Umstellung verbessert werden können. Abschließend werden die
2024-09-22 19:32:07 +02:00
\textit{Materialized View} verwendet, um zu ermitteln, ob durch einen vorverdichteten und aufbereiteten Datenbestand
die Abfragen beschleunigt werden können.
2024-09-13 13:21:22 +02:00
\section{Nutzerumfrage}
2024-09-15 00:47:49 +02:00
\label{sec:evaluation:user-survey}
2024-09-13 13:21:22 +02:00
2024-09-28 16:16:31 +02:00
Zusätzlich war noch eine Befragung unter den Benutzern und den Entwicklern geplant. Auf Grund dessen, dass nur fünf
2024-09-28 13:33:24 +02:00
Personen zur Verfügung stehen, ist dies nicht zielführend. Daher ist die einzig sinnvolle Alternative, welche gewählt
2024-09-22 19:32:07 +02:00
wurde, ein rein technischer Ansatz.
2024-09-13 13:21:22 +02:00
2024-09-24 00:08:33 +02:00
\section{Umgestalten der Datenbanktabellen}
\label{sec:evaluation:new-table}
2024-09-28 13:33:24 +02:00
Hierfür wurde die aktuelle Datenstruktur untersucht, um zu überprüfen, ob eine Umgestaltung der Tabelle eine Verbesserung
2024-09-28 16:16:31 +02:00
bringt. Die typische Optimierung ist die Normalisierung der Tabellenstruktur. Die Tabellenstruktur ist aktuell
2024-09-24 00:08:33 +02:00
schon normalisiert, daher kann hier nichts weiter optimiert werden.
Eine weitere Optimierungsstrategie besteht in der Denormalisierung, um sich die Verknüpfungen der Tabellen zu sparen.
Dies ist in diesem Fall nicht anwendbar, da nicht nur 1:n Beziehungen vorhanden sind, sondern auch auch n:m Beziehungen.
2024-09-28 16:16:31 +02:00
Dadurch würde sich die Anzahl der Dokumentenliste erhöhen.
2024-09-24 00:08:33 +02:00
2024-09-13 13:21:22 +02:00
\section{Statische Webseiten}
\label{sec:evaluation:static-website}
2024-09-28 16:16:31 +02:00
Eine Umstellung der Dokumentenliste in eine statische Webseite würde die Zugriffszeiten sehr verkürzen. Darüber hinaus
2024-09-26 23:43:15 +02:00
funktionieren in statischen Webseiten aber keine Suchen oder Sortierungen. Die Sortierung könnte durch das Erstellen
2024-09-22 19:32:07 +02:00
von statischen Seiten aller Möglichkeiten der Sortierung emuliert werden, diese würde den notwendigen Speicherbedarf der
2024-09-13 13:21:22 +02:00
Webseite vervielfachen. Für die Suchanfragen ist dies nicht mehr möglich, da nicht alle Suchanfragen vorher definiert
werden können.
2024-09-28 16:16:31 +02:00
Die Umstellung der Suche auf Client"=Basis wäre noch eine Möglichkeit, dafür benötigen die Clients entsprechende
Leistung und es muss eine Referenzdatei erstellt werden, welche alle Informationen über die Dokumente beinhaltet, nach
2024-09-22 19:32:07 +02:00
welcher gesucht werden kann.
2024-09-13 13:21:22 +02:00
Daher ist eine Umstellung auf statische Webseiten nicht sinnvoll.
\section{Client basierte Webseiten}
\label{sec:evaluation:client-side-rendering}
Als weitere Möglichkeit könnte man die Webseite so umbauen, dass die Daten erst im Nachgang über eine AJAX-Anfrage
2024-09-22 19:32:07 +02:00
ermittelt und die Sortierung und Aufteilung im Client durchgeführt wird. Hierbei wird allerdings je nach Datenmenge ein
großer Speicher am Client benötigt und der Großteil der benötigten Rechenleistung zu dem Client verschoben.
2024-09-13 13:21:22 +02:00
Dies wiederrum ist ein Vorteil für den Serverbetreiber, da durch die Verschiebung weniger Rechenleistung am Server
2024-09-22 19:32:07 +02:00
benötigt wird. Gleichzeitig würde man wiederrum schwächere Clients, wie Smartphones, aussperren, da bei diesem
2024-09-13 13:21:22 +02:00
die notwendige Rechenleistung fehlt, um die Webseite in annehmbarer Zeit darzustellen.
2024-09-24 23:56:07 +02:00
\section{Serverseitige Paginierung}
\label{sec:evaluation:server-side-paging}
2024-09-28 13:33:24 +02:00
Die Aufteilung eines großen Datenbestandes in mehrere einzelne Seiten ist eine der wenigen Optimierungsmöglichkeiten in
der \ac{JSF}"=Ebene. Dieser Einbau optimiert direkt an mehreren Stellen, dazu gehört die kleinere Datenmenge, die vom
Datenbankserver geladen wird. Ebenso wird entsprechend weniger Zeit benötigt, um die View zu erstellen,
gleichzeitig wird die übertragene Datenmenge an den Client reduziert. Dadurch benötigt die Seite auf dem Client weniger
2024-09-26 23:43:15 +02:00
Zeit zum rendern.
2024-09-24 23:56:07 +02:00
Da das Paging für den Fall der Dokumentenliste implementiert ist, gibt es hier keine weiteren offensichtliche
Optimierungsmöglichkeiten.
2024-09-22 19:32:07 +02:00
\section{Caching im OpenJPA}
\label{sec:evaluation:caching-jpa}
2024-09-13 13:21:22 +02:00
2024-09-27 20:58:59 +02:00
Bei der Verwendung des OpenJPA"=Caches gibt es einige Verbesserungen bei der Geschwindigkeit zu sehen. Die Höhe der
2024-09-13 13:21:22 +02:00
Optimierungen hängt stark von der gewählten Cache"=Größe und der aufgerufenen Webseiten ab. Solange die Anfragen sich
auf die gleichen Objekte beziehen und diese alle im Cache hinterlegt werden können, fällt die Optimierung entsprechend
2024-09-22 19:32:07 +02:00
hoch aus. Sobald bei den Anfragen aber häufig die zu ermittelnden Objekte sich unterscheiden und alte Objekte wieder
2024-09-13 13:21:22 +02:00
aus dem Cache entfernt werden, fällt die Performance"=Verbesserung immer geringer aus.
2024-09-15 00:47:49 +02:00
Das Entfernen der Objekte kann zwar umgangen werden, indem die häufig abgefragten Objekte gepinnt werden, was aber
2024-09-28 16:16:31 +02:00
den Speicherbedarf noch weiter erhöht, da diese Objekte nicht in die Zählung der Cache"=Objekte betrachtet werden.
2024-09-27 20:58:59 +02:00
Als größten Nachteil des Caches ist zu nennen, dass die notwendige Speichermenge ständig zur Verfügung gestellt
werden muss. Damit ist immer ein gewisser Grundbedarf notwendig, da sich der Speicher bis zum eingestellten
2024-09-26 23:43:15 +02:00
Grenzwert aufbaut und dann nicht mehr entleert wird. Gerade bei kleiner dimensionierten Servern stellt dies ein
2024-09-22 19:32:07 +02:00
größeres Problem dar, da nun weniger Speicher für die anderen laufenden Programme, wie dem Datenbankmanagementsystem,
2024-09-13 13:21:22 +02:00
zur Verfügung steht.
Hierbei ist aber noch zu beachten, dass die Optimierung durch den Cache nicht die Laufzeit der Abfragen in der Datenbank
2024-09-22 19:32:07 +02:00
enorm verringert hat, sondern die Laufzeit beim Erstellen der Objekte im \textit{OpenJPA}"=Framework. Dies sieht man
2024-09-28 16:16:31 +02:00
sehr gut schon bei der ersten Messung, wie in \autoref{tbl:measure-ojpa-active}. Hierbei wird die Laufzeit in der
2024-09-22 19:32:07 +02:00
Datenbank im Schnitt um circa 5 ms reduziert, allerdings wird die komplette Webseite fast 100 ms schneller an den Client
ausgeliefert. Dies ist nur dadurch erklärbar, dass das Erstellen und mit den Datenwerte zu befüllen mehr Zeit kostet,
2024-09-13 13:21:22 +02:00
als das Objekt aus dem Cache zu ermitteln und zurückzugeben.
Daher ist die Verwendung des OpenJPA"=Cache nur in Verbindung mit einem größer dimensionierten Server gut verwendbar,
wenn der Großteil der Objekte im Cache gehalten werden kann. Bei Bedarf sollten die häufig frequentierten Objekte
explizit im Cache aufgenommen und angepinnt werden.
2024-09-22 19:32:07 +02:00
\section{Cached Queries}
\label{sec:evaluation:cached-queries}
2024-09-13 13:21:22 +02:00
2024-09-28 16:16:31 +02:00
Die Optimierung über die gespeicherten Anfragen brachte keine Verbesserung hervor. Dies ist dadurch erklärbar, dass %TODO Der Satz ist schwer zu lesen, hat sie gesagt
2024-09-22 19:32:07 +02:00
für die diese Art nur Anfragen verwendet werden, die keinerlei Bedingungen besitzen. In diesem Fall sind in der Tabelle
noch nicht freigegebene und ungültige Datensätze gespeichert, daher müssen diese vor dem Übertragen herausgefiltert
2024-09-27 20:58:59 +02:00
werden. Aus diesem Grund werden die Anfragen in diesem Cache nicht gespeichert.
2024-09-13 13:21:22 +02:00
2024-09-22 19:32:07 +02:00
Dadurch ist dieser Cache für eine Performance"=Verbesserung in dem Fall der Dokumentenliste nicht anwendbar.
2024-09-13 13:21:22 +02:00
2024-09-22 19:32:07 +02:00
\section{Caching mit Ehcache}
\label{sec:evaluation:ehcache}
2024-09-21 15:05:19 +02:00
2024-09-28 16:16:31 +02:00
Mit dem Ehcache konnte eine Verbesserung in der Performance erzielt werden. Im Vergleich zum Cache von OpenJPA ist
2024-09-21 15:05:19 +02:00
die Verbesserung sehr ähnlich. Die Standardwerte dieses Caches sind gut vordefiniert, es wird für den aktuellen Fall
2024-09-28 13:33:24 +02:00
keine Anpassung benötigt, um eine gute Performance zu bekommen. Hierbei ist natürlich das gleiche Problem wie in anderen
Caches, dass beim Erreichen der Grenzen alte Objekte entfernt werden müssen.
2024-09-21 15:05:19 +02:00
2024-09-28 13:33:24 +02:00
Nach aktueller Beobachtung scheint die Verwaltung im Ehcache effizienter gestaltet zu sein als die des OpenJPA"=Caches.
2024-09-21 15:05:19 +02:00
Im Falle des Ehcache ist die interne Verwaltung auf mehrere Caches aufgebaut, dies ist daran zu sehen, dass in der
Standardkonfiguration jede Klasse ihren eigenen Cache besitzt. Diese können einzeln konfiguriert und diagnostiziert
werden, um diese genau auf die jeweiligen Bedürfnisse der Objekte anzupassen.
2024-09-28 13:33:24 +02:00
Im Falle der Verwendung des Caches ist auch hier gut zu sehen, dass der Speicheranstieg bei der Verwendung des Caches
2024-09-24 00:08:33 +02:00
sehr gering ist, dies deutet ebenfalls darauf hin, dass die Speicherproblematik beim Erstellen von Objekten innerhalb
des OpenJPA Framework liegen muss.
2024-09-21 15:05:19 +02:00
2024-09-28 13:33:24 +02:00
Durch die effizientere Verwendung des Speichers, ist der Ehcache die bessere Alternative zum OpenJPA"=Cache. Dieser ist
2024-09-21 15:05:19 +02:00
auch schon für kleinere Serverkonfigurationen gut verwendbar. Hierbei ist nur abzuwägen, mit welcher Größe der Cache
2024-09-26 23:43:15 +02:00
bereitgestellt werden kann, dies hängt direkt vom verfügbaren Arbeitsspeicher ab.
2024-09-21 15:05:19 +02:00
2024-09-22 19:32:07 +02:00
\section{Caching in EJB}
\label{sec:evaluation:ejb}
2024-09-18 00:19:25 +02:00
2024-09-28 13:33:24 +02:00
Bei der Erweiterung des \ac{EJB} konnte keine Verbesserung in der Performance festgestellt werden. Der Grund hierfür ist, dass
der \ac{EJB}"=Cache die Provider beinhaltet, aber keine Daten"=Objekte. Dadurch kann der Cache das Ermitteln der Objekte
2024-09-21 15:05:19 +02:00
nicht optimieren.
2024-09-28 13:33:24 +02:00
Auf Grund dessen ist der \ac{EJB}"=Cache nicht für eine Performance"=Verbesserung nutzbar.
2024-09-13 13:21:22 +02:00
2024-09-22 19:32:07 +02:00
\section{Abfragen mit JPQL und Criteria API}
\label{sec:evaluation:jpal-capi}
2024-09-13 13:21:22 +02:00
2024-09-22 19:32:07 +02:00
Bei dem Vergleich zwischen den zwei Abfragemöglichkeiten der \ac{JPQL} und der Criteria API konnte in der Art der
Abfragen kein Unterschied festgestellt werden. Die Abfragen der beiden Systeme sind auf Datenbankseite komplett
2024-09-28 16:16:31 +02:00
identisch. Auch in der Übertragung der Daten aus der Datenbank in die Java"=Objekte konnte kein Unterschied in der
2024-09-22 19:32:07 +02:00
Art und Geschwindigkeit festgestellt werden.
2024-09-13 13:21:22 +02:00
2024-09-28 13:33:24 +02:00
Ebenfalls sind die Möglichkeiten über der Optimierung über Hints identisch. In beiden Fällen haben die meisten Hints
keinen nennenswerten Einfluss auf die Laufzeit der Abfragen und Übertragung in die Java"=Objekte. Das sinnvolle Setzen
2024-09-13 13:21:22 +02:00
von OptimizeResultCount, der FetchSize sowie der FetchBatchSize hilft dem Framework die Bearbeitung der Anfrage
effizient abzuarbeiten, konnte aber in den gemessenen Laufzeiten nicht verifiziert werden.
2024-09-27 20:58:59 +02:00
Anders verhält sich dies mit der Einstellung für \texttt{EagerFetchMode}, welche definiert, wie die Daten für abhängige Klassen
2024-09-26 23:43:15 +02:00
ermittelt werden. Bei der Umstellung auf \textit{parallel} konnte für die Ermittlung der Dokumente einiges an Performance gewonnen
2024-09-13 13:21:22 +02:00
werden. Das liegt daran, dass nun für die abhängigen Objekte, wie den Koautoren, nicht pro Dokument eine Anfrage an die
Datenbank gestellt wird, sondern es werden alle Koautoren für die ermittelten Dokumente auf einmal ermittelt. Die
Zuordnung der Koautoren zu dem Dokument wird dann nun im Framework und nicht mehr durch die Datenbank durchgeführt.
2024-09-22 19:32:07 +02:00
Diese Abarbeitung reduziert viele einzelne Abfragen und somit auch den entsprechend Overhead im Framework.
2024-09-13 13:21:22 +02:00
2024-09-27 20:58:59 +02:00
Folglich ist die Entscheidung der Technik für die Performance irrelevant und es kann das genutzt werden, was für
2024-09-22 19:32:07 +02:00
jeweiligen Einsatzzweck besser beziehungsweise einfacher zu programmieren ist. Das Setzen der richtigen Hints wiederrum
ist in beiden Fällen äußerst wichtig. Explizit bei der EagerFetchMode muss vorher darüber nachgedacht werden, wie viele
2024-09-13 13:21:22 +02:00
abhängige Objekttypen es zu dieser Klasse gibt, welche dazu geladen werden sollen und von welcher Anzahl an Objekte
2024-09-26 23:43:15 +02:00
ausgegangen werden kann. Gerade bei einer größeren Anzahl lohnt es sich den Hint auf \textit{parallel} zu setzen.
2024-09-28 16:16:31 +02:00
Gleiches gilt bei dem Hint \texttt{SubclassFetchMode}, dieser steuert dimensionierte Abfragen im Falle von
abgeleiteten Klassen.
2024-09-13 13:21:22 +02:00
2024-09-22 19:32:07 +02:00
\section{Materialized View}
\label{sec:evaluation:materialized-view}
2024-09-21 15:05:19 +02:00
2024-09-28 13:33:24 +02:00
Die Idee der \textit{Materialized View} ist simple, aber sehr effizient, gerade für einen Datenbestand, welcher häufig gelesen
2024-09-21 15:05:19 +02:00
und selten verändert wird. Hierbei werden komplexe Abfragen einmalig ausgeführt und das Ergebnis intern
2024-09-28 13:33:24 +02:00
zwischengespeichert. Für alle weiteren Aufrufe werden die Daten nun aus dem Zwischenspeicher gelesen und dem Aufrufer
2024-09-26 23:43:15 +02:00
zurückgegeben. Der größte Nachteil der \textit{Materialized View} ist, dass bei einer Änderung an den Quelldaten die
2024-09-22 19:32:07 +02:00
Sicht aktualisiert werden muss. Dieser Nachteil kommt in einer Briefedition nicht zum tragen, da in dieser nach dem die
2024-09-28 13:33:24 +02:00
Briefe einmalig eingepflegt wurden, nur noch selten Änderungen erfahren. Der Recherche zu dem Datenbestand wird die
2024-09-27 20:58:59 +02:00
meiste Zeit gewidmet.
2024-09-22 00:51:24 +02:00
2024-09-22 19:32:07 +02:00
Ein weiterer Nachteil der \textit{Materialized View} ist die doppelte Speicherung der Daten, da die Daten für die Sicht
wie bei einer Tabelle auf der Festplatte gespeichert sind. Dieser Nachteil ist in der Dokumentliste vernachlässigbar,
2024-09-22 00:51:24 +02:00
da sich die Daten auf die Meta"=Daten der Dokumente, wie Namen, Datum und Autoren beschränkt. Der größte Datenbestand,
die Faksimile, sind nicht in dieser Sicht enthalten und werden erst beim Anzeigen einer Kommunikation ermittelt.
Zusätzlich ist zu beachten, dass bei der Verwendung eines Caches die Daten ebenfalls doppelt gehalten werden und in
den meisten Fällen im Arbeitsspeicher gehalten werden.
2024-09-26 23:43:15 +02:00
Eine weitere Optimierung, welche durch die \textit{Materialized View} entstanden ist, ist die direkte Integration der
2024-09-22 19:32:07 +02:00
Autoren, der Koautoren und der Adressen im \textit{Json}"=Format. Durch diese aus dem Wedekind-Projekt übernommene Idee
2024-09-22 00:51:24 +02:00
konnten schon viele zusätzliche Abfragen eingespart werden, da diese nicht mehr durch OpenJPA nach der Hauptabfragen
für jede Datenzeile einzeln durchgeführt wird.
2024-09-26 23:43:15 +02:00
Zusätzlich konnte dies nochmal beschleunigt werden, in dem das Parsen der \textit{Json}"=Daten vom Server auf den Client
2024-09-27 20:58:59 +02:00
verlagert wurde. Hiermit konnte ein Teil der Last vom Server genommen und die gesamte Ausführungszeit nochmals
2024-09-28 13:33:24 +02:00
optimiert werden. Die Wandlung der Daten in \textit{\ac{HTML}}"=Objekte ist eine Kernkompetenz von JavaScript und damit auch bei
2024-09-24 00:08:33 +02:00
schwächeren Clients in kurzer Zeit durchführbar.
2024-09-22 00:51:24 +02:00
2024-09-28 13:33:24 +02:00
Als weiteren Punkt ist anzumerken, dass der Speicherbedarf des Webserver relativ konstant bleibt, ohne dass ein Cache
verwendet wird. Der größte Unterschied zur Standardimplementierung ist die Verwendung von eigenen Codes, um die Objekte
2024-09-24 23:56:07 +02:00
zu erstellen und zu befüllen und es nicht durch das OpenJPA"=Framework durchführen zu lassen.
2024-09-27 20:58:59 +02:00
Dies legt den Schluss nahe, dass Probleme in der Speicherverwaltung der Objekte im OpenJPA"=Framework existieren.
2024-09-24 23:56:07 +02:00
2024-09-26 23:43:15 +02:00
Zusammenfassend ist zu sagen, dass die \textit{Materialized View} eine gute Wahl ist, um die Listendarstellungen
2024-09-22 00:51:24 +02:00
zu optimieren. Mit dieser Technik können zum einen die Abfragezeiten optimiert werden, wodurch gleichzeit die
Ressourcennutzung verringert wird. Zum anderen wird die Ressourcennutzung des Servers noch weiter reduziert, wenn die
\textit{Json}"=Verarbeitung an den Client ausgelagert wird.
2024-09-26 23:43:15 +02:00
Durch die doppelte Datenhaltung muss bei jeder Abfrage geprüft werden, ob die Nutzung der \textit{Materialized View} sinnvoll
2024-09-22 00:51:24 +02:00
ist oder direkt auf denormalisierte Daten umgestellt werden sollte, weil der zusätzliche benötigte Speicher größer als
die Quelle ist.
2024-09-28 13:33:24 +02:00
Im Gegensatz zu einer reinen Cache"=Lösung, die die gleiche Optimierung besitzt, ist diese vorzuziehen, da in den
2024-09-22 00:51:24 +02:00
meisten Fällen der Festplattenspeicher kostengünstiger als der Arbeitsspeicher ist. Zusätzlich ist der Cache begrenzt
2024-09-27 20:58:59 +02:00
und wirft alte Objekte heraus. Wenn dieser voll ist wird ein Zugriff auf diese entfernten Objekte
2024-09-26 23:43:15 +02:00
langsamer. Somit ist die Optimierung über die \textit{Materialized View} auf lange Zeit gesehen kostengünstiger und
2024-09-22 00:51:24 +02:00
stabiler.
2024-09-21 15:05:19 +02:00
2024-09-22 19:32:07 +02:00
\section{Optimierung der Abfrage}
\label{sec:evaluation:optimize-query}
2024-09-21 15:05:19 +02:00
2024-09-28 13:33:24 +02:00
Die Abfragen, die durch die OpenJPA an die Datenbank abgesetzt werden, sind meist durch ihre Einfachheit gut optimiert.
2024-09-27 20:58:59 +02:00
Nur durch Sortierung oder Bedingungen können die Abfragen langsamer werden. Diese können durch entsprechende Indexe
2024-09-22 00:51:24 +02:00
gelöst werden. Bei größeren Abfragen mit mehreren Joins kann durch geschicktes umstellen die Performance verbessert
2024-09-26 23:43:15 +02:00
werden. Die Hauptabfrage der Dokumentenliste besteht aus mehreren Joins und diese wurde explizit untersucht.
2024-09-22 00:51:24 +02:00
Der Abfrageplan der Hauptabfrage wurde visuell untersucht und zeigt, dass das Hauptproblem die nicht eingeschränkte
2024-09-27 20:58:59 +02:00
Datenmenge der Haupttabelle \textit{document} ist. Dadurch werden die anderen Tabellen komplett geladen
anstatt die Zugriffe über die vorhandenen Indexe durchzuführen, obwohl die Bedingungen über die Primary Key definiert
sind. Für den PostgreSQL
2024-09-22 19:32:07 +02:00
ist es laut Berechnung kostengünstiger mit einem \textit{Seq Scan}, was einem kompletten Durchlaufen der Tabelle
entspricht, zu arbeiten.
2024-09-22 00:51:24 +02:00
Um dies zu optimieren, wurde über eine \textit{Common Table Expression} zuerst die eingeschränkten Datenzeilen
2024-09-27 20:58:59 +02:00
ermittelt, dieser mit der Haupttabelle verknüpft und nun die anderen Tabellen dazugenommen. Hierdurch konnte die
2024-09-22 19:32:07 +02:00
Zeilenanzahl während der Verarbeitung enorm verringert werden, wodurch einige der Verknüpfungen auf Indexzugriffe
2024-09-27 20:58:59 +02:00
umgestellt wurden. Durch die Umstellung konnte die Abfragezeit um mehr als das dreifache reduziert werden.
2024-09-22 19:32:07 +02:00
2024-09-28 16:16:31 +02:00
Mit dieser Art der Umstellung können Abfragen optimiert werden, die für das Paging verwendet werden und die Abfrage aus
2024-09-26 23:43:15 +02:00
mehrere Tabellen besteht. Das Wichtigste hierbei ist, dass die Bedingungen und die Sortierkriterien auf der
2024-09-22 19:32:07 +02:00
Haupttabelle arbeiten. Wenn dem nicht so ist, müssen Joins in die \textit{Common Table Expression} mit aufgenommen
werden und damit funktioniert die Reduzierung der Datensätze nicht mehr. Bei der Selektion einer Tabelle hat diese Art
2024-09-26 23:43:15 +02:00
der Optimierung keine Auswirkung, hier hilft nur das geschickte Setzen von Indexen auf die Tabelle, welche die
2024-09-22 19:32:07 +02:00
Bedingungen und die Sortierkriterien beinhalten. Dies wurde mit der Untersuchung der Abfrage auf die
\textit{Materialized View} bestätigt.