Die Montagsauswertung für den Vertrieb entsteht in Access im Abfrageentwurf: Positionen, Kunden, Umsätze und einige Gruppierungen. Zieht das Backend auf den SQL Server um, laufen Teile davon nicht mehr oder liefern in unserer Konfiguration andere Zahlen. Ein TOP 1<\/b> liefert dann eine Zeile statt zweier, ein Durchschnitt verliert seine Nachkommastellen, und eine Summe kommt als Text in Access an. Wer SELECT<\/b> in T-SQL schreibt, kennt viel davon aus Access. Umdenken müssen wir an einigen Stellen, und einige davon zeigen keine Fehlermeldung, sondern nur andere Ergebnisse. Wie wir die Abfragen schreiben, die im Alltag gebraucht werden, und worauf wir dabei achten, zeigt dieser zweite Teil der Reihe.<\/b><\/p>\n
Die Auswertungen des Vertriebs<\/h2>\n
Als Szenario dient wieder die Bestellverwaltung aus T-SQL, Teil 1: Von Jet-SQL zu T-SQL<\/b>. Der Vertrieb möchte wöchentlich sechs Fragen beantwortet haben:<\/p>\n Die Beispiele laufen gegen die Datenbank Bestellverwaltung_TSQL<\/b> mit den 330 Bestellungen, 32 Kunden und 825 Positionen aus Teil 1. Wer die Daten verändert hat, führt das Skript Bestellverwaltung_TSQL.sql<\/b> erneut aus. Es legt die Datenbank neu an und löscht dabei eine vorhandene gleichen Namens. Die Hilfsfunktionen PassThroughOeffnen<\/b>, PassThroughWert<\/b>, SqlText<\/b> und SqlDatum<\/b> stammen aus dem Modul mdlTSQLEinstiegBeispiele<\/b> aus Teil 1 und liegen auch im Frontend TSQL_SELECTInDerPraxis.accdb<\/b> bereit. Die neuen VBA-Funktionen dieses Beitrags stehen im Modul mdlSelectBeispiele<\/b>.<\/p>\n Wir beginnen mit den fünf Positionen mit dem höchsten Betrag. Der Betrag einer Position ist Menge<\/b> mal Einzelpreis<\/b> mal (1 minus Rabatt<\/b>). Der Rabatt<\/b> steht als Anteil in der Tabelle, 0,05 entspricht fünf Prozent. Berechnete Spalten benennen wir mit einem Alias, den wir wie in Access mit dem Schlüsselwort AS<\/b> angeben. Die Positionen stehen in tblBestelldetails<\/b>, den Namen der Produkte holen wir aus tblProdukte<\/b> (siehe Listing 1).<\/p>\n Listing 1: Die fünf größten Bestellpositionen<\/span><\/b><\/p>\n Das Ergebnis sind die fünf Positionen mit den Beträgen 399,00 Euro bis 3,00 Euro (siehe Bild 1). TOP (5)<\/b> begrenzt die Ausgabe auf fünf Zeilen. Die ORDER BY<\/b>-Klausel sortiert nach dem Alias Zeilenbetrag<\/b>. Als zweites Sortierkriterium dient d.BestelldetailID<\/b>, damit die Reihenfolge bei gleichen Beträgen festliegt.<\/p>\n Bild 1: Die fünf größten Positionen im Ergebnisraster von SSMS<\/span><\/b><\/p>\n Der CAST<\/b> auf decimal(10,2)<\/b> rundet den Betrag auf zwei Nachkommastellen. Bei Aggregatfunktionen hat er eine weitere Aufgabe, die im Abschnitt Dezimalzahlen in Access<\/b> folgt.<\/p>\n In ORDER BY<\/b> durften wir den Alias Zeilenbetrag<\/b> verwenden. In WHERE<\/b> funktioniert das nicht. Wir versuchen es mit den Positionen, deren Betrag über 300 Euro liegt:<\/p>\n Der Server meldet Ungültiger Spaltenname „Betrag“<\/b>. Woran liegt das? Er wertet eine Abfrage logisch in einer anderen Reihenfolge aus, als wir die Klauseln hinschreiben. Der tatsächliche Ausführungsplan kann davon noch einmal abweichen. Die logische Reihenfolge lautet:<\/p>\n Ein Alias aus der SELECT<\/b>-Liste ist in WHERE<\/b>, GROUP BY<\/b> und HAVING<\/b> also noch nicht bekannt. In Access ist das nicht anders. Dort fragt die Abfrage allerdings nach einem Parameterwert, statt einen Fehler zu melden. Wir wiederholen deshalb den Ausdruck in WHERE<\/b> oder kapseln die Abfrage als Unterabfrage, davon handelt der nächste Teil.<\/p>\n Auch DISTINCT<\/b> kennen wir aus Access. Es entfernt doppelte Zeilen aus dem Ergebnis. Die Länder der Kunden stehen so nur einmal in der Liste:<\/p>\n Die Abfrage liefert drei Zeilen, obwohl tblKunden<\/b> 32 Datensätze enthält.<\/p>\n Die Frage nach den Kunden mit den meisten Bestellungen führt zu TOP<\/b>. In Access schreiben wir die Abfrage mit TOP 1<\/b> und einer absteigenden Sortierung nach der Zahl der Bestellungen. In unseren Tests lieferte sie zwei Zeilen, weil zwei Kunden jeweils 19 Bestellungen haben. Access gab bei diesem Gleichstand beide Kunden zurück.<\/p>\n In T-SQL liefert TOP (1)<\/b> ohne weitere Angabe höchstens eine Zeile. Welcher der beiden Kunden das ist, steht ohne ein weiteres Sortierkriterium nicht fest. Wer Gleichstände wie Access behandeln möchte, verwendet WITH TIES<\/b> (siehe Listing 2).<\/p>\n Listing 2: WITH TIES liefert die Gleichplatzierten<\/span><\/b><\/p>\n Das Ergebnis sind die Kunden Schröder und Vogel mit je 19 Bestellungen. WITH TIES<\/b> setzt eine ORDER BY<\/b>-Klausel voraus, und diese Klausel bestimmt, was als Gleichstand zählt. Hängen wir dort k.KundeID<\/b> an, sind die beiden nicht mehr gleich platziert, und WITH TIES<\/b> liefert nur eine Zeile.<\/p>\n Statt einer Anzahl lässt sich mit TOP (n) PERCENT<\/b> auch ein Prozentsatz der Zeilen angeben.<\/p>\n Die Kundenliste soll ein Formular seitenweise zeigen. TOP<\/b> liefert nur die ersten Zeilen und kennt keine Seiten. Dafür gibt es OFFSET<\/b> und FETCH<\/b>: OFFSET<\/b> überspringt die angegebene Zahl von Zeilen, FETCH NEXT<\/b> holt die folgenden.<\/p>\n Die zweite Seite mit zehn Kunden je Seite lautet so:<\/p>\n Das Ergebnis sind die Kunden Köhler bis Neumann. OFFSET<\/b> gehört zu ORDER BY<\/b> und ist ohne diese Klausel nicht erlaubt. Die Sortierung muss außerdem eindeutig sein, sonst können Datensätze beim Blättern doppelt oder gar nicht erscheinen. Haben zwei Kunden denselben Nachnamen, entscheidet KundeID<\/b> als zweites Kriterium, auf welcher Seite sie stehen.<\/p>\n Das setzt voraus, dass sich die Daten zwischen den Seitenaufrufen nicht verändern. Neue, gelöschte oder umsortierte Datensätze können die Seitengrenzen verschieben.<\/p>\n In VBA setzen wir die Anweisung aus der Seitenzahl und der Zahl der Zeilen je Seite zusammen. Das erledigt die Funktion KundenSeite<\/b>. Sie setzt die Seitenzahl auf 1, wenn sie kleiner ist, und löst bei einer Seitengröße unter 1 einen Fehler aus, weil FETCH NEXT<\/b> mindestens eine Zeile verlangt (siehe Listing 3).<\/p>\n Listing 3: KundenSeite holt eine Seite der Kundenliste<\/span><\/b><\/p>\n Der Ausdruck (lngSeite – 1) * lngProSeite<\/b> liefert den Wert für OFFSET<\/b>. Die Funktion PassThroughOeffnen<\/b> aus Teil 1 schickt den Text als temporäre Pass-Through-Abfrage an den Server und gibt das Recordset zurück.<\/p>\n Zum Ausprobieren gibt die Prozedur KundenSeiteAusgeben<\/b> eine Seite im Direktbereich aus (siehe Listing 4).<\/p>\n Listing 4: KundenSeiteAusgeben zeigt eine Seite der Kundenliste an<\/span><\/b><\/p>\n Der Aufruf KundenSeiteAusgeben 2, 10<\/b> liefert die zehn Kunden der zweiten Seite (siehe Bild 2). Seite 4 enthält die letzten beiden Kunden, Seite 5 ist leer.<\/p>\n Bild 2: Die zweite Seite der Kundenliste, ausgegeben von KundenSeiteAusgeben im Direktbereich<\/span><\/b><\/p>\n Bei Verknüpfungen unterscheiden sich Access und T-SQL deutlich. Der Abfrageentwurf von Access setzt um die bisherigen Verknüpfungen eine Klammer, sobald ein weiterer INNER JOIN<\/b> hinzukommt. Ohne diese Klammern meldet die Datenbank-Engine einen Syntaxfehler.<\/p>\n Die Abfrage, die die Positionen über fünf Tabellen zählt, sieht in der SQL-Ansicht so aus (siehe Listing 5).<\/p>\n Listing 5: Fünf Tabellen in Access-SQL mit Klammern<\/span><\/b><\/p>\n Lassen wir die Klammern weg, meldet Access den Fehler 3075, dessen Text mit Syntaxfehler (fehlender Operator) in Abfrageausdruck<\/b> beginnt.<\/p>\n T-SQL braucht keine Klammern. Die Verknüpfungen stehen hintereinander, und sie beziehen sich auf die Tabellen davor (siehe Listing 6).<\/p>\n Listing 6: Dieselbe Verknüpfung in T-SQL, ohne Klammern<\/span><\/b><\/p>\n Der Wert Anzahl<\/b> ist wie in der Access-Fassung 825. Das Schlüsselwort INNER<\/b> dürfen wir weglassen, JOIN<\/b> allein bedeutet dasselbe. In diesem Beitrag steht es ausgeschrieben, damit der Unterschied zu den äußeren Verknüpfungen erkennbar bleibt.<\/p>\n Für die Frage nach den Kunden ohne Bestellung brauchen wir den LEFT JOIN<\/b>. Er behält die Zeilen der linken Tabelle, auch wenn in der rechten nichts dazu passt. Ausgeschrieben heißt er LEFT OUTER JOIN<\/b>. Die Spalten der rechten Tabelle sind für solche Zeilen NULL<\/b>, und danach fragen wir in WHERE<\/b> (siehe Listing 7).<\/p>\n Listing 7: Kunden ohne Bestellung per LEFT JOIN<\/span><\/b><\/p>\n Die Abfrage liefert drei Kunden: Peters, Kleinschmidt und Zimmermann. Im Frontend liegt sie als Pass-Through-Abfrage ptKundenOhneBestellung<\/b> vor (siehe Bild 3).<\/p>\n Bild 3: Die Pass-Through-Abfrage ptKundenOhneBestellung in der Datenblattansicht<\/span><\/b><\/p>\n Für den Einsatz in VBA genügt oft die Zahl dieser Kunden. Die Funktion KundenOhneBestellungZaehlen<\/b> schickt dieselbe Bedingung mit COUNT(*)<\/b> an den Server und holt den Wert mit PassThroughWert<\/b> (siehe Listing 8).<\/p>\n Listing 8: KundenOhneBestellungZaehlen zählt die Kunden ohne Bestellung<\/span><\/b><\/p>\n Im Direktbereich liefert ?KundenOhneBestellungZaehlen()<\/b> die 3.<\/p>\n Bei einem LEFT JOIN<\/b> entscheidet der Ort einer Bedingung über das Ergebnis. Das zeigt ein Beispiel: Wir wollen für die Kunden die Zahl der Bestellungen seit Jahresbeginn 2026, auch für Kunden ohne eine solche Bestellung. Im ersten Versuch steht die Bedingung im ON<\/b> (siehe Listing 9).<\/p>\n Listing 9: Die Bedingung steht im ON<\/span><\/b><\/p>\n Das Ergebnis hat 32 Zeilen, also einen Eintrag je Kunde. Wer 2026 nicht bestellt hat, steht mit einer 0 in der Liste. Im zweiten Versuch verschieben wir die Bedingung in die WHERE<\/b>-Klausel (siehe Listing 10).<\/p>\n Listing 10: Dieselbe Bedingung im WHERE<\/span><\/b><\/p>\n Jetzt sind es 27 Zeilen. Woran liegt das? WHERE<\/b> wirkt auf das Ergebnis der Verknüpfung. Für die drei Kunden ohne Bestellung ist Bestelldatum<\/b> dort NULL<\/b>, und ein Vergleich mit NULL<\/b> ist weder wahr noch falsch. Die Zeilen fallen heraus. Dasselbe gilt für die zwei Kunden, deren Bestellungen vor 2026 liegen. Allgemein entfernt ein WHERE<\/b>-Kriterium auf der rechten Tabelle, das NULL<\/b> ausschließt, auch die Kunden ohne passende Bestellung. Die Abfrage verhält sich dann hinsichtlich dieser Zeilen wie ein INNER JOIN<\/b>. Steht die Bedingung im ON<\/b>, bleiben die Zeilen der linken Tabelle erhalten.<\/p>\n Eine Tabelle lässt sich auch mit sich selbst verknüpfen. In tblMitarbeiter<\/b> zeigt das Fremdschlüsselfeld VorgesetzterID<\/b> auf MitarbeiterID<\/b> derselben Tabelle. Um zu einem Mitarbeiter den Namen des Vorgesetzten zu bekommen, verwenden wir die Tabelle zweimal unter verschiedenen Aliasen. Mit LEFT JOIN<\/b> bleibt die Geschäftsführung ohne Vorgesetzten im Ergebnis (siehe Listing 11).<\/p>\n Listing 11: Selbstverknüpfung: Mitarbeiter und ihre Vorgesetzten<\/span><\/b><\/p>\n Das Ergebnis hat acht Zeilen. Bei Claudia Hoffmann steht (oberste Ebene)<\/b>, denn für sie ist VorgesetzterID<\/b> leer und die rechte Seite des LEFT JOIN<\/b> NULL<\/b>.<\/p>\n Weitere Verknüpfungsarten brauchen wir seltener. RIGHT JOIN<\/b> ist ein LEFT JOIN<\/b> mit vertauschten Tabellen und lässt sich umschreiben. FULL OUTER JOIN<\/b> behält die Zeilen beider Seiten und eignet sich für den Abgleich zweier Tabellen, etwa eines Imports gegen den Bestand. CROSS JOIN<\/b> bildet das Kreuzprodukt beider Tabellen und kommt im nächsten Teil vor.<\/p>\n Nun zum Umsatz der einzelnen Warengruppen. Beim Gruppieren gelten in T-SQL dieselben Grundregeln wie in Access. Eine Spalte der SELECT<\/b>-Liste steht entweder in GROUP BY<\/b> oder in einer Aggregatfunktion wie SUM<\/b>, COUNT<\/b>, AVG<\/b>, MIN<\/b> oder MAX<\/b>. Im Abfrageentwurf von Access nehmen wir die Zuordnung über die Zeile Funktion<\/b> vor. In T-SQL schreiben wir GROUP BY<\/b> und die Aggregatfunktionen hin.<\/p>\n Wir werten das Jahr 2025 aus, ohne stornierte Bestellungen, und behalten nur Gruppen mit mehr als 500 Euro Umsatz (siehe Listing 12).<\/p>\n Listing 12: Umsatz je Warengruppe 2025 mit GROUP BY und HAVING<\/span><\/b><\/p>\n Das Ergebnis zeigt sieben Warengruppen, die größte ist Zubehör<\/b> mit 7.205,65 Euro.<\/p>\n Der Unterschied zwischen WHERE<\/b> und HAVING<\/b> ergibt sich aus der Auswertungsreihenfolge. WHERE<\/b> wirkt auf die einzelnen Zeilen vor dem Gruppieren, HAVING<\/b> auf die fertigen Gruppen. Eine Bedingung auf eine Aggregatfunktion in WHERE<\/b> führt zu einer Fehlermeldung. Eine Bedingung auf ein Gruppierungsfeld gehört in WHERE<\/b>, weil dann weniger Zeilen in die Gruppierung gehen.<\/p>\n Bei COUNT<\/b> kommt es darauf an, was gezählt wird. COUNT(*)<\/b> zählt Zeilen, COUNT(Spalte)<\/b> zählt die Zeilen, in denen die Spalte nicht NULL<\/b> ist. Eine leere Zeichenkette ist nicht NULL<\/b> und wird mitgezählt.<\/p>\n Die folgende Abfrage zählt in tblBestellungen<\/b> 330 Bestellungen, davon 14 mit einer Bemerkung<\/b> und 312 mit einem Lieferdatum<\/b>:<\/p>\n Fehlt in GROUP BY<\/b> eine Spalte aus der SELECT<\/b>-Liste, nennt der Server die Spalte beim Namen. Im folgenden Beispiel fehlt MitarbeiterID<\/b>:<\/p>\n Die Meldung lautet Die dbo.tblBestellungen.MitarbeiterID-Spalte ist in der Auswahlliste ungültig, da sie nicht in einer Aggregatfunktion und nicht in der GROUP BY-Klausel enthalten ist<\/b> (siehe Bild 4). Welche Lösung passt, hängt von der Frage ab: Mit MitarbeiterID<\/b> in GROUP BY<\/b> entsteht eine Zeile je Kunde und Mitarbeiter, mit MAX(MitarbeiterID)<\/b> bleibt es bei einer Zeile je Kunde.<\/p>\n Bild 4: Die Meldung von SSMS, wenn eine Spalte weder in GROUP BY noch in einer Aggregatfunktion steht<\/span><\/b><\/p>\n Oft soll die Auswertung eine Gesamtzeile enthalten. In Access erzeugen wir sie mit einer Ergebniszeile im Datenblatt oder mit einer zweiten Abfrage.<\/p>\n In T-SQL ergänzt ROLLUP<\/b> die gruppierte Abfrage um eine Zeile, in der das Gruppierungsfeld NULL<\/b> ist und die Aggregate über die gesamte Abfrage laufen. Die Funktion GROUPING<\/b> unterscheidet diese Zeile von einer echten NULL<\/b>-Gruppe. Mit ihr sortieren wir die Gesamtzeile ans Ende (siehe Listing 13).<\/p>\n Listing 13: ROLLUP ergänzt den Umsatz je Warengruppe um eine Gesamtzeile<\/span><\/b><\/p>\n Ohne HAVING<\/b> erscheinen die neun Warengruppen. Dazu kommt die Zeile Gesamt<\/b> mit 15.280,51 Euro (siehe Bild 5). Sie summiert die ungerundeten Beträge. Die Summe der angezeigten, gerundeten Zeilen ergibt deshalb 15.280,53 Euro und weicht um 0,02 Euro ab.<\/p>\n Bild 5: Umsatz je Warengruppe mit der Gesamtzeile aus ROLLUP<\/span><\/b><\/p>\n Zwei Besonderheiten beim Rechnen verursachen keine Fehlermeldung, sondern andere Ergebnisse. Die erste betrifft die Division. In Access liefert \/<\/b> eine Dezimalzahl, und der Backslash \\<\/b> teilt ganzzahlig: 7\/2<\/b> ergibt 3,5, 7\\2<\/b> ergibt 3. T-SQL kennt nur ein Divisionszeichen. Es teilt ganzzahlig, wenn beide Seiten ganze Zahlen sind:<\/p>\n Das Ergebnis ist 3 und 3,5. Mit einer Dezimalzahl auf einer der beiden Seiten rechnet der Server mit Nachkommastellen.<\/p>\n Bei AVG<\/b> ist der Rückgabetyp bei einer ganzzahligen Spalte ebenfalls ganzzahlig, und der Durchschnitt wird abgeschnitten. In tblBestelldetails<\/b> ist Menge<\/b> eine smallint<\/b>-Spalte:<\/p>\n Die durchschnittliche Menge je Position beträgt 5,6. Der Server liefert für AVG(Menge)<\/b> die 5, für die zweite Spalte 5,600000. Wer eine Dezimalzahl erwartet, wandelt vor dem Rechnen mit CAST<\/b> um.<\/p>\n Dasselbe gilt für die durchschnittliche Lieferzeit in Tagen, berechnet mit DATEDIFF<\/b> und AVG<\/b>:<\/p>\n Das Ergebnis ist 4 und 4,487179, auf zwei Stellen gerundet 4, Tage. AVG<\/b> übergeht NULL<\/b>-Werte. Die 18 Bestellungen ohne Lieferdatum<\/b> gehen deshalb nicht in den Durchschnitt ein.<\/p>\n Die zweite Besonderheit zeigt sich erst in Access. Aggregatfunktionen über decimal<\/b>-Spalten liefern in T-SQL bis zu 38 Stellen. In unserer getesteten DAO- und ODBC-Konfiguration kommt ein Wert wie AVG(CAST(Menge AS decimal(9,2)))<\/b> als Text an, hier als 5.600000<\/b>. Vermutlich liegt das an der Genauigkeit von 38 Stellen, die DAO mit seinen 28 Stellen nicht abbilden kann. Dasselbe beobachten wir bei SUM<\/b>-Spalten über decimal<\/b>-Felder.<\/p>\n Zum Vergleich fragen wir den Durchschnitt zweimal ab, in der Spalte OhneCast<\/b> direkt und in der Spalte MitCast<\/b> mit einem äußeren CAST<\/b> auf decimal(9,2)<\/b>. Wir speichern die Abfrage als Pass-Through-Abfrage:<\/p>\n In der Datenblattansicht liefert sie zwei Spalten (siehe Bild 6).<\/p>\n Bild 6: Der Durchschnitt aus AVG ohne und mit CAST in der Datenblattansicht von Access<\/span><\/b><\/p>\n Die Spalte OhneCast<\/b> steht linksbündig und enthält 5.600000<\/b> als Text, die Spalte MitCast<\/b> steht rechtsbündig als Zahl. Der Datentyp steht in DAO.Field.Type<\/b>. Die Linksbündigkeit ist nur ein Hinweis.<\/p>\n Rechnet VBA mit dem Text, kann das Ergebnis falsch sein. In einer deutschen Windows-Installation liest CDbl<\/b> den Punkt in 5.600000<\/b> als Tausendertrenner und macht daraus 5.600.000.<\/p>\n Bei SUM<\/b> haben wir die Abhilfe in den Listings dieses Beitrags schon eingebaut: Wir wandeln die Summen mit CAST(… AS decimal(12,2))<\/b> um. Der Typ bleibt damit unter der Grenze von 28 Stellen und kommt in unserer Konfiguration als Decimal<\/b> an. Für AVG<\/b> zeigt das die Spalte MitCast<\/b>.<\/p>\n Die Division durch Null löst in T-SQL einen Fehler aus: 1\/0<\/b> ergibt die Meldung Fehler aufgrund einer Division durch Null<\/b>. NULLIF(Wert, 0)<\/b> liefert NULL<\/b>, wenn der Wert 0 ist, und eine Division durch NULL<\/b> ergibt wieder NULL<\/b>. Wir berechnen den Lagerbestand in Prozent des Mindestbestands. Hätte ein Produkt den Mindestbestand 0, endete die Abfrage ohne NULLIF<\/b> mit einer Fehlermeldung:<\/p>\n In den Beispieldaten kommt das nicht vor. Der Faktor 100.0<\/b> sorgt dafür, dass der Server nicht ganzzahlig teilt.<\/p>\n Iif<\/b> kennen wir aus Access-Abfragen, Switch<\/b> für Fälle mit mehreren Bedingungen. T-SQL hat IIF<\/b> für einen einfachen Entweder-oder-Fall und CASE<\/b> für mehrere Bedingungen. CASE<\/b> ist der allgemeinere Ausdruck. Der Server prüft die WHEN<\/b>-Bedingungen der Reihe nach und liefert das THEN<\/b> der ersten wahren Bedingung, sonst das ELSE<\/b>. Fehlt das ELSE<\/b>, ist das Ergebnis NULL<\/b>.<\/p>\n Damit teilen wir die Kunden anhand ihres Umsatzes in Klassen ein: ab 2.000 Euro A<\/b>, ab 1.000 Euro B<\/b>, der Rest C<\/b> (siehe Listing 14).<\/p>\n Listing 14: Umsatz je Kunde mit einer Klasseneinteilung per CASE<\/span><\/b><\/p>\n Von den 29 Kunden mit Bestellungen fallen acht in Klasse A<\/b>, dreizehn in Klasse B<\/b> und acht in Klasse C<\/b>. Die Abfrage steht im Frontend als ptKundenUmsatz<\/b> bereit. In der Datenblattansicht stehen die Umsätze rechtsbündig als Zahlen und nicht als Text (siehe Bild 7).<\/p>\n Bild 7: Die Pass-Through-Abfrage ptKundenUmsatz mit Umsatz und Klasse je Kunde<\/span><\/b><\/p>\n CASE<\/b> innerhalb einer Aggregatfunktion ersetzt die Kreuztabellenabfrage von Access, wenn die Spalten feststehen. Wir stellen die Umsätze der Jahre 2025 und 2026 nebeneinander, mit einer Zeile je Monat (siehe Listing 15).<\/p>\n Listing 15: Der Umsatz der Jahre 2025 und 2026 je Monat nebeneinander<\/span><\/b><\/p>\n CASE<\/b> liefert nur für die Zeilen des jeweiligen Jahres einen Wert, und SUM<\/b> übergeht die NULL<\/b>-Werte der übrigen Zeilen. Für Oktober bis Dezember 2026 gibt es noch keine Bestellungen, dort steht NULL<\/b> (siehe Bild 8).<\/p>\n Bild 8: Die Jahre 2025 und 2026 je Monat nebeneinander, bei fehlenden Bestellungen steht NULL<\/span><\/b><\/p>\n Wer das Datenblatt mit Nullen sehen möchte, ersetzt die Summe durch ISNULL(SUM(…), 0)<\/b>. Alternativ gibt es COALESCE<\/b>, das mehr als zwei Argumente akzeptiert und im Gegensatz zu ISNULL<\/b> zum SQL-Standard gehört. Der verwandte Operator PIVOT<\/b> dreht die Werte einer Spalte in ausdrücklich festgelegte Ergebnisspalten. Er kommt im nächsten Teil an die Reihe.<\/p>\n STRING_AGG<\/b> fasst die Werte einer Spalte je Gruppe zu einer Zeichenkette zusammen. Access braucht dafür eine eigene VBA-Funktion. STRING_AGG<\/b> gibt es ab SQL Server 2017. Die Produkte der einzelnen Warengruppen stehen so in einer kommaseparierten Liste (siehe Listing 16). Das Ergebnis hat neun Zeilen, eine je Warengruppe. Die Klausel WITHIN GROUP<\/b> sortiert die Produkte innerhalb der Liste.<\/p>\n Listing 16: STRING_AGG liefert die Produkte je Warengruppe als Liste<\/span><\/b><\/p>\n Zum Verketten von Spalten gibt es CONCAT_WS<\/b>. Die Funktion setzt Werte mit einem Trennzeichen zusammen und überspringt NULL<\/b>-Werte. Bei den Privatkunden ohne Firma entsteht so kein überflüssiges Komma. Eine Adresszeile aus Firma<\/b>, Name, Strasse<\/b> und Ort sieht so aus:<\/p>\n Für Hans Müller steht dort Müller Bürobedarf GmbH, Hans Müller, Hauptstraße 12, 80331 München<\/b>, für Petra Schmidt ohne Firma Petra Schmidt, Lindenweg 5, 50667 Köln<\/b>. In den Beispieldaten ist keine der Spalten Vorname<\/b>, Nachname<\/b>, Strasse<\/b>, PLZ<\/b> und Ort<\/b> NULL<\/b>. Wäre eine davon NULL<\/b>, fiele das zusammengesetzte Stück vollständig weg.<\/p>\n\n
Die größten Positionen<\/h2>\n
SELECT TOP (5)\r\n d.BestellungID,\r\n p.Produkt,\r\n d.Menge,\r\n d.Einzelpreis,\r\n d.Rabatt,\r\n CAST(d.Menge * d.Einzelpreis * (1 - d.Rabatt)\r\n AS decimal(10,2)) AS Zeilenbetrag\r\nFROM dbo.tblBestelldetails AS d\r\n INNER JOIN dbo.tblProdukte AS p ON p.ProduktID = d.ProduktID\r\nORDER BY Zeilenbetrag DESC, d.BestelldetailID;<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_001.png\")
<\/p>\nAliase und die Reihenfolge der Auswertung<\/h2>\n
SELECT Menge * Einzelpreis * (1 - Rabatt) AS Betrag\r\nFROM dbo.tblBestelldetails\r\nWHERE Betrag > 300;<\/pre>\n
\n
SELECT DISTINCT Land\r\nFROM dbo.tblKunden\r\nORDER BY Land;<\/pre>\n
TOP und Gleichstände<\/h2>\n
SELECT TOP (1) WITH TIES\r\n k.KundeID, k.Nachname, COUNT(*) AS Bestellungen\r\nFROM dbo.tblKunden AS k\r\n INNER JOIN dbo.tblBestellungen AS b ON b.KundeID = k.KundeID\r\nGROUP BY k.KundeID, k.Nachname\r\nORDER BY COUNT(*) DESC;<\/pre>\n
Die Kundenliste seitenweise holen<\/h2>\n
SELECT KundeID, Nachname, Ort\r\nFROM dbo.tblKunden\r\nORDER BY Nachname, KundeID\r\nOFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY;<\/pre>\n
Public Function <\/span>KundenSeite(lngSeite As Long<\/span>, lngProSeite As Long<\/span>) As <\/span>DAO.Recordset\r\n Dim <\/span>strSQL As String<\/span>\r\n If <\/span>lngSeite < 1 Then<\/span> lngSeite = 1\r\n If <\/span>lngProSeite < 1 Then<\/span>\r\n Err.Raise 5, \"KundenSeite\", \"Mindestens 1 Zeile je Seite\"\r\n End If<\/span>\r\n strSQL = \"SELECT KundeID, Nachname, Ort FROM dbo.tblKunden \" & _\r\n \"ORDER BY Nachname, KundeID \" & _\r\n \"OFFSET \" & (lngSeite - 1) * lngProSeite & \" ROWS \" & _\r\n \"FETCH NEXT \" & lngProSeite & \" ROWS ONLY\"\r\n Set<\/span> KundenSeite = PassThroughOeffnen(strSQL)\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>KundenSeiteAusgeben(lngSeite As Long<\/span>, lngProSeite As Long<\/span>)\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> rst = KundenSeite(lngSeite, lngProSeite)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Debug.Print<\/span> rst!KundeID, rst!Nachname, rst!Ort\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_002.png\")
<\/p>\nJOIN ohne Klammern<\/h2>\n
SELECT Count(*) AS Anzahl\r\nFROM (((dbo_tblBestelldetails AS d\r\n INNER JOIN dbo_tblBestellungen AS b ON d.BestellungID = b.BestellungID)\r\n INNER JOIN dbo_tblKunden AS k ON b.KundeID = k.KundeID)\r\n INNER JOIN dbo_tblProdukte AS p ON d.ProduktID = p.ProduktID)\r\n INNER JOIN dbo_tblKategorien AS c ON p.KategorieID = c.KategorieID;<\/pre>\n
SELECT COUNT(*) AS Anzahl\r\nFROM dbo.tblBestelldetails AS d\r\n INNER JOIN dbo.tblBestellungen AS b ON b.BestellungID = d.BestellungID\r\n INNER JOIN dbo.tblKunden AS k ON k.KundeID = b.KundeID\r\n INNER JOIN dbo.tblProdukte AS p ON p.ProduktID = d.ProduktID\r\n INNER JOIN dbo.tblKategorien AS c ON c.KategorieID = p.KategorieID;<\/pre>\n
Kunden ohne Bestellung<\/h2>\n
SELECT k.KundeID, k.Nachname, k.Ort\r\nFROM dbo.tblKunden AS k\r\n LEFT JOIN dbo.tblBestellungen AS b ON b.KundeID = k.KundeID\r\nWHERE b.BestellungID IS NULL\r\nORDER BY k.KundeID;<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_003.png\")
<\/p>\nPublic Function <\/span>KundenOhneBestellungZaehlen() As Long<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n strSQL = \"SELECT COUNT(*) FROM dbo.tblKunden k \" & _\r\n \"LEFT JOIN dbo.tblBestellungen b ON b.KundeID = k.KundeID \" & _\r\n \"WHERE b.BestellungID IS NULL\"\r\n KundenOhneBestellungZaehlen = Nz(PassThroughWert(strSQL), 0)\r\nEnd Function<\/span><\/pre>\nBedingungen im ON oder im WHERE<\/h2>\n
SELECT k.KundeID, COUNT(b.BestellungID) AS Bestellungen\r\nFROM dbo.tblKunden AS k\r\n LEFT JOIN dbo.tblBestellungen AS b\r\n ON b.KundeID = k.KundeID AND b.Bestelldatum >= '20260101'\r\nGROUP BY k.KundeID;<\/pre>\n
SELECT k.KundeID, COUNT(b.BestellungID) AS Bestellungen\r\nFROM dbo.tblKunden AS k\r\n LEFT JOIN dbo.tblBestellungen AS b ON b.KundeID = k.KundeID\r\nWHERE b.Bestelldatum >= '20260101'\r\nGROUP BY k.KundeID;<\/pre>\n
Selbstverknüpfung<\/h2>\n
SELECT m.Vorname + N' ' + m.Nachname AS Mitarbeiter,\r\n m.Funktion,\r\n ISNULL(v.Vorname + N' ' + v.Nachname, N'(oberste Ebene)') AS Vorgesetzter\r\nFROM dbo.tblMitarbeiter AS m\r\n LEFT JOIN dbo.tblMitarbeiter AS v ON v.MitarbeiterID = m.VorgesetzterID\r\nORDER BY m.MitarbeiterID;<\/pre>\n
Umsatz je Warengruppe<\/h2>\n
SELECT c.Kategorie,\r\n COUNT(*) AS Positionen,\r\n CAST(SUM(d.Menge * d.Einzelpreis * (1 - d.Rabatt))\r\n AS decimal(12,2)) AS Umsatz\r\nFROM dbo.tblBestellungen AS b\r\n INNER JOIN dbo.tblBestelldetails AS d ON d.BestellungID = b.BestellungID\r\n INNER JOIN dbo.tblProdukte AS p ON p.ProduktID = d.ProduktID\r\n INNER JOIN dbo.tblKategorien AS c ON c.KategorieID = p.KategorieID\r\nWHERE b.Bestelldatum >= '20250101' AND b.Bestelldatum < '20260101'\r\n AND b.BestellstatusID <> 5\r\nGROUP BY c.Kategorie\r\nHAVING SUM(d.Menge * d.Einzelpreis * (1 - d.Rabatt)) > 500\r\nORDER BY Umsatz DESC;<\/pre>\n
COUNT: Zeilen und Werte<\/h2>\n
SELECT COUNT(*) AS Alle,\r\n COUNT(Bemerkung) AS MitBemerkung,\r\n COUNT(Lieferdatum) AS Geliefert\r\nFROM dbo.tblBestellungen;<\/pre>\n
Die Fehlermeldung beim Gruppieren<\/h2>\n
SELECT KundeID, MitarbeiterID, COUNT(*) AS Anzahl\r\nFROM dbo.tblBestellungen\r\nGROUP BY KundeID;<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_004.png\")
<\/p>\nEine Gesamtzeile mit ROLLUP<\/h2>\n
SELECT ISNULL(c.Kategorie, N'Gesamt') AS Kategorie,\r\n CAST(SUM(d.Menge * d.Einzelpreis * (1 - d.Rabatt))\r\n AS decimal(12,2)) AS Umsatz\r\nFROM dbo.tblBestellungen AS b\r\n INNER JOIN dbo.tblBestelldetails AS d ON d.BestellungID = b.BestellungID\r\n INNER JOIN dbo.tblProdukte AS p ON p.ProduktID = d.ProduktID\r\n INNER JOIN dbo.tblKategorien AS c ON c.KategorieID = p.KategorieID\r\nWHERE b.Bestelldatum >= '20250101' AND b.Bestelldatum < '20260101'\r\n AND b.BestellstatusID <> 5\r\nGROUP BY ROLLUP (c.Kategorie)\r\nORDER BY GROUPING(c.Kategorie), Umsatz DESC;<\/pre>\n
![\"Umsatz](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_005.png\")
<\/p>\nDivision mit Ganzzahlen<\/h2>\n
SELECT 7 \/ 2 AS Ganzzahl, 7 \/ 2.0 AS Dezimal;<\/pre>\n
AVG bei ganzzahligen Spalten<\/h2>\n
SELECT AVG(Menge) AS Mittel,\r\n AVG(CAST(Menge AS decimal(9,2))) AS MittelDezimal\r\nFROM dbo.tblBestelldetails;<\/pre>\n
SELECT AVG(DATEDIFF(DAY, Bestelldatum, Lieferdatum))\r\n AS Ganzzahl,\r\n AVG(CAST(DATEDIFF(DAY, Bestelldatum, Lieferdatum)\r\n AS decimal(9,2))) AS Dezimal\r\nFROM dbo.tblBestellungen;<\/pre>\n
Dezimalzahlen in Access<\/h2>\n
SELECT AVG(CAST(Menge AS decimal(9,2))) AS OhneCast,\r\n CAST(AVG(CAST(Menge AS decimal(9,2)))\r\n AS decimal(9,2)) AS MitCast\r\nFROM dbo.tblBestelldetails;<\/pre>\n
![\"Der](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_009.png\")
<\/p>\nDivision durch Null<\/h2>\n
SELECT Produkt,\r\n Lagerbestand * 100.0 \/ NULLIF(Mindestbestand, 0)\r\n AS Prozent\r\nFROM dbo.tblProdukte;<\/pre>\n
CASE statt IIF und Switch<\/h2>\n
SELECT k.KundeID, k.Nachname,\r\n CAST(SUM(d.Menge * d.Einzelpreis * (1 - d.Rabatt))\r\n AS decimal(12,2)) AS Umsatz,\r\n CASE\r\n WHEN SUM(d.Menge * d.Einzelpreis * (1 - d.Rabatt)) >= 2000 THEN N'A'\r\n WHEN SUM(d.Menge * d.Einzelpreis * (1 - d.Rabatt)) >= 1000 THEN N'B'\r\n ELSE N'C'\r\n END AS Klasse\r\nFROM dbo.tblKunden AS k\r\n INNER JOIN dbo.tblBestellungen AS b ON b.KundeID = k.KundeID\r\n INNER JOIN dbo.tblBestelldetails AS d ON d.BestellungID = b.BestellungID\r\nWHERE b.BestellstatusID <> 5\r\nGROUP BY k.KundeID, k.Nachname\r\nORDER BY Umsatz DESC;<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_006.png\")
<\/p>\nKreuztabelle mit CASE<\/h2>\n
SELECT MONTH(b.Bestelldatum) AS Monat,\r\n CAST(SUM(CASE WHEN YEAR(b.Bestelldatum) = 2025\r\n THEN d.Menge * d.Einzelpreis * (1 - d.Rabatt) END)\r\n AS decimal(12,2)) AS Umsatz2025,\r\n CAST(SUM(CASE WHEN YEAR(b.Bestelldatum) = 2026\r\n THEN d.Menge * d.Einzelpreis * (1 - d.Rabatt) END)\r\n AS decimal(12,2)) AS Umsatz2026\r\nFROM dbo.tblBestellungen AS b\r\n INNER JOIN dbo.tblBestelldetails AS d ON d.BestellungID = b.BestellungID\r\nWHERE b.Bestelldatum >= '20250101' AND b.Bestelldatum < '20270101'\r\n AND b.BestellstatusID <> 5\r\nGROUP BY MONTH(b.Bestelldatum)\r\nORDER BY Monat;<\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_04\/pic_517_007.png\")
<\/p>\nListen mit STRING_AGG<\/h2>\n
SELECT c.Kategorie,\r\n STRING_AGG(p.Produkt, N', ')\r\n WITHIN GROUP (ORDER BY p.Produkt) AS Produkte\r\nFROM dbo.tblKategorien AS c\r\n INNER JOIN dbo.tblProdukte AS p ON p.KategorieID = c.KategorieID\r\nGROUP BY c.Kategorie\r\nORDER BY c.Kategorie;<\/pre>\n
Adresszeilen mit CONCAT_WS<\/h2>\n
SELECT KundeID,\r\n CONCAT_WS(N', ', Firma, Vorname + N' ' + Nachname,\r\n Strasse, PLZ + N' ' + Ort) AS Adresse\r\nFROM dbo.tblKunden;<\/pre>\n