Optimierte SQL-Abfragen

Optimierte SQL-Abfragen mit FilterColumn & Pager

In modernen Anwendungen müssen oft sehr große Datenmengen verarbeitet werden.

Unoptimierte SQL-Abfragen führen dabei schnell zu:

• langen Antwortzeiten,

• unnötigem Datenverkehr zwischen Anwendung und Datenbank,

• hoher Serverlast.

Die Lösung: 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 optimierte SQL-Abfragen mithilfe von FilterColumn & Pager umgesetzt werden und welche Vorteile dieser Ansatz für Performance und Wartbarkeit bringt.

‍

Das Problem: zu viele Daten im Code statt in der Datenbank

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.

‍

Die Lösung: FilterColumn & Pager

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.

‍

Das Problem: zu viele Daten im Code statt in der Datenbank

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.

‍

Die Lösung: FilterColumn & Pager

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.

‍

Vorteile:

• Nur relevante Daten werden geladen

• Deutlich weniger Datenverkehr

• Kürzere Antwortzeiten

• Entlastung des Servers

• Dynamisch erweiterbar ohne manuelles Anpassen von SQL-Code

Praxisbeispiel: Rabattberechnung in C#

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

‍

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.

‍

Wie wird es verwendet?

‍

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

‍

Erläuterung

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:

• Die Anwendung muss nicht mehr alle Daten laden und später im Code herausfiltern.

• Es werden nur die relevanten Zeilen direkt aus der Datenbank geholt.

• Das spart Zeit, reduziert den Datenverkehr und entlastet den Server.

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.

‍

Fazit

Durch den Einsatz von FilterColumn und Pager lassen sich SQL-Abfragen massiv optimieren.

• Die Filterung erfolgt direkt in der Datenbank.

• Die Anwendung muss nicht mehr alle Daten laden und später aussortieren.

• Die Performance verbessert sich spürbar, besonders bei großen Tabellen.

‍

Für Projekte mit großen Datenmengen ist dieser Ansatz ein klarer Vorteil:

Mehr Geschwindigkeit, Effizienz und Wartbarkeit.