Menü
Dieser Beitrag zeigt verschiedene Möglichkeiten zur Abfrage und Verarbeitung großer Datenmengen mit Hilfe der CosmosDb und ASP.Net Core.
Pagination ist ein UI Pattern, welches eingesetzt wird, wenn großen Datenmengen performant und übersichtlich dargestellt werden sollen.
CosmosDb unterstützt hierfür die OFFSET-LIMIT-Bedingung, mit der wir eine definierte Anzahl an Ergebnissen einer Anfrage überspringen (OFFSET) und zum anderen begrenzen (LIMIT) können. Der SQL Befehl sieht folgendermaßen aus:
SELECT * FROM USERS OFFSET <offset> LIMIT <size>;
Viele Benutzeroberflächen wollen dem Benutzer mehr Kontrolle geben, in dem es möglich wird eine Liste von Ergebnissen gezielt durchzublättern. Wie der Name schon verdeutlicht, wird das Konzept der „Seite“ verwendet, welche durch die folgenden zwei Parameter definiert ist:
Für die eigentliche SQL-Abfrage werden diese Parameter wie folgt umgerechnet
setzen.
Diese Query können wir nun mit LINQ anhand Skip (für OFFSET) und Take (für LIMIT) konstruieren.
public async Task<List<DTO>> GetDataAsync(int page, int pageSize) { var res = (await _container.ConfigureAwait(false)) .GetItemLinqQueryable<DTO>(true, null) .Skip(page * pageSize) .Take(pageSize) .AsEnumerable() .ToList(); return res; }
Die Verwendung der OFFSET–LIMIT–Bedingung sorgt für ein gezieltes Übertragen der gewünschten Daten an den Client und reduziert somit dessen Datenmenge. Gegenüber der Datenbank ist dies jedoch nicht der Fall. Die Belastung der Datenbank, mit einer OFFSET LIMIT Abfrage steigt mit steigendem Wert von OFFSET an. Dies liegt daran, dass zum Überspringen der Datensätze die Abfrage vollständig ausgeführt werden muss (Filter-Bedingungen und Sortierung) und mindestens alle zu überspringenden Datensätze durchlaufen werden müssen, obwohl diese anschließend nicht zurückgegeben werden.
Die CosmosDB bietet die Möglichkeit, von einer Abfrage nur die ersten X Datensätze zu erhalten. Dies würde einem OFFSET von 0 und einem definierten LIMIT von X entsprechen. Technisch gesehen wird jedoch die Abfrage datenbankseitig nach dem Ausgeben der X Datensätze „angehalten“ und zusätzlich ein Continuation-Token zurückgegeben. Mit diesem Token können wir von der gleichen Abfrage wieder eine Menge an X Datensätzen abrufen.
Die Eigenschaft MaxItemCount der FeedOptions einer CosmosDb Query bestimmt die maximale Anzahl an Ergebnissen, die die CosmosDb zurückgeben soll. Wenn die Anzahl an Ergebnissen höher als MaxItemCount ist, wird ein ContinuationToken in der Antwort mitgesendet.
public async Task<Tuple<Object, string>> GetDataAsync(string requestContinuationToken) { var options = new QueryRequestOptions() { MaxItemCount = 10 }; var responseToken = null; var iterator = (await _container.ConfigureAwait(false)) .GetItemQueryStreamIterator("SELECT * FROM FOO", requestContinuationToken, options); if (iterator.HasMoreResults) { var res = await iterator.ReadNextAsync().ConfigureAwait(false); if (res.IsSuccessStatusCode) responseToken = res.ContinuationToken; return new Tuple<Object, string>(res.Content, responseToken); } return null; }
Bei der Verwendung des Continuation-Tokens ist es extrem wichtig zu wissen, dass man nur die nächsten X Datensätze abrufen kann. Es gibt keine Möglichkeit die vorherigen Datensätze erneut abzufragen, ohne eine komplett neue Abfrage durchzuführen. Dafür ist die Performance jedoch selbst bei großen Datenmengen im Vergleich zu OFFET-LIMIT sehr gut.
Durch diese Limitierung ist der Einsatzweck des Continuation-Tokens eher begrenzt, da nur von Anfang an gelesen werden kann. Im Gegensatz zu OFFET-LIMIT kann eine „Seite“ nicht direkt angesprungen werden, ohne alle Daten vorher auszelesen.
Ein häufiges Einsatzszenario ist eine Liste mit Endless-Scrolling, welche immer am Anfang beginnt. Beim Scrollen werden die nächsten Daten geladen. Ältere Daten werden vom Client zwischengespeichert und können beim Nach-oben-Scrollen erneut angezeigt werden.
LINQ ermöglicht uns mit fünf Operatoren, Elemente eines Queryable oder Enumerable Objekts umzuordnen.
Für OrderBy kann man entweder den default Comparer benutzen (wird verwendet wenn kein anderer eingegeben wurde). Der Comparer implementiert dabei die Logik, wie zwei Datensätze verglichen werden (notwendig bei komplexen Datenstrukturen).
public async Task<List<People>> GetPeopleWhoseNamesStartWithA() { var res = (await _container.ConfigureAwait(false)) .GetItemLinqQueryable<People>(true, null) .OrderBy(p => p.Name) // sortiert die Personen ansteigend nach Namen .ThenBy(p => p.Age) // sortiert die resultierende Liste nach Alter .AsEnumerable() .ToList(); return res; }
Hier wird die Liste der Personen zuerst nach Namen aufsteigend sortiert. Personen mit gleichem Namen werden anschließend nach Alter aufsteigend sortiert.
Ergebnisse können mit LINQ via die Where-Methode herausgefiltert werden. Wenn z.B. nur die Personen , deren Namen mit „A“ starten gesucht sind, kann man die LINQ Query folgendermaßen aufbauen:
public async Task<List<People>> GetPeopleWhoseNamesStartWithA() { var res = (await _container.ConfigureAwait(false)) .GetItemLinqQueryable<People>(true, null) .Where(p => p.Name.StartsWith("A")) .AsEnumerable() .ToList(); return res; }
Die Verwendete Logik in der Where–Methode kann dabei beliebig komplex sein, so lange sie ein true (Datensatz soll in der Ergebnissmenge enthalten sein) oder false (Datensatz soll rausgefiltert werden) zurückgibt.