{"id":55000313,"date":"2016-06-01T00:00:00","date_gmt":"2020-01-24T15:59:34","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=313"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"SELECTAbfragen_in_Union","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/SELECTAbfragen_in_Union.html","title":{"rendered":"SELECT-Abfragen in Union"},"content":{"rendered":"

In der vorigen Ausgabe von Access [basics] schnitten wir das Thema UNION-Abfragen bereits an. Dort wurde ein Kombinationsfeld zur Formularnavigation mit einem UNION-SELECT-Ausdruck als Datenherkunft belegt. Deshalb nehmen wir diese SQL-Spezialität hier einmal etwas allgemeiner unter die Lupe und betrachten zusammengesetzte Abfragen im Detail.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 1603_Union-Abfragen.accdb<\/b><\/p>\n

Daten zusammenfassen<\/h2>\n

In der Beispieldatenbank stellt sich eine Aufgabe, die so gar nicht selten zu erledigen ist: Daten verschiedener Herkunft sollen in einer Tabelle zusammengeführt werden. Es handelt sich um Adressen, die etwa aus importierten CSV-Dateien stammen und bereits in den Tabellen tblAdressen1<\/b> bis tblAdressen4<\/b> vorliegen.<\/p>\n

Die erste enthält nur Adressen aus dem Postleitzahlengebiet 1*<\/b> und 2*<\/b>, die nächste aus 3*<\/b>, 4*<\/b> und 5*<\/b>, eine weitere aus 6*<\/b>, 7*<\/b>, 8*<\/b> und 9*<\/b>, sowie schließlich eine für jene aus 0*<\/b>. Die Datensätze dieser vier Tabellen transferieren wir nun in ihrer Gesamtheit in die Tabelle tblAdressen<\/b>.<\/p>\n

Hierfür könnten Sie eine einfache Anfügeabfrage erstellen und nacheinander die jeweiligen Quelltabellen in sie einsetzen, um den Export zu bewerkstelligen. Das allerdings ist wenig elegant und zieht so einiges Mausgeklicke nach sich, von der Fehleranfälligkeit einmal abgesehen. Besser, Sie greifen hier zu einer UNION-Abfrage, die die Sache in einem Rutsch erledigt.<\/p>\n

UNION-Abfragen<\/h2>\n

Eine UNION-Abfrage<\/b> fasst zwei oder mehr einzelne Abfragen in einem Ergebnis zusammen. Während Sie fast alle Abfragetypen mit dem GUI-Query-Editor<\/b> anlegen und bearbeiten können, sieht das bei UNION-Abfragen<\/b> anders aus. Hier sind Sie im Entwurf auf den SQL-Editor<\/b> beschränkt. Ohne grundlegende SQL-Kenntnisse sind sie damit also nicht im Boot.<\/p>\n

Bild 1 zeigt, wie Sie gespeicherte UNION-Abfragen<\/b> im Navigationsbereich von Access sofort erkennen können. Das Schnittmengensymbol macht sie deutlich.<\/p>\n

\"Die<\/a><\/p>\n

Bild 1: Die zwei Ringe stellen das Symbol für UNION-Abfragen im Navigationsbereich dar<\/p>\n

Legen Sie Ihre erste UNION-Abfrage<\/b> so an: Klicken Sie im Ribbon Erstellen<\/b> auf Abfrageentwurf<\/b>. Schließen Sie sofort den Dialog zur Tabellenauswahl. Der Ribbon-Tab<\/b> Entwurf<\/b> ist nun automatisch aktiv, und links wird auch gleich der Button SQL<\/b> für die Ansicht eingeblendet. Klicken Sie darauf, um den SQL-Editor<\/b> zu öffnen.<\/p>\n

Nur als Hinweis hat Access bereits den Ausdruck Select;<\/b> als SQL-Text im Editor eingefügt. Um nun alle Datensätze der Tabelle tblAdressen1<\/b> im Abfrageergebnis anzuzeigen, erweitern Sie den Ausdruck in<\/p>\n

SELECT * FROM tblAdressen1<\/pre>\n
Da die Aufgabe darin besteht, zusätzlich zu dieser Tabelle auch noch eine weitere ins Ergebnis zu holen, benötigen wir ein weiteres SELECT-Statement<\/b>, das diesmal aber über den Ausdruck UNION<\/b> mit dem anderen SELECT-Statement<\/b> verknüpft wird:<\/p>\n
SELECT * FROM tblAdressen1\r\nUNION\r\nSELECT * FROM tblAdressen2<\/pre>\n
Klicken Sie auf den Ausführen<\/b>-Button im Ribbon, um sich davon zu überzeugen, dass diese Abfrage einwandfrei funktioniert. Speichern Sie sie unter dem Namen qry_Union_Simple<\/b> ab. Im Navigationsbereich wird sie sogleich angezeigt und weist das entsprechende Symbol auf. Ein Rechtklick auf den Eintrag listet im Kontextmenü übrigens nun ebenfalls nur die SQL<\/b>-Ansicht ein. Die normale Entwurfsansicht<\/b> ist nicht erreichbar.<\/p>\n
Eine UNION-Abfrage wird als solche allerdings nur identifiziert, wenn Sie den Aufbau von oben hat und Sie das Ergebnis nicht in Klammern einfassen. Denn auch diese Syntax ließe sich herstellen:<\/p>\n
SELECT * FROM (\r\nSELECT * FROM tblAdressen1\r\nUNION\r\nSELECT * FROM tblAdressen2\r\n)<\/pre>\n
Die eigentliche UNION-Abfrage<\/b> ist hier innerhalb der Klammern zu finden und wird wie eine einzelne Tabelle behandelt, indem ein weiterer Select<\/b>-Ausdruck auf diese Unterabfrage angewandt wird. Das Anzeigeergebnis ist zwar dasselbe, die Abfrage wird dabei jedoch als normale Auswahlabfrage<\/b> gespeichert. Damit besteht automatisch auch die Möglichkeit, sie im Entwurfsmodus<\/b> zu öffnen. Das sieht dann etwa aus, wie in Bild 2. In dieser Abfrage wurde das UNION<\/b>-Ergebnis über das äußere Select-Statement<\/b> noch einer Sortierung nach Namen unterzogen, sowie einer Filterung nach dem Postleitzahlenbereich 1*<\/b>.<\/p>\n
\"Dass<\/a><\/p>\n
Bild 2: Dass es sich hier um eine UNION-Abfrage handelt, ist nicht gleich erkennbar<\/p>\n
Das geht aus dem Entwurf zwar vor, irritierend ist aber die seltsame Tabellenbezeichnung [%$##@_Alias]<\/b>. Access setzt diesen Ausdruck immer dann ein, wenn eine Unterabfrage nicht namentlich definiert ist. Sie können das etwa so ändern:<\/p>\n
SELECT * FROM (\r\nSELECT * FROM tblAdressen1\r\nUNION\r\nSELECT * FROM tblAdressen2\r\n) As <\/span>UTable<\/pre>\n
Hier wird das Klammerergebnis, die UNION-Abfrage, als virtuelle Tabelle UTable<\/b> definiert, was anschließend auch im Entwurfsmodus zu sehen ist. Das [%$##@_Alias] <\/b>macht dem UTable<\/b> Platz. Indessen geht im Entwurf auch jetzt noch nicht hervor, dass die angezeigte Tabelle tatsächlich eine UNION-Abfrage<\/b> darstellt. Erst das Schalten in den SQL-Modus lüftet das Geheimnis.<\/p>\n
Sie können direkt auch mehrere Tabellen oder Abfragen in einer UNION-Abfrage<\/b> zusammenführen.<\/p>\n
Alle für unsere Zielabfrage benötigten Adresstabellen fügen sich so aneinander:<\/p>\n
SELECT * FROM tblAdressen1\r\nUNION\r\nSELECT * FROM tblAdressen2\r\nUNION\r\nSELECT * FROM tblAdressen3\r\nUNION\r\nSELECT * FROM tblAdressen4<\/pre>\n
Im Ergebnis stehen damit alle Adressen aller Postleitzahlenbereiche bereit.<\/p>\n
Wie viele Tabellen in einer UNION-Abfrage<\/b> eingebaut sein dürfen, steht nicht eindeutig fest. An sich gibt es die Aussage von Microsoft, dass eine Abfrage nicht mehr als 32 Tabellen enthalten darf. Entweder ist diese Information veraltet und spiegelt nicht mehr die Eigenschaften der Access Database Engine<\/b> wider, oder für UNION<\/b> gelten andere Regeln. Jedenfalls gelang es uns problemlos, auch 49 Adresstabellen aneinanderzufügen. Erst bei 50 und mehr kam es zur Fehlermeldung<\/p>\n
Ausdruck oder Abfrage zu komplex<\/pre>\n
Es dürfte auch von der Anzahl der Felder der Quelltabellen abhängen, wann diese Meldung auf den Plan tritt.<\/p>\n
übrigens können sie die gleiche Tabelle auch mehrmals mit sich selbst kombinieren:<\/p>\n
SELECT * FROM tblAdressen1\r\nUNION\r\nSELECT * FROM tblAdressen1<\/pre>\n
Man sollte hier erwarten, dass sich die Zahl der Datensätze gegenüber tblAdressen1<\/b> verdoppelt. Tatsächlich ist das nicht der Fall!<\/p>\n
Der Grund dafür ist, dass Access im Ergebnis keine doppelten identischen Datensätze ausgibt, also zusätzlich ein DISTINCT<\/b> ausführt. Der Ausdruck UNION<\/b> bekommt damit ja auch die korrekte Bedeutung: Das Ergebnis ist die Mengensumme<\/b> beider Tabellen! Allerdings können Sie dies aufheben, indem Sie nach UNION<\/b> noch das Prädikat ALL<\/b> setzen:<\/p>\n
SELECT * FROM tblAdressen1\r\nUNION ALL\r\nSELECT * FROM tblAdressen1<\/pre>\n
In diesem Fall werden tatsächlich alle Ausgangsdatensätze aneinander gereiht. Vorteil dieser Variante ist die bessere Performance. Access muss hier lediglich die Datensätze summieren, während ohne ALL<\/b> noch die überprüfung auf Doppelungen stattfindet.<\/p>\n
Sortierung und Filterung<\/h2>\n
Die kombinierten Datensätze können gleich innerhalb der UNION-Abfrage <\/b>sortiert und gefiltert werden, indem die normalen ORDER BY<\/b>-Statements oder WHERE<\/b>-Bedingungen ans Ende des SQL-Ausdrucks gestellt werden:<\/p>\n
SELECT * FROM tblAdressen1\r\nUNION\r\nSELECT * FROM tblAdressen2\r\nUNION\r\nSELECT * FROM tblAdressen3\r\nWHERE PLZ LIKE \"1*\"\r\nORDER BY Nachname;<\/pre>\n
Die drei Quelltabellen werden kombiniert und das Ergebnis schließlich der Filterung nach Postleitzahlengebiet 1 unterzogen, sowie aufsteigend nach Nachname sortiert.<\/p>\n
Welche Anforderungen bestehen an die Ausgangstabellen<\/h2>\n
Die wichtigste Anforderung ist, dass die Zahl der Felder jeder Tabelle oder Abfrage übereinstimmen. Das gilt indessen nicht für die Namen der Felder. Auch der Datentyp spielt keine Rolle. Versuchen Sie etwa dies:<\/p>\n
SELECT Nachname FROM tblAdressen1\r\nUNION\r\nSELECT PLZ FROM tblAdressen2<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t