In modernen Anwendungen müssen oft sehr große Datenmengen verarbeitet werden.
Unoptimierte SQL-Abfragen führen dabei schnell zu:
FilterColumn und Pager ermöglichen es, schon in der SQL-Abfrage gezielt zu filtern und nur die relevanten Daten zu laden. In diesem Fachartikel wird gezeigt, wie das funktioniert und welche Vorteile es für die Performance bringt.
In vielen Projekten werden zunächst alle Datensätze aus der Datenbank geladen und erst danach im Anwendungscode gefiltert. Das kostet Zeit, belastet das Netzwerk und verlangsamt die Anwendung.
Hauptursache: Die WHERE-Bedingungen werden nicht direkt im SQL-Befehl gesetzt, sondern erst später im Code.
Besser ist es, die Filterung bereits in der Datenbank durchzuführen.
Mit FilterColumn lassen sich flexible Filter definieren, die automatisch in die SQL-Abfrage eingebunden werden. Der Pager sammelt diese Filter und sorgt dafür, dass die Abfrage nur die wirklich benötigten Datensätze zurückliefert.
Bei großen Datenmengen werden oft alle Datensätze aus der Datenbank geladen und erst danach im Code gefiltert.
Das bedeutet: Die Anwendung muss sehr viele Daten übertragen und verarbeiten, obwohl nur ein kleiner Teil wirklich benötigt wird.
Wenn die Filter erst nach dem Laden im Code angewendet werden, muss die Anwendung unnötig viele Daten übertragen.
Besser ist es, schon im SQL-Befehl gezielt zu filtern, bevor die Abfrage überhaupt zur Datenbank geschickt wird.
So werden nur die relevanten Datensätze geladen, was die Performance deutlich verbessert – besonders bei sehr großen Tabellen.
Mit FilterColumn und Pager kann die Abfrage so gestaltet werden, dass die Filterung direkt in der Datenbank erfolgt.
Das bedeutet: Die WHERE-Bedingung wird schon im SQL-Befehl gesetzt, bevor die Abfrage an die Datenbank gesendet wird.
Dadurch werden nur die wirklich benötigten Datensätze geladen, was die Datenübertragung reduziert, und die Verarbeitung beschleunigt.
Praxisbeispiel 1: Rabattberechnung in C#
1public static List<FilterColumn> GetCustomerList_Filter()
2{
3 var filters = new List<FilterColumn>();
4
5 // Beispiel 1: Filter nach Jahr
6 filters.Add(new FilterColumn
7 {
8 Rank = 1,
9 ControllId = "pnYear",
10 DisplayName = "Jahr",
11 DisplayKriterien = "=",
12 FilterControlType = ControlTypeEnum.Textbox,
13 FilterValue = DateTime.Today.Year,
14 FilterValueType = typeof(int),
15 DBWhereParameterName = "customer.year",
16 DBWhereCondition = "customer.year = ?",
17 DBColumnType = (int)OdbcType.Int
18 });
Praxisbeispiel 2: Filter nach Status:
1 filters.Add(new FilterColumn
2 {
3 Rank = 2,
4 ControllId = "psStatus",
5 DisplayName = "Status",
6 DisplayKriterien = "=",
7 FilterControlType = ControlTypeEnum.Textbox,
8 FilterValue = "Aktiv",
9 FilterValueType = typeof(string),
10 DBWhereParameterName = "customer.status",
11 DBWhereCondition = "customer.status = ?",
12 DBColumnType = (int)OdbcType.VarChar
13 });
14
15 return filters;
16}
Die Methode GetCustomerList_Filter() gibt eine Liste von FilterColumn zurück.
Diese Liste kann dann beim Aufbau der SQL-Abfrage genutzt werden, um nur die relevanten Daten zu laden.
Dadurch wird die WHERE-Bedingung automatisch erstellt, bevor die Abfrage an die Datenbank geht.
1. Filterliste laden
var oFilterColumns = GetCustomerList_Filter();
2. Pager erstellen
Pager oPager = new Pager { Filter = oFilterColumns };
3. Werte für die Filter setzen
FilterHelper.AssignFilterValue(oPager.Filter, "pnYear", DateTime.Today.Year);
FilterHelper.AssignFilterValue(oPager.Filter, "psStatus", "Aktiv");
4. Daten aus der Datenbank holen (vereinfacht)
var customerList = oContext.getCustomerList(oPager).ToList();
5. Ergebnis prüfen oder weiterverarbeiten
foreach (var customer in customerList)
{
Console.WriteLine($"{customer.Id} - {customer.Name}");
}
Der Vorteil dieser Methode ist, dass neue Bedingungen sehr leicht ergänzt werden können.
Man muss nur in der GetCustomerList_Filter()-Methode einen weiteren FilterColumn hinzufügen und den passenden Wert mit AssignFilterValue setzen.
So bleibt die Abfrage flexibel und erweiterbar, ohne dass der SQL-Code manuell angepasst werden muss.
Praxisbeispiel – Methode mit Pager:
public List<Customer> GetCustomerList(Pager oPager)
{
// SQL-Abfrage aufbauen mit den Filtern aus dem Pager
string sql = "SELECT * FROM customer” ;
foreach (var filter in oPager.Filter)
{
sql += " AND " + filter.DBWhereCondition;
}
// Abfrage ausführen (vereinfacht)
var result = new List<Customer>();
using (var command = new OdbcCommand(sql, myConnection))
{
foreach (var filter in oPager.Filter)
{
command.Parameters.AddWithValue(filter.DBWhereParameterName, filter.FilterValue);
}
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
result.Add(new Customer
{
Id = reader.GetInt32(0),
Name = reader.GetString(1),
Status = reader.GetString(2),
Year = reader.GetInt32(3)
});
}
}
}
return result;
}Mit dem gezeigten Ansatz wird zuerst eine Filterliste über die Methode GetCustomerList_Filter() erstellt.
Diese Liste enthält alle Bedingungen, die später im SQL-Befehl genutzt werden.
Jede Bedingung beschreibt eine Spalte, einen Vergleichsoperator und einen Wert.
Anschließend wird ein Pager angelegt, der diese Filter sammelt.
Mit FilterHelper.AssignFilterValue() können die Werte flexibel gesetzt werden, zum Beispiel ein bestimmtes Jahr oder ein Status.
Dadurch bleibt die Abfrage dynamisch und leicht erweiterbar.
Im nächsten Schritt wird der Pager an eine Methode wie GetCustomerList(Pager oPager) übergeben.
Diese Methode baut den SQL-Befehl anhand der Filter auf und führt die Abfrage gegen die Datenbank aus.
Die WHERE-Bedingungen werden also vor dem Senden an die Datenbank gesetzt.
Das bedeutet: Die Datenbank liefert nur die wirklich benötigten Datensätze zurück.
Der Vorteil dieser Vorgehensweise liegt auf der Hand:
In der Praxis führt diese Technik zu deutlich kürzeren Antwortzeiten und einer stabileren Performance – besonders, wenn mit sehr großen Tabellen gearbeitet wird.
Wie auch in Fachartikeln und Best Practices beschrieben, ist das Filtern direkt in der SQL-Abfrage einer der wichtigsten Schritte, um Datenbanken effizient zu nutzen.
Durch den Einsatz von FilterColumn und Pager lassen sich SQL-Abfragen massiv optimieren.
Für Projekte mit großen Datenmengen ist dieser Ansatz ein klarer Vorteil:
Mehr Geschwindigkeit, Effizienz und Wartbarkeit.
Unser Geschäftsführer Tibor Csizmadia und unser Kundenbetreuer Jens Walter stehen Ihnen persönlich zur Verfügung. Profitieren Sie von unserer langjährigen Erfahrung und erhalten Sie eine kompetente Erstberatung in einem unverbindlichen Austausch.
