SQL mit SAS: Band 1: PROC SQL für Einsteiger 9783486704563, 9783486598407

Citation preview

SQL mit SAS Band 1: PROC SQL für Einsteiger

von

Dr. Christian FG Schendera

Oldenbourg Verlag München

Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. © 2011 Oldenbourg Wissenschaftsverlag GmbH Rosenheimer Straße 145, D-81671 München Telefon: (089) 45051-0 www.oldenbourg-verlag.de Das Werk einschließlich aller Abbildungen ist urheberrechtlich geschützt. Jede Verwertung außerhalb der Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlages unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Bearbeitung in elektronischen Systemen. Lektorat: Kristin Beck Herstellung: Constanze Müller Titelbild: Flávio Takemoto, www.sxc.hu Einbandgestaltung: hauser lacour Gesamtherstellung: Grafik + Druck GmbH, München Dieses Papier ist alterungsbeständig nach DIN/ISO 9706. ISBN 978-3-486-59840-7 eISBN 978-3-486-70456-3

Vorwort SQL (Structured Query Language) ist die am weitesten verbreitete Programmiersprache für relationale Datenbanken. Weltweit. Eine Websuche ergibt für keine andere Programmiersprache mehr Treffer als für SQL. Google erzielte Anfang Juni 2010 z.B. 135 Millionen Treffer, Yahoo sogar 473 Millionen Treffer. Die Prognosen aller großen IT Consulting Unternehmen laufen darauf hinaus, dass die künftig anfallenden Datenmengen exponentiell zunehmen werden. Man bedenke, dass wir uns gegenwärtig bereits in Größenordnungen wie Tera- oder immer häufiger im Petabyte-Bereich bewegen. Für praktisch jeden Bereich werden diese Datenlawinen erwartet bzw. sind sogar schon Realität geworden. Im Bereich des CRM fallen z.B. ungeheure Datenmengen zu Konsumentenverhalten oder Produktperformanz an. Einzelne Anbieter berichten dabei alleine für Web-Transaktionen ein Datenvolumen im Petabyte-Bereich. Vom Data Warehouse von eBay ist z.B. bekannt, dass es über 17 Trillionen Zeilen enthält und um 150 Milliarden Zeilen pro Tag größer wird. Der Sloan Digital Sky Server (http://cas.sdss.org/public/de bzw. http://cas.sdss.org/astrodr7/en) speichert z.B. Daten und Bilder von hunderten Millionen von Himmelskörpern. Der Anspruch des SDSS ist nichts anderes, als den Himmel zu kartieren. Die Abfrage dieser Informationen erfolgt über SQL direkt auf der SDSS-Webseite. Im Bereich der Mediennutzung fallen Daten darüber an, wer wann welches Medium (Radio, Fernsehen, mobile Endgeräte) auf welchem Kanal (Sender, Programm usw.) wie lange genutzt hat. Im Bereich der Telekommunikation fallen analog ungeheure Mengen an Telefoniedaten an, im Bereich Finance Daten von Kontobewegungen. Versicherungen führen z.B. Data Warehouses mit Rohdaten von Millionen Versicherten. Im Bereich Logistics fallen u.a. (Geo)Daten zu Sendungen (Registrierung, Bündelung, Transport, Auslieferung) an. SQL gilt als die Programmiersprache, die in der Lage ist, effizient mit diesen oder noch größeren Datenmengen umzugehen. SQL entwickelte sich in kürzester Zeit nach seiner Erfindung zu einem Quasi-Standard für den Umgang mit großen und sehr großen Datenmengen. Gründe sind u.a. die damals rasche Verbreitung von Datenbanken seit den 70er Jahren, die weitgehende Unabhängigkeit von Hersteller und Software, die tagtäglich bewiesene Performanz sowie seine Beliebtheit bei den Anwendern. Mit der Verbreitung von Datenbanken und der Zunahme der Datenmengen wuchs zugleich die Bedeutung der Rolle der Analysten und Programmierer. Ihre Hauptaufgaben sind das Programmieren von Abfragen auf große, oft verteilte Datenmengen, das Management von und den Zugriff auf Daten sowie die Analyse von Daten in Form von Kennzahlen, Tabellen oder auch komplexeren Reports. Für Analysten und Programmierer war und ist an SQL als Standard attraktiv, dass einmal erworbene SQL Kompetenzen in allen denkbaren Umgebungen angewandt werden können, von Open Source bis hin zu kommerziellen Systemen. Was man einmal z.B. für das SQL in Oracle (im Rah-

VI

Vorwort

men des ANSI Standards) lernte, konnte man damit auch auf das SQL in SAS oder Teradata etc. anwenden. Erfahrungsgemäß werden daher in den meisten Positionen, die mit dem Management oder der Analyse von Daten zu tun haben, mindestens Grundkenntnisse in SQL erwartet. Je nach ausgeschriebener Analystenposition kann durchaus bereits anspruchsvolleres SQL Knowhow erforderlich sein, u.a. zu Themen wie Makroprogrammierung, Effizienz oder auch speziellen Anwendungen, z.B. Integrity Constraints. Dieses Buch ist Teil I von zwei Bänden. Dieser Band wird in die Grundlagen des Programmierens mit SQL einführen. Dieses Buch führt ein in die Programmierung von Abfragen (Queries), Views und Tabellen mit SQL von SAS. SQL ist, besonders in der SAS Variante, eine ausgesprochen leistungsfähige Programmiersprache. Mit PROC SQL ist u.a. möglich: Werte in SAS Tabellen aktualisierenkomplexe Berechnungen (neuer Variablen) durchführen, zusammenfassende Parameter bzw. Statistiken erzeugenautomatische Prüfungen auf Datenintegrität vorzunehmen, Daten aus Tabellen oder Views abfragenTabellen, Views, neue Variablen und Indexe anlegen und vieles andere mehr. Schnellfinder: Kapitel

Stichwort

Steckbrief bzw. Übersicht

1

Einführung

Grundlegende Bedeutung von SQL

2

Einführung (Theorie)

Erste Schritte und Grundoperationen

3

Syntax (Theorie)

Übersicht der SQL Syntax in SAS

4

Praxis der Programmierung

Programmierung von Queries

5

Praxis der Programmierung

Arbeit mit einer Tabelle

6

Praxis der Programmierung

Arbeit mit zwei Tabellen: Verbinden von zwei Tabellen (One-to-One-Szenario)

7

Praxis der Programmierung

Arbeit mit zwei Tabellen (und mehr): Komplexere Szenarien und Joins

8

Fokus

Deskriptive Statistik als das Fundament jeder professionellen Analyse von Daten

9

Fokus

Hilfen, Tipps und Tricks

10

Fokus

Übungsaufgaben

11

Verwendete SAS Datensätze

12

Literatur

13

Ihre Meinung zu diesem Buch

14

Autor

15

Syntaxverzeichnis

16

Sachverzeichnis

Vorwort

VII

Die Kapitel 1 und 2 sind Einführungskapitel und führen in die Bedeutung von SQL und erste Schritte mit PROC SQL ein. Kapitel 1 geht auf die grundlegende Bedeutung von SQL (Structured Query Language) ein. Kapitel 2 stellt erste Schritte und zahlreiche Grundoperationen vor. Kapitel 3 ist ein Syntaxkapitel und erläutert die SQL Syntax in der Version SAS 9.1.3, teilweise bereits SAS 9.2, systematisch und vollständig. Es werden auch derzeit nicht dokumentierte PROC SQL Funktionen wie z.B. _METHOD und _TREE vorgestellt. Die Kapitel 4 bis 7 sind Programmierkapitel und veranschaulichen die Programmierung von (Sub)Queries (Kap. 4), die Arbeit mit einer Tabelle (Kap. 5), und mit zwei oder mehr Tabellen (Kap. 6, 7). Die weiteren Kapitel sind Fokuskapitel. Fokuskapitel vertiefen besondere Themen der Arbeit mit SQL: Der Fokus von Kapitel 8 ist z.B. die Deskriptive Statistik. Der Fokus von Kapitel 9 sind Hilfen, Tipps und Tricks in SQL, u.a. die Optionen FEEDBACK und VALIDATE zum Verstehen und Testen von SQL Syntax. Der Fokus von Kapitel 10 sind Übungsaufgaben zu Daten erfolgreicher Kinofilme und ihre Lösung mit PROC SQL. Die Kapitel 11 bis 14 enthalten Ausschnitte der verwendeten SAS Datasets, die Literatur, die Möglichkeit zur Rückmeldung Ihrer Meinung zu diesem Buch, eine Kurzvorstellung des Autors sowie abschließend die Verzeichnisse zur SAS Syntax und zu den Stichworten. Die Form der separaten Darstellung von Syntax-Theorie und Praxis-Beispielen der praktischen Anwendung wurde von mir deshalb gewählt, damit die Syntax überschaubar bleibt, was für das schnelle Nachschlagen immer möglich sein sollte. Durch die zahlreichen Beispiele war eine übersichtliche Darstellung der SQL Syntax nicht mehr zu gewährleisten. Hätten umgekehrt Anwender nur die benötigte Syntax gefunden, so wären sie erfahrungsgemäß nicht bloß an einem einzelnen idealtypischen Anwendungsbeispiel interessiert, sondern vor allem auch an Beispielen, an denen allzu schnell begangene Fehler, Sonderfälle oder pfiffige Lösungsvarianten häufig vorkommender Fragestellungen demonstriert werden. Durch den Umfang der Praxis-Kapitel war es unvermeidlich, dass unter der Menge der Anwendungsbeispiele wiederum die Überschaubarkeit der Theorie der SQL Syntax als solche leiden würde. Ich habe mich daher entschlossen, in Kapitel 3 und 4 bis 7 konsequent zwischen Theorie (Syntax) und Praxis des Programmierens mit SQL zu unterscheiden. Diese Trennung soll einerseits eine Übersicht über die SQL Syntax erleichtern, andererseits aber auch eine praxisorientierte Vertiefung der Anwendung der jeweiligen SQL Elemente. Ich verbinde damit die Hoffnung, dass gerade diese Form der Darstellung dem Anwender die Aneignung von Theorie und Praxis von SQL erleichtert. Für Rückmeldungen dazu bin ich dankbar. Ausführliche Beschreibung Kapitel 1 geht auf die grundlegende Bedeutung von SQL (Structured Query Language) ein. Die große Bedeutung von SQL rührt daher, dass SQL wegen seiner ANSI Konformität eine weitgehende Unabhängigkeit von Hersteller und Software ermöglicht. Dies bedeutet für Anwender und Leser zweierlei: Was Sie jetzt für das SQL für SAS lernen, können Sie auch auf SQL für MySQL usw. anwenden. Dies ist dadurch möglich, eben weil SQL ein Standard ist. Mittels ANSI-konformem SQL können auch Programme geschrieben werden, die vom Datenbanksystem unabhängig sind. Ein Programm, das z.B. mit einem ANSI-konformen SQL geschrieben wurde, funktioniert u.a. auch auf Oracle, IBM oder auch Teradata. Kapi-

VIII

Vorwort

tel 1 erläutert auch grundlegende Terminologien und Konzepte. Je nach Anwendungsbereich (SQL, SAS Base oder auch RDBMS) wird oft eine andere Nomenklatur für Datendatei, Datenzeile oder auch Datenspalte verwendet. Die anfangs oft ungewohnt heterogene Terminologie wird geklärt, um das Risiko für Missverständnisse von Anfang an auf ein Minimum zu reduzieren. Ein weiterer Abschnitt erläutert das Konzept des sog. Schlüssels und darin die Unterscheidung zwischen Primär- und Fremdschlüssel (Primary Key, Foreign Key). Ein Schlüssel dient i.A. weniger zur Beschreibung als zur Identifikation von Datenzeilen. Wie viele andere SQL Varianten entspricht auch das SQL von SAS nicht uneingeschränkt dem aktuellen ANSI Standard. Ein weiterer Abschnitt beschäftigt sich daher mit den Unterschieden von PROC SQL zum ANSI Standard. Als bedeutende (konzeptionelle) Abweichung wäre z.B. der Umgang mit Missings in PROC SQL zu nennen, demgegenüber auch die Makrofähigkeit von PROC SQL, wie auch, dass PROC SQL deutlich mehr Auswertungsfunktionen als der ANSI Standard unterstützt. Die weiteren Ausführungen behandeln weitere grundlegende Konzepte. Allen voran werden Gemeinsamkeiten und Unterschiede zwischen Tabellen, Views und Abfragen im Hinblick auf Funktion, Inhalt und Speicherplatz erläutert und die damit ebenfalls einhergehenden Anforderungen an ihre jeweilige Programmierung mit PROC SQL (Programmierkonvention). Kapitel 2 stellt erste Schritte mit SQL vor. Abschnitt 2.1 spielt an einer kleinen überschaubaren SAS Tabelle schrittweise durch, wie sich eine SAS Tabelle in Struktur und Inhalt ändert, wenn die SQL Syntax Schritt für Schritt um kleine, aber wichtige Optionen variiert wird. Abschnitt 2.2 stellt zahlreiche weitere Grundoperationen vor, darunter u.a. das Anlegen einer temporären bzw. permanenten Tabelle, die Abfrage aller oder nur bestimmter Spalten (Variablen) sowie auch das gleichzeitige Berechnen weiterer Variablen. Weitere wichtige Beispiele für spezielle Anwendungen von PROC SQL sind z.B. das Erzeugen eines Kartesischen Produktes oder das Vermeiden bzw. das Zulassen von sog. rekursiven Referenzen. Der nächste Abschnitt könnte für Anwender interessant sein, die neu in SQL oder der Programmierung sind. Abschnitt 2.3 stellt mit dem SQL Query Window einen unkomplizierten Einstieg in das Erstellen von Abfragen mit SQL vor. Das SQL Query Window ist ein mausgesteuertes, interaktives Menü, mit dem u.a. SQL Abfragen unkompliziert per Mausklick erstellt, gespeichert und ausgeführt werden können. Als Beispiele werden das Erstellen einer SQL Abfrage und das Joinen zweier Tabellen erläutert. Abschnitt 2.4 hebt die diversen Unterschiede zwischen SAS Tabellen und SAS Views hervor. Abschnitt 2.5 ist für SAS Base Programmierer gedacht, die sich einen ersten Eindruck von Unterschieden in Programmierung, Anwendungen und Effizienz im Vergleich zu SAS Base verschaffen wollen. Weitere Unterabschnitte werden zeigen: Programmierung derselben Anforderung (z.B. wenn-dannBedingung), jeweils mit SAS Base (DATA Step) und PROC SQL, sowie Unterschiede in den Programmierkonventionen, wie auch ggf. Hinweise auf mögliche Unterschiede in der Performanz von SAS Base und PROC SQL. Der Leistungsumfang bzw. die Differenziertheit des SQL von SAS geht oftmals über den ANSI Standard hinaus. Abschnitt 2.6 hebt hervor, inwieweit PROC SQL von den ANSI Richtlinien für SQL abweicht, z.B. im Hinblick auf Missings bzw. die dreiwertige Logik. Kapitel 3 ist ein Syntaxkapitel. Kapitel 3 stellt die SQL Syntax in der Version SAS 9.1.3, teilweise bereits SAS 9.2, systematisch und vollständig vor. Es werden auch derzeit nicht dokumentierte PROC SQL Funktionen wie z.B. _METHOD und _TREE vorgestellt. Für

Vorwort

IX

jeden Ausdruck und jedes Syntaxelement einschließlich SQL Bedingungen und Funktionen wird die grundlegende Funktionsweise in der Theorie vorgestellt. Praktische Anwendungen und SAS Ausgaben der SQL Syntax werden anhand unzähliger Beispiele in den nachfolgenden Kapiteln vertiefend veranschaulicht. Kapitel 4 fokussiert bei Erläuterung der Syntaxelemente die Arbeit mit Queries, Kapitel 5 die Arbeit mit einer Tabelle. In die Arbeit mit zwei und mehr Tabellen (z.B. mittels des Tabellen-Join) wird ab Kapitel 6 eingeführt. Abschnitt 3.1 stellt die Ausdrücke in PROC SQL vor. Zu den Ausdrücken gehören u.a. der SQL Ausdruck, Tabellen-Ausdruck und Query-Ausdruck. Ein SQL Ausdruck ermittelt z.B. einen oder mehrere Werte durch eine Abfolge aus Operatoren und Operanden. Beispiele für Operanden sind z.B. eine SAS Funktion, eine ANSI SQL Funktion (z.B. COALESCE, BTRIM, SUBSTRING) oder eine Auswertungsfunktion. Ein Tabellen-Ausdruck fragt Daten aus Tabellen ab. Ein Tabellen-Ausdruck besteht oft nur aus einem SELECT-Statement. Ein QueryAusdruck umfasst dagegen mindestens einen Tabellen-Ausdruck und verbindet eine Tabelle mit anderen oder mit sich selbst. Ein Query-Ausdruck ist somit auch die Methode des Verknüpfens der Abfragen aus zwei oder mehr Tabellen bzw. auch einer Tabelle in Bezug auf sich selbst. Vorgestellte Methoden sind dabei Reflexive Joins, Inner Joins, Outer Joins (Left, Right), Cross Joins, Union Joins und auch Natural Joins. Abschnitt 3.2 stellt die SQL Syntax in einer ersten Übersicht vor. Ein Schnellfinder hilft dabei, für den gewünschten Zweck schnell das richtige SQL Statement zu finden, z.B. UPDATE für das Aktualisieren von Werten oder SELECT für das Auswählen. Abschnitt 3.3 stellt weitere Ausdrücke, Bedingungen und Funktionen der PROC SQL Prozedur vor, z.B. die Auswertungsfunktion, die BETWEEN-Bedingung, CALCULATED und viele andere mehr. Ausdrücke, Bedingungen und Funktionen werden jeweils anhand von vier Informationen vorgestellt: Kurzbeschreibung, Syntax, Programmierbeispiel und ggf. Details. Ein Exkurs behandelt das sog. „Remerging“ bzw. die „Wiederzusammenführung“. Hinweise verweisen ausdrücklich auf Besonderheiten oder mögliche Einschränkungen, z.B. dass Klauseln im SELECT-Statement in der Reihenfolge FROM vor WHERE vor GROUP BY vor HAVING usw. angegeben werden müssen. Zur Ergänzung wird allen Lesern vor der Umsetzung der Theorie in die Praxis die Auseinandersetzung mit dem Umgang mit Missings durch PROC SQL dringlich empfohlen. Kapitel 4 behandelt Abfragen (Queries). Queries sind definiert als eine spezifische Zusammenstellung an Bedingungen, fragen auf diese Weise die gewünschten Daten oder statistischen Parameter aus einzelnen oder mehreren Views, Tabellen oder Datenbanken ab und zeigen diese automatisch an, z.B. in der SAS Ausgabe. Queries legen dabei zunächst keine SAS Datei bzw. View an. Bevor in Beispiele für verschachtelte bzw. genestete Queries eingeführt wird, wird auf Besonderheiten in Logik, Programmierung und Ausführung hingewiesen, z.B. sog. (eine oder mehrere) Subqueries (Unterabfragen). Eine Subquery ist eine Abfrage, die wiederum innerhalb einer anderen Abfrage eingebettet ist. Bei mehreren Subqueries wird zunächst die innerste ausgeführt, danach alle weiteren in Richtung der äußersten (Sub)Query. Abschnitt 4.1 stellt Queries vor, die sich auf einen SAS Datensatz beziehen. Abschnitt 4.2 stellt Queries für den Bezug auf mehrere Tabellen vor. Subqueries werden in den Abschnitten 5.4 und 6.4 vertiefend behandelt. Am Anfang dieses Kapitels findet der Leser auch eine Übersicht der wichtigsten Symbole und mnemonischen Äquivalente (sofern vorhanden) für Operatoren, z.B. für den Vergleich von Werten (z.B. =, !, >= usw. ) oder auch für den Vergleich von Strings (z.B. EQT, NET, GTT usw.).

X

Vorwort

Kapitel 5 behandelt die Arbeit mit einer Tabelle. Jedes Element der SQL Syntax wird anhand der Funktionsweise zahlreicher SQL Beispiele erläutert. Die Kombination und Komplexität der Anwendungsbeispiele geht über die SQL Syntax hinaus, so wie sie in Kapitel 3 vorgestellt wurde. Für die Anwendungsbeispiele wird, falls erforderlich, auch der SAS Output angezeigt und erläutert. Zur Erläuterung der grundlegenden Funktionsweise wird auf Kapitel 3 verwiesen. Dieses Kapitel beschränkt sich auf Anwendungsbeispiele für eine Tabelle; in die Arbeit mit zwei und mehr Tabellen (z.B. mittels des Joins) wird in den nachfolgenden Kapiteln eingeführt. Abschnitt 5.1 enthält für jedes Element der SQL Syntax ein oder mehrere Beispiele. Die Beispiele sind alphabetisch nach der unter Kapitel 3 vorgestellten SQL Syntax von ALTER TABLE bis VALIDATE geordnet. Abschnitt 5.2 vertieft Grundoperationen und Berechnungen am SELECT-Statement. Die Abfolge der Beispiele zu den im folgenden vorgestellten Klauseln entspricht der Reihenfolge, wie sie im SELECT-Statement verwendet werden sollen, von FROM vor WHERE vor GROUP BY vor HAVING usw. Darüber hinaus wird auf diverse Empfehlungen für das Schreiben performanter WHERE-Klauseln verwiesen. Als Grundoperationen werden u.a. das Selegieren vorhandener oder das Anlegen neuer Spalten, die Abfrage bestimmter Ausprägungen von Strings, numerischen Werten oder Datumsvariablen, das Neuanlegen von kategorial skalierten Variablen/Spalten über Bedingungen und das Gruppieren / Sortieren von Tabellen, sowie das Sortieren mit Platzhalter anhand mehrerer Syntax-Beispiele behandelt. Als Berechnungen werden u.a. das Zählen von Werten bzw. Zeilen, das Ermitteln von Durchschnittswerten von Werten bzw. Zeilen, Prozentwertberechnungen, sowie die Berechnung gruppierter aggregierter Werte, und das zeilenweise Filtern mit oder auch ohne Aggregierungsfunktion anhand mehrerer SyntaxBeispiele vorgestellt. Abschnitt 5.3 behandelt vertiefend Berechnungen und Aktualisierungen mit CASE. Ein CASE/END-Ausdruck wird z.B. oft (aber nicht ausschließlich) für die Umsetzung einer WHEN-THEN-ELSE Bedingungsabfolge verwendet. UPDATE/CASEBeispiele werden für das bedingte Aktualisieren von Werten vorgestellt, u.a. wie eine einzelne Variable anhand zahlreicher Bedingungen durchaus komplex und vielschichtig aktualisiert werden kann. Abschnitt 5.4 behandelt Subqueries (Kapitel 4 führt in (Sub)Queries ein). Dieser Abschnitt vertieft dieses Thema. Eine Subquery kann sich auf eine oder mehrere Tabellen beziehen und je nach Klausel einen oder mehrere Werte zurückgeben, die dann von der nächstäußeren Query weiterverarbeitet werden. (Sub)Queries können auch mehr als eine Subquery enthalten. Vorgestellt werden u.a. dieselbe Abfrage als multiple (temporäre) Queries, WHERE- und HAVING-Bedingung, korrelierte Subqueries, oder konditionale Operatoren mit HAVING oder WHERE, sowie Subqueries in Kombination mit diversen Klauseln und Bedingungen. Da Subqueries i.A. als nicht besonders performant gelten, wäre zu prüfen, ob sie nicht in einfachere bzw. performantere Queries umgeschrieben werden können. Abschnitt 5.5 behandelt Self-Joins (Reflexive Joins). Wird eine Tabelle mit sich selbst oder anderen Tabellen gejoined, wird dies als Self-Join oder auch als Reflexive Join bezeichnet. Eine Besonderheit des Self-Joins ist, dass in der FROM-Klausel dieselbe Tabelle zweimal aufgeführt wird, einmal als Tabelle und einmal als Kopie. Zwei der vorgestellten Beispiele behandeln das Matchen von Wertepaaren für Fall-Kontroll-Analysen (Case Control Studies). Abschnitt 5.6 behandelt abschließend eine weitere Möglichkeit der Arbeit mit einer Tabelle, die nicht eindeutig einem der vorangehenden Abschnitte zugeordnet werden konnte, nämlich die Definition neuer Variablen im SELECT-Statement. Dieses Kapitel konzentriert sich auf

Vorwort

XI

Anwendungsbeispiele für nur eine Tabelle; die beiden folgenden Kapitel behandeln die Arbeit mit zwei und mehr Tabellen. Kapitel 6 behandelt die Arbeit mit zwei Tabellen. Der Unterschied zum sich anschließenden Kapitel 7 ist, dass Kapitel 6 in das Joinen und Mergen von (nur) zwei Tabellen unter der Annahme eines One-to-One-Szenarios einführt. Bei einer One-to-One-Beziehung referenziert ein Fall in einer ersten Tabelle auf genau einen Fall in einer zweiten Tabelle, z.B. auf der Grundlage einer oder mehrerer Schlüsselvariablen. Eine One-to-One-Beziehung liegt dann vor, wenn im Falle einer einzelnen Schlüsselvariablen die Werte der Schlüsselvariablen in allen zusammenzufügenden Tabellen nur einmal auftreten bzw. im Falle mehrerer Schlüsselvariablen Kombinationen der Werte aller Schlüsselvariablen in allen zusammenzufügenden Tabellen nur einmal auftreten. Kapitel 7 ist dagegen den komplizierteren Szenarios Oneto-Many, Many-to-One und Many-to-Many vorbehalten. Ein erstes Beispiel erklärt an Äpfeln und Birnen, ob und wann Fälle aus zwei oder mehr Tabellen nicht „einfach so“ miteinander verknüpft werden können. Kapitel 6 führt zunächst in grundlegende Konzepte beim Zusammenfügen von Tabellen ein, u.a. Beziehung und Struktur der Tabellen (data relation, data structure), und auch die Art des Zugriffs (sequentiell oder direkt). Die Art der Beziehung zwischen zwei (oder mehr) Tabellen bestimmt auch die Methode ihres Zusammenfügens. Das „Untereinanderhängen“ von verschiedenen Fällen bei gleichen Variablen wird z.B. als Concatenating bzw. Interleaving bezeichnet. Das „Nebeneinanderstellen“ von verschiedenen Variablen bei gleichen Fällen wird z.B. als (One-to-One) Merging bezeichnet. Für diese beiden grundsätzlichen Herangehensweisen gibt es so viele Varianten, dass sich die Übergänge zwischen ihnen als fließend herausstellen werden. Anhand der One-to-One-Beziehung sollen nun die Grundmethoden des Zusammenfügens von Tabellen, ihre Besonderheiten, sowie erste SQL Operatoren dazu vorgestellt werden. Ausgehend von der One-to-OneBeziehung wird auch auf erste Besonderheiten eingegangen, die z.B. bei Doppelten oder Missings in einer oder mehreren Key-Variablen auftreten können. Auch werden drei Prüfschritte für das kontrollierte Zusammenfügen von Tabellen empfohlen. Abschnitt 6.1 stellt die Set Operatoren für das „Untereinanderhängen“ (z.B. Concatenating, Interleaving) von verschiedenen Fällen bei gleichen Variablen vor. Abschnitt 6.2 erläutert diverse Varianten für das „Nebeneinanderstellen“ (Joinen) von verschiedenen Variablen (bei gleichen Fällen): Equi-Joins, Inner Joins und Outer Joins. Abschnitt 6.3 stellt spezielle Joins vor, u.a. Joins zum Erzeugen von sog. Kartesischen Produkten. Behandelte Operatoren sind CROSS, NATURAL und UNION. Abschnitt 6.4 diskutiert Möglichkeiten mit Subqueries bei der Arbeit mit zwei Tabellen. (Korrelierte) Subqueries erlauben z.B. einen oder mehrere Werte aus einer ersten Tabelle (z.B. in der Subquery) zur Weiterverarbeitung (z.B. Filterung) der Daten einer zweiten Tabelle (z.B. in der Query) zu verwenden. Abschnitt 6.5 stellt diverse Möglichkeiten der Berechnung und Aktualisierung von Werten bei der Arbeit mit zwei Tabellen vor. Die Beispiele behandeln u.a. das Aktualisieren der Werte einer ersten Tabelle durch Werte einer zweiten Tabelle. Abschnitt 6.6 stellt abschließend vier allzu schnell übersehene Fehlerquellen bereits bei der Arbeit mit nur zwei Tabellen vor. Ein erstes Beispiel erläutert die Bedeutung der Anzahl und Abfolge der Sortier- bzw. Schlüsselvariablen für das Joinen von Tabellen. Ein zweites Beispiel veranschaulicht das Problem von Missings und doppelten Werten in einer Schlüsselvariablen. Zwei weitere Beispiele erläutern u.a. die Konsequenzen des Weglassens der Schlüsselwörter COALESCE bzw. CALCULATED beim Programmieren des Zusam-

XII

Vorwort

menfügens zweier Tabellen (oder mehr). Ein abschließendes Beispiel hebt das Problem der Missings bei der Arbeit mit Subqueries hervor. Kapitel 7 behandelt die Arbeit mit zwei Tabellen (oder mehr). Der zentrale Unterschied zum vorangegangenen Kapitel 6 ist, dass Kapitel 7 in die Besonderheiten des Joinens und Mergens von zwei Tabellen (oder mehr) einführt, falls kein One-to-One-Szenario vorliegt. Missings und doppelte Einträge in Primärschlüsseln können ein erfolgreiches Mergen beeinträchtigen. Dieses Kapitel konzentriert sich auf das zeilenweise Zusammenfügen mittels Join-Operatoren und einem Primärschlüssel. Hat die Überprüfung der zusammenzufügenden Tabellen ergeben, dass die Werte der Schlüsselvariablen bzw. ihre Kombinationen mehr als einmal auftreten, ist man bei den Datenbeziehungen des One-to-Many, Many-to-One oder Many-to-Many angelangt. Es hängt oft von mehreren Kriterien ab, ob und wie eine solche Datenstruktur zustande kommen kann, u.a. vom Typ der einzelnen Tabellen (one, many), der Abfolge der Tabellen in der FROM-Klauselund u.a. die Richtung des/der Joins (left, right, full). Anhand zweier Tabellentypen (ONE, MANY) werden zahlreiche Kombinationsmöglichkeiten durchvariiert. Bei dieser Gelegenheit werden auch die Konsequenzen der mehrfach auftretenden IDs und der (mehrfach auftretenden) Missings in einer ID hervorgehoben, die erfahrungsgemäß u.a. in eine unterschiedliche Anzahl an Zeilen und Abfolgen von Werten (Sortierungen) münden. Abschnitt 7.1 stellt zunächst die Besonderheiten beim One-toMany-Mergen u.a. an Inner und Outer Joins (left, right, full) vor. Abschnitt 7.2 veranschaulicht anschließend das Many-to-One-Mergen ebenfalls an Inner und Outer Joins (left, right, full). Abschnitt 7.3 behandelt das Many-to-Many-Mergen in derselben Systematik. Abschnitt 7.4 behandelt die Arbeit mit drei oder mehr Tabellen. Die konkrete Arbeit mit drei Tabellen und mehr unterscheidet sich außer in der zunehmenden Zahl der Tabellen (und der damit einhergehenden Komplexität) nicht bedeutsam vom Arbeiten mit „nur“ zwei Tabellen. Die Diskussion arbeitet für drei grundsätzlich unterschiedliche Szenarios die Besonderheiten für das Joinen von drei oder mehr Tabellen heraus:One-to-One (SAS Tabellen), Nicht One-toOne (One-to-Many, Many-to-One, Many-to-Many, SAS Tabellen), sowie Nicht SAS Tabellen. Dieser Abschnitt präsentiert u.a. SQL Beispiele für three-way joins, four-way joins, wie z.B. das Zusammenfügen von Daten in SAS, die aus Tabellen im Format Microsoft Excel und Lotus 1-2-3 extrahiert wurden. Kapitel 7.5 stellt abschließend Prüfregeln, Prüfschritte und von SAS bereitgestellte Hilfsmittel zum Zusammenfügen mehrerer Tabellen vor. Bei den Prüfregeln handelt es sich im Wesentlichen um Regeln, deren Prüfung und Einhaltung in der Verantwortung des Anwenders liegen. Abschließend findet der interessierte Leser eine Übersicht zu SAS Statements und Prozeduren für das Zusammenfügen von Tabellen. Kapitel 8 ist ein Fokuskapitel. Der Fokus dieses Kapitels ist die Deskriptive Statistik. Die deskriptive Statistik ist das Fundament jeder professionellen Analyse von Daten. Den einführenden Hinweisen auf eine notwendige Differenzierung wie z.B. zwischen Vollerhebungen oder Stichproben schließt sich Abschnitt 8.1 mit den notwendigen statistischen Grundlagen an. Abschnitt 8.1 erläutert die statistischen Grundlagen der gebräuchlichsten Lage- und Streuungsmaße. Lage- und Streuungsparameter beschreiben Daten aus unterschiedlichen Perspektiven: Lagemaße beschreiben das Zentrum einer Verteilung, Streuungsmaße beschreiben dagegen die Abweichung vom Zentrum einer Verteilung. Unterabschnitt 8.1.1 behandelt die Lagemaße Modus, Median, und Mittelwert. Unterabschnitt 8.1.2 behandelt die Streuungsmaße Spannweite (Range), Interquartilsabstand, Varianz, Standardabweichung und

Vorwort

XIII

Variationskoeffizient. Abschnitt 8.2 veranschaulicht die Berechnung von Lage- und Streuungsmaßen mittels PROC SQL (u.a. unter Zuhilfenahme mit CALL SYMPUTX bzw. SYMPUT). Abschnitt 8.3 stellt weitere Aggregierungsfunktionen in PROC SQL, z.B. COUNT, MIN/MAX, N, SUM usw. zur Aggregierung bzw. statistischen Beschreibung von Variablen vor. Abschnitt 8.4 behandelt die Berechnung von Prozent- und Quotientwerten. Letztlich ist es mit PROC SQL möglich, Häufigkeitstabellen mit Anteils- und Prozentwerten zu erzeugen, wie man sie z.B. von PROC FREQ her kennt. Abschnitt 8.5 geht abschließend auf das Rechnen mit Gewichten ein. PROC SQL bezieht standardmäßig jede Zeile bzw. Spalte mit dem Gewicht 1 in die Analyse ein. Dieser Abschnitt demonstriert, wie auch Werte von Gewichtungsvariablen in eine Analyse mit PROC SQL einbezogen werden können. Kapitel 9 ist ein Fokuskapitel. Der Fokus von Kapitel 9 sind z.B. Hilfen, Tipps und Tricks für speziellere Anforderungen in SQL: Abschnitt 9.1 stellt z.B. die beiden Optionen FEEDBACK und VALIDATE vor. FEEDBACK ist v.a. dann nützlich, wenn es notwendig ist, die Funktionsweise von prinzipiell funktionierenden, aber ggf. unverständlichen SQL Queries nachvollziehen zu können, die Dritte geschrieben haben. VALIDATE ist v.a. dann nützlich, wenn es erforderlich ist, selbstgeschriebene SQL Queries auf eine korrekte Funktionsweise zu prüfen, und sich erste Empfehlungen von SAS geben lassen zu können. Abschnitt 9.2 stellt z.B. die beiden nicht in SAS dokumentierten Optionen _METHOD und _TREE vor. Diese beiden Optionen zeigen an, wie der interne Optimierer die Join-Methoden auswählt und verarbeitet. Man versteht dadurch die intern ablaufenden SQL Prozesse des SAS Systems besser und erhält auch Hinweise, wie PROC SQL möglicherweise noch besser im Hinblick auf Performanz z.B. mittels der ebenfalls nicht dokumentierten SAS Optionen MAGIC und IDXWHERE optimiert werden könnte. Abschnitt 9.3 stellt diverse Tipps und Tricks für das Konvertieren vor, Funktionen und Komparatoren für die Arbeit mit Strings oder auch das Anlegen einer ID-Variablen mit der ebenfalls nicht dokumentierten SAS Funktion MONOTONIC und den damit verbundenen Tücken. Abschnitt 9.4 stellt zahlreiche Möglichkeiten für das Designen einer SQL Ausgabe vor, u.a. durch das Hinzufügen von Text(zeichen). Abschnitt 9.5 stellt das Output Delivery System (ODS) und darin v.a. die Ausgabe von SAS Tabellen und SQL Ausgaben in die unterschiedlichsten Formate vor (u.a. HTML, PDF, PostScript oder XML) oder auch Designs (Styles). Abschnitt 9.6 behandelt Möglichkeiten des Import und Export von Daten im Format Microsoft Excel. Kapitel 10 ist ein Fokuskapitel. Der Fokus von Kapitel 10 sind Übungsaufgaben und ihre Lösung mit PROC SQL. Die Aufgaben sind danach gestaffelt, ob sie zur Lösung eine (vgl. 10.1) oder zwei Tabellen (vgl. 10.2) erfordern. Lösungsvorschläge sind in Abschnitt 10.3 zusammengestellt. Die Beispiele basieren auf realen Daten zu den zehn erfolgreichsten Kinofilmen weltweit (u.a. Rangplatz, Titel, Regisseur, Einspielergebnis uvam.). Die Kapitel 11 bis 14 enthalten Ausschnitte der verwendeten SAS Datasets, die Literatur, die Aufforderung zur Rückmeldung Ihrer Meinung zu diesem Buch, eine Kurzvorstellung des Autors sowie abschließend die Verzeichnisse zur SAS Syntax und zu den Stichworten. Am Ende dieses Buches sollten Sie die grundlegende Bedeutung von SQL kennen, mittels SQL Syntax (Sub)Queries, und mit einer, zwei oder auch mehr Tabellen (in unterschiedlichen Formaten) programmieren können. Übungsaufgaben meistern Sie ebenso wie die deskriptive Statistik. Sie wenden auch SAS Optionen u.a. zum Verstehen und Testen von SQL

XIV

Vorwort

Syntax kompetent an. Auch sind Sie in der Lage, einen Join-Algorithmus zu optimieren. Sie kennen diverse Mittel und Wege zum Designen einer SQL Ausgabe und setzen auch erste Möglichkeiten des Output Delivery System (ODS) ein. Hat Sie dieses Buch auf SQL und SAS so neugierig gemacht, dass Sie weitermachen wollen, dann könnten Sie möglicherweise die folgenden Hinweise interessieren. Der Leistungsumfang und die umfangreichen Anwendungsmöglichkeiten von SAS führten dazu, dass sich diesem ersten (einführenden) Band ein zweiter Band anschließen wird: Band I versteht sich als Übersicht und Einführung in SQL (Structured Query Language) und ist für Einsteiger in SQL gedacht. Schritt für Schritt wird der Anwender von einfachen Beispielen (per Maus abgefragt oder mit SQL Syntax geschrieben) zu komplexen Arbeiten innerhalb einer oder zwei oder mehr Tabellen einschließlich One-to-Many, Many-to-One und Many-to-Many geführt. SQL ist ein Quasi-Industriestandard. Es wurde versucht, Band I so allgemein zu halten, dass die Beispiele auch in anderen DBMS eingesetzt werden können. Wenige Ausnahmen kann es dann geben, sobald es sich um besondere SQL Funktionalitäten des Anbieters SAS handelt, z.B. beim Einbinden von SAS Funktionen oder SAS Makros. Band II ist für Fortgeschrittene in PROC SQL geschrieben. Ein wichtiges Kapitel in diesem Band ist der Umgang von PROC SQL mit Missings (Nullwerten), da das SQL von SAS mit Missings anders als der ANSI Standard umgeht. Das Nichtberücksichtigen dieser Besonderheiten kann zu möglicherweise unerwünschten Ergebnissen beim Umgang mit Missings führen. Ein weiteres Kapitel beschäftigt sich mit Datenqualität, darin vor allem (aber nicht nur) mit Integrity Constraints (Prüfregeln), wie auch Besonderheiten im Umgang mit fehlenden Werten (Missings). Besonders wichtig sind die beiden weiteren Kapitel, da sich Anwender mit ihrer Hilfe die Power von SAS zunutze machen können. Das Kapitel zur Makroprogrammierung beschreibt beispielsweise, wie mittels des listenweisen Ausführens von Befehlen die Arbeit mit SAS sowohl bei der Programmierung, wie auch bei der Ausführung von Programmen um ein Vielfaches beschleunigt werden kann. Das Kapitel zu Performanz und Effizienz stellt diverse Möglichkeiten zusammen, wie gerade beim Umgang mit sehr großen Datenmengen noch mehr an Performanz aus SQL Programmen bzw. dem System herausgeholt werden kann. Ein weiteres Kapitel ist Übersichten zur SQL Syntax, SAS Funktionen und Funktionsaufrufen vorbehalten, sowie diversen Besonderheiten der SAS Pass-though Facility für ausgewählte DBMS Zugriffe. Weil Band II den Einsatz vieler Features von SAS zum Thema hat, ist Band II vorrangig für Nutzer von SAS geschrieben, wie auch Interessierte, die sich einen tieferen Einblick in die SAS Power verschaffen möchten. Zu Dank verpflichtet bin ich für fachlichen Rat und/oder auch einen Beitrag in Form von Syntax, Daten und/oder auch Dokumentation unter anderem: Prof. Gerd Antos (MartinLuther-Universität, Prof. Mark Galliker (Universität Bern, Schweiz), Prof. Jürgen Bock, Prof. Rainer Schlittgen, den Austausch auf SAS-L: z.B. Richard R. Allen, Michael Bramley, Dave Brewer, Nancy Brucken, David Carr, David Cassell, Laurel A. Copeland, Peter Crawford, Richard DeVenezia, Paul M. Dorfman, Harry „Bill“ Droogendyk, Ron Fehd, Y. (Jim) Groeneveld, Gerhard Hellriegel, Sigurd Hermansen, Eric Hoogenboom, Ya Huang, Nick Longford, Gene Maguin, Dale McLerran, Lawrence H. Muhlbaier, Girish S. Patel, Prasad S. Ravi, Kattamuri Sarma, Howard Schreier, Karsten M. Self, Daniel Sharp, Erik Tilanus, Michel Vaillant, Kevin Viel, Ian Whitlock, John Whittington, Andre Wielki, Matthew M. Zack,

Vorwort

XV

und last but not least die Helden vom German First Level Support bei SAS in Heidelberg und Cary NC. Mein Dank gilt Wilhelm Petersmann und Markus Grau von SAS Switzerland (Brüttisellen) für die großzügige Bereitstellung von SAS Software und technischer Dokumentation. Herrn Dr. Schechler, Frau Dr. Autenrieth, Frau Kristin Beck und Frau Cornelia Horn vom Oldenbourg Verlag danke ich für das Vertrauen, auch dieses Buch zu veröffentlichen, sowie die immer großzügige Unterstützung. Volker Stehle (Eppingen) gestaltete die Druckformatvorlage. Stephan Lindow (Hamburg) entwarf die Grafiken. Falls in diesem Buch noch irgendwas unklar oder fehlerhaft sein sollte, so liegt die Verantwortung alleine beim Autor. An dieser Stelle möchte ich mich auch auf die positiven Rückmeldungen und Vorschläge zu meinen weiteren Veröffentlichungen bei Oldenbourg bedanken, u.a. zur Clusteranalyse (2009), Regressionsanalyse (2008), zur Datenqualität (2007) sowie grundlegend zur Datenanalyse und Datenmanagement mit dem SAS System (2004). Die wichtigsten Rückmeldungen, Programme und auch Beispieldaten stehen auf der Webseite des Autors www.methodconsult.de zum kostenlosen Download bereit. Hergiswil, September 2010 Dr. CFG Schendera

Inhalt Vorwort

V

1

SQL (Structured Query Language)

1

2

Erste Schritte mit PROC SQL

9

2.1

Variationen eines Beispiels: Abläufe innerhalb einer Tabelle.....................................9

2.2

Von hier aus weiter: Beispiele für grundlegende SQL Anwendungen......................14

2.3

SQL per Mausklick mit dem SQL Query Window...................................................20

2.4

Unterschiede zwischen SAS Tabellen und SAS Views ............................................26

2.5 2.5.1 2.5.2 2.5.3

PROC SQL für SAS Base Programmierer ...............................................................27 Programmierbeispiele: SAS Base vs. PROC SQL ...................................................27 Unterschiede in den Programmierkonventionen ......................................................34 Performanz: „Es kommt darauf an“ .........................................................................36

2.6

PROC SQL und der ANSI Standard.........................................................................37

3

Elemente der PROC SQL Syntax: Übersicht

3.1

Ausdrücke (SQL, Tabelle, Query, Joins) ..................................................................42

3.2

SQL Syntax: Struktur und Übersicht........................................................................47

3.3

Weitere SQL Ausdrücke, Bedingungen und Funktionen ..........................................52

4

Queries: Verschachtelte bzw. genestete Abfragen (Tabellen)

4.1

Bezugnahme auf eine Tabelle...................................................................................65

4.2

Bezugnahme auf mehrere Tabellen ..........................................................................70

5

Arbeiten innerhalb einer Tabelle

5.1

SQL Syntax in der Praxis .........................................................................................78

5.2

Grundoperationen und Berechnungen (SELECT-Statement) .................................103

5.3

Berechnungen und Aktualisierungen mit CASE und UPDATE .............................124

5.4

Subqueries ..............................................................................................................138

41

63

77

XVIII

Inhalt

5.5

Self-Joins (Reflexive Join)..................................................................................... 147

5.6

Weitere Möglichkeiten der Arbeit mit einer Tabelle .............................................. 156

6

Arbeit mit zwei Tabellen: Verknüpfen von Tabellen

6.1

„Untereinanderhängen“ von Tabellen (Set Operatoren)......................................... 165

6.2

Operatoren für das „Nebeneinanderstellen“ (Joinen) von Tabellen ....................... 179

6.3

Spezielle Joins (u.a. INNER, CROSS, NATURAL, UNION) ............................... 193

6.4

Filtern mit Subqueries ............................................................................................ 199

6.5

Weitere Möglichkeiten der Berechnung und Aktualisierung.................................. 205

6.6

Fallstricke bei der Arbeit mit zwei Tabellen........................................................... 210

7

Arbeit mit zwei Tabellen (und mehr)

7.1

One-to-Many (BY-Merge, interleaving)................................................................. 223

7.2

Many-to-One.......................................................................................................... 230

7.3

Many-to-Many ....................................................................................................... 238

7.4

Arbeiten mit drei und mehr Tabellen...................................................................... 249

7.5

Prüfschritte und Hilfsmittel für die Arbeit mit zwei und mehr Tabellen ................ 258

8

Fokus: Deskriptive Statistik

8.1 8.1.1 8.1.2

Statistische Grundlagen.......................................................................................... 267 Lagemaße ............................................................................................................... 269 Streuungsmaße ....................................................................................................... 271

8.2

Berechnung von Lage- und Streuungsmaßen......................................................... 273

8.3

Weitere Aggregierungsfunktionen (COUNT, SUM usw.) ...................................... 280

8.4

Prozent- und Quotientwerte (SUM, COUNT) ....................................................... 283

8.5

Rechnen mit Gewichtungen (SUM, CASE GROUP BY) ...................................... 287

9

Fokus: Hilfen, Tipps und Tricks

9.1

Verstehen und Testen von SQL (FEEDBACK, VALIDATE)................................. 291

9.2

Optimieren von Joins (_METHOD, _TREE)......................................................... 294

9.3

Konvertieren, String-Funktionen etc...................................................................... 298

9.4

Designen der SQL Ausgabe ................................................................................... 304

9.5

Output Delivery System (ODS) ............................................................................. 308

9.6

Zugriff auf Microsoft Excel ................................................................................... 310

159

219

265

291

Inhalt

XIX

10

Übungsteil: Aufgaben und Lösungen

315

10.1

Aufgaben, die nur eine Tabelle erfordern ...............................................................320

10.2

Aufgaben, die zwei Tabellen erfordern ..................................................................323

10.3

Lösungen ................................................................................................................328

11

Verwendete SAS Datasets

11.1

SAS Datasets von SAS Institute.............................................................................337

11.2

SAS Datasets des Verfassers ..................................................................................341

12

Literatur

345

13

Ihre Meinung zu diesem Buch

347

14

Autor

349

337

Syntaxverzeichnis

351

Sachverzeichnis

359

1

SQL (Structured Query Language)

Kapitel 1 geht auf die grundlegende Bedeutung von SQL (Structured Query Language) ein. Die große Bedeutung von SQL rührt daher, dass SQL wegen seiner ANSI Konformität eine weitgehende Unabhängigkeit von Hersteller und Software ermöglicht. Dies bedeutet für Anwender und Leser zweierlei: Was Sie jetzt für das SQL für SAS lernen, können Sie auch auf SQL für MySQL usw. anwenden. Dies ist dadurch möglich, eben weil SQL ein Standard ist. Mittels ANSI-konformem SQL können auch Programme geschrieben werden, die vom Datenbanksystem unabhängig sind. Ein Programm, das z.B. mit einem ANSI-konformen SQL geschrieben wurde, funktioniert u.a. auch auf Oracle, IBM oder auch Teradata. Kapitel 1 erläutert auch grundlegende Terminologien und Konzepte. Je nach Anwendungsbereich (SQL, SAS Base, oder auch RDBMS) wird oft eine andere Nomenklatur für Datendatei, Datenzeile oder auch Datenspalte verwendet. Die anfangs oft ungewohnt heterogene Terminologie wird geklärt, um das Risiko für Missverständnisse von Anfang an auf ein Minimum zu reduzieren. Ein weiterer Abschnitt erläutert das Konzept des sog. Schlüssels und darin die Unterscheidung zwischen Primär- und Fremdschlüssel (Primary Key, Foreign Key). Ein Schlüssel dient i.A. weniger zur Beschreibung als zur Verwaltung als zur Identifikation von Datenzeilen. Wie viele andere SQL Varianten entspricht auch das SQL von SAS nicht uneingeschränkt dem aktuellen ANSI Standard. Ein weiterer Abschnitt beschäftigt sich daher mit den Unterschieden von PROC SQL zum ANSI Standard. Als bedeutende (konzeptionelle) Abweichung wäre z.B. der Umgang mit Missings in PROC SQL zu nennen, demgegenüber auch die Makrofähigkeit von PROC SQL, wie auch, dass PROC SQL deutlich mehr Auswertungsfunktionen als der ANSI Standard unterstützt. Die weiteren Ausführungen behandeln weitere grundlegende Konzepte. Allen voran werden Gemeinsamkeiten und Unterschiede zwischen Tabellen, Views und Abfragen im Hinblick auf Funktion, Inhalt und Speicherplatz erläutert, und damit ebenfalls einhergehende Anforderungen an ihre jeweilige Programmierung mit PROC SQL (Programmierkonvention). SQL (Structured Query Language) ist die am weitesten verbreitete Programmiersprache für relationale Datenbanken. SQL wurde ursprünglich von IBM in den Projekten SEQUEL, XRM und System R entwickelt (vgl. zu den interessanten Hintergründen z.B. McJones et al., 1997), jedoch schnell von anderen Datenbank-Herstellern übernommen und ist mittlerweile ein Quasi-Industriestandard für relationale Datenbanken (RDBMS). Vor allem die Tatsache, dass SQL und seine Vorgängerversionen erst ab Mitte der siebziger Jahre entwickelt wurden, verdeutlicht den fulminanten Erfolg dieser Datenbanksprache.

2

1 SQL (Structured Query Language)

SQL ist eine Programmiersprache zur Definition, Abfrage und Manipulation von Daten in relationalen Datenbanken. SQL ist seit 1986 ein Standard beim ANSI (American National Standards Institute) und 1987 beim ISO. Alle Datenbankhersteller implementieren sukzessive auch neuere Versionen dieser Standards. Kommerzielle Datenbankhersteller, wie z.B. Oracle, IBM oder Teradata heben sich i.A. von freien Anbietern wie z.B. MySQL oder PostgreSQL durch u.a. komplexere Modellierungsmöglichkeiten, einen größeren Funktionsumfang sowie i.A. höhere Sicherheit ab. Mittlerweile ist der Versionsstandard bei SQL:2008 angelangt. Die große Bedeutung von SQL rührt daher, weil SQL eine weitgehende Unabhängigkeit von Hersteller und Software ermöglicht. Dies bedeutet für Anwender und Leser:  Mittels SQL können Programme geschrieben werden, die vom Datenbanksystem unabhängig sind. Ein Programm, das z.B. für das DBMS MySQL mittels eines SQL nach dem ANSI Standard geschrieben wurde, funktioniert z.B. auch auf Oracle, IBM oder auch Teradata, PostgreSQL oder MaxDB.  Dieses Buch zum SQL von SAS (syn.: PROC SQL) ist daher gleichzeitig auch eine Einführung in das SQL anderer Hersteller. Wenn Sie jetzt SQL für SAS kennenlernen, dann auch SQL für MySQL usw. Dies ist dadurch möglich, eben weil SQL ein Standard ist.  Aus dem großen Umfang an Möglichkeiten mit PROC SQL folgte auch die Entscheidung, das ursprünglich als einen Band konzipierte Buch in zwei Bände aufzuteilen. Band I konzentriert sich auf die umfangreichen grundlegenden Möglichkeiten in PROC SQL. Band I beschränkt sich soweit als möglich auf den ANSI Standard und kann daher von Anwendern auch auf andere DBMS angewandt werden. Band I ist für Einsteiger in PROC SQL, aber auch Fortgeschrittene gedacht. Band II demonstriert die eigentliche Power von SAS: Anwendungen für die Gewährleistung von Datenqualität (u.a. Audit Trails), unzählige Makroprogramme zur Beschleunigung und Automatisierung sowie u.a. Hinweise für Performanz und Effizienz zeigen zeitlich das Besondere von SAS. Das Kapitel für Missings wird allen Lesern empfohlen, da der Umgang mit Missings seitens SAS nicht ANSI-kompatibel ist und erfahrungsgemäß zu Überraschungen führen kann. Band II geht deutlich über den ANSI Standard hinaus und kann voraussichtlich nur auf SAS angewandt werden. Band II ist v.a. für Fortgeschrittene in SAS geschrieben. Die erhältlichen SQL Varianten sind jedoch bekanntlich nicht von derselben Aktualität hinsichtlich der jeweils zertifizierten ANSI Standards und Funktionalitäten. Vor allem herstellerspezifische Erweiterungen, die (noch) nicht dem ANSI Standard entsprechen, haben zur Folge, dass scheinbar verschiedene Ausdrücke oder Syntaxelemente dieselben Funktionen aufweisen können. Ebenfalls ist umgekehrt nie ganz auszuschließen, dass scheinbar semantisch gleichen Ausdrücken oder Syntaxelementen unterschiedliche Funktionalitäten zugrunde liegen können. Obwohl SQL im Wesentlichen mit Anweisungen für Zeilen und Spalten arbeitet, können damit auch ausgesprochen komplexe Programmierungen vorgenommen werden. In SAS kann SQL u.a. über die Prozeduren SQL, ACCESS und das SQL Query Window an SAS bzw. das System übergeben werden. SQL ist somit neben der SAS Base Syntax eine weitere, zentrale Syntaxsprache in der Programmierumgebung des SAS Editors.

1 SQL (Structured Query Language)

3

Die Syntax von SQL ist verhältnismäßig überschaubar aufgebaut (das Vorgängerakronym SEQUEL bedeutete konkret „Structured English Query Language”). Die Befehle selbst orientieren sich an der englischen Umgangssprache (z.B. INSERT, UPDATE) und erleichtern dadurch ihre Anwendung. SQL stellt diverse Ausdrücke und Syntaxelemente zur Definition von Tabellenstrukturen nach der relationalen Algebra, zur Manipulation von Zeilen und Spalten (Einfügen, Bearbeiten und Löschen von Datensätzen) sowie zur Abfrage von Daten zur Verfügung. SQL ist, besonders in der SAS Variante, eine ausgesprochen leistungsfähige Programmiersprache. Mit PROC SQL ist es u.a. möglich:         

Werte in SAS Tabellen aktualisieren komplexe Berechnungen (neuer Variablen) durchführen zusammenfassende Parameter bzw. Statistiken erzeugen automatische Prüfungen auf Datenintegrität vornehmen Daten aus Tabellen oder Views abfragen Tabellen, Views, neue Variablen und Indexe anlegen Daten aus Tabellen oder Views zusammenfügen Berichte erzeugen und designen (z.B. mit dem Output Delivery System, ODS) SQL Programme mittels der SAS Macro Facility automatisieren

Neben der Funktionalität und der Programmierung dürfte für SAS Base Anwender anfangs auch eine etwas abweichende Terminologie gewöhnungsbedürftig sein. In SAS Base wird z.B. eine Datendatei als SAS Datei, eine Datenzeile als Beobachtung und eine Datenspalte als Variable bezeichnet. In PROC SQL wird dagegen eine Datendatei als Tabelle, eine Datenzeile als Zeile und eine Datenspalte als Spalte bezeichnet. Die Bezeichnungen bei RDBMS lauten wieder etwas anders. Andere Modelle oder Modellierungssprachen (ERM, UML) verwenden wiederum eine andere Terminologie. Struktur / Sprache

SQL

SAS Base

RDBMS

Datendatei

Tabelle

SAS Datei

Relation

Datenzeile

Zeile

Beobachtung / record

Tupel / Datensatz

Datenspalte

Spalte

Variable

Attribut / Feld

Datenzelle

Wert

Wert

(Attribut)Wert

Bereits diese kleine Übersicht ist im Prinzip nichts anderes als die Relation diverser Attribute, mit Attributwerten in den Tupeln. Nicht immer können Daten in einer solch einfachen Struktur angeordnet werden. Die Grenze einer solch verhältnismäßig einfachen relationalen Struktur ist, dass komplexe Attributstrukturen nicht immer durch eine einzelne Tabelle abgebildet werden können. Mit der naheliegenden Lösung, komplexe Attributstrukturen einfach auf verschiedene Tabellen zu verteilen (und über Schlüssel im Moment der Abfrage miteinander zu verknüpfen), geht der Nachteil verarbeitungs- und wartungsintensiver Joins (syn.: Verbund) einher. Alternative Ansätze wären sog. objektorientierte, objektrelationale Daten-

4

1 SQL (Structured Query Language)

banken oder auch semistrukturierte Datenbanken (z.B. XML) mit dem Vorzug der Speicherung komplexer Attributstrukturen, jedoch überwiegend mit u.a. Performanznachteilen. Alle Konzepte setzen voraus, dass eine Datenzeile, Beobachtung bzw. ein Tupel mittels mindestens eines sog. Schlüssels (syn.: Keys, IDs; idealerweise: primary key) eindeutig identifizierbar sein muss. Ein Schlüssel ist i.A. unique und identifiziert dadurch eindeutig eine Zeile in einer Tabelle; nicht ihre (relative) Position in der Tabelle, die sich durch Sortieren ja immer verändern kann. Ein Schlüssel dient daher i.A. weniger zur Beschreibung als zur Verwaltung einer Datenzeile. Ein Primärschlüssel (Primary Key) dient dabei i.A. der Identifikation der Zeilen in der eigenen Tabelle, ein Fremdschlüssel (Foreign Key) der Identifikation der Zeilen in einer anderen Tabelle, üblicherweise deren Primärschlüssel. Schlüssel sind für das Joinen von zwei oder mehr Tabellen essentiell und dürfen daher weder gelöscht oder verändert werden. Erfahrungsgemäß werden in einem SAS Programm SAS Base und PROC SQL Elemente oft gleichzeitig verwendet. Eine terminologische Trennung dürfte zwar nicht völlig unmöglich, aber vielleicht umständlich bzw. oft unnötig aufwendig sein. Eine gewisse Sprachverwirrung ist also wirklich nie ganz auszuschließen. Entsprechend wird dieses Buch zwar die SQL Terminologie bevorzugen, jedoch (notwendigerweise) auch die SAS Base Terminologie verwenden (müssen). Dieses Buch verwendet daher für eine Datendatei die Ausdrücke „Tabelle“, „SAS Datei“ oder auch „Datensatz“. Im Gegensatz zum RDBMS Begriff ist mit „Datensatz“ die Gesamtheit aller Zeilen gemeint (auch wenn eine Datei nur eine Zeile enthalten sollte). Das SQL von SAS entspricht den meisten der ANSI Richtlinien (American National Standards Institute, ANSI) für SQL. Wie viele andere SQL Varianten entspricht auch PROC SQL nicht uneingeschränkt dem aktuellen ANSI Standard.  In PROC SQL sind z.B. noch nicht alle Datenbankfunktionen implementiert, wie sie z.B. andere SQL Varianten bereitstellen.  PROC SQL geht z.B. mit Missings (fehlenden Werten, missing values) anders als nach dem ANSI Standard für SQL um. Gemäß dem ANSI Standard werden diese Ausdrücke zu NULL, in PROC SQL dagegen wahr. Beispiel: Gemäß des ANSI Standards werden z.B. die Ausdrücke „5 > NULL“, „0 > NULL“, oder auch „-5 > NULL“ zu NULL. In Boole'schen und Vergleichsoperatoren werden dieser und andere Ausdrücke jedoch wahr, entsprechend auch bei der Arbeit mit SAS. Diese und weitere Unterschiede gerade im Umgang mit Missings sind für die konkrete Arbeit mit PROC SQL derart zentral, dass diesem Thema ein eigenes Kapitel vorbehalten ist (vgl. Kapitel 2, Band II).  PROC SQL unterstützt u.a. auch den Einsatz der SAS Makrosprache. Auch dieser Unterschied ist von solch großer Bedeutung für die praktische Arbeit mit SQL, dass der Einführung der Makroprogrammierung mit PROC SQL ein eigenes Kapitel vorbehalten ist (vgl. Kapitel 4, Band II).  PROC SQL unterstützt weit mehr Auswertungsfunktionen als nach dem ANSI Standard für SQL erforderlich ist. Auch dieser Unterschied ist so groß, dass ein separates Kapitel

1 SQL (Structured Query Language)

5

einer umfangreichen Übersicht zu den einsetzbaren SAS Funktionen und Funktionsaufrufen vorbehalten ist (vgl. Kapitel 9, Band II).  PROC SQL ermöglicht darüber hinaus den Zugriff auf sog. Dictionary Tables. Dictionary Tables sind read-only Dateien, die Informationen über SAS Dateien und Libraries enthalten, wie auch über SAS Makros oder Einstellungen und Optionen des SAS Systems. Auch diesem SQL Feature sind einige Beispiele gewidmet, z.T. im Zusammenhang mit SAS Makros.  PROC SQL ermöglicht es darüber hinaus, in gewissem Maße auch den erzielten Output zu designen (z.B. durch das Hinzufügen von Text(zeichen)) bzw. einzustellen (z.B. mittels OUTOBS= usw.). PROC SQL bietet jedoch nicht so viele Möglichkeiten wie z.B. PROC PRINT bzw. PROC REPORT. Die folgenden Abschnitte stellen die Grundlagen der SQL Programmierung vor. PROC SQL legt (leere) Tabellen bzw. Views an oder führt „nur“ Abfragen durch. Worin besteht nun der Unterschied zwischen Tabellen, Views und Abfragen (syn.: Queries)? Eine Tabelle ist nichts anderes als eine SAS Datei. SAS Tabellen sind oft eine Folge von Queries. Eine SAS Datei (a) beschreibt Daten, (b) enthält Daten und (c) benötigt dafür Speicherplatz. Vor allem die beiden letzten Punkte sind wichtig; sie dienen zur Abgrenzung von Views. Eine View (a) beschreibt Daten, (b) enthält jedoch selbst keine Daten, und benötigt deshalb (c) auch keinen Speicherplatz. SAS Views sind nur eine Ansicht bzw. Sicht auf Daten bzw. Ergebnisse, ohne die dazu notwendigen Daten selbst physikalisch enthalten zu müssen. SAS Views sind oft eine Folge von Queries. Views und Tabellen ist gemeinsam, dass sie jeweils ein Ergebnis einer Abfrage (sog. Query) sind. Man könnte Tabellen und Views auch als „gespeicherte Abfragen“ umschreiben, z.B. als Folge einer SELECT-Anweisung oder komplexerer Abfragen. Queries sind eine Zusammenstellung von Bedingungen (z.B. „übernehme alle Daten aus Tabelle A“, „frage nur Zeilen mit einem Wert in Spalte X größer als 5 aus View B ab“ usw.). Queries können auf diese Weise Daten aus einzelnen oder mehreren Views, Tabellen oder DBMS abfragen. Queries können dabei das Ergebnis ihrer Abfragen in (a) Tabellen, (b) Views oder auch (c) direkt in den SAS Output ausgeben. Queries (bzw. die Bedingungen, die sie enthalten) sind die Voraussetzungen von Tabellen, Views, oder Ergebnissen. Beim Ausführen von Queries werden Views oder Tabellen aber nicht notwendigerweise automatisch angelegt. Queries fragen in ihrer Grundform nur die Daten ab und geben ihr Resultat sofort in den SAS Output aus. Erst eine Erweiterung der SQL Syntax für eine Query um u.a. CREATE, AS und QUIT erlaubt auch das Ablegen der Ergebnisse der Abfrage in Tabellen oder Views. Legt ein und dieselbe Query einmal eine Tabelle und einmal eine View an, ist diesen Tabellen und Views gemeinsam, dass sie dieselbe Information wiedergeben, ihnen dieselben Bedingungen („Logik“) der Query zugrunde liegen und auch oft (aber nicht immer) auf gleiche Weise weiterverarbeitet werden können. Queries können auch eine oder mehrere Subqueries enthalten. Eine Subquery (Unterabfrage) ist eine Abfrage (in Klammern), die wiederum innerhalb einer anderen Abfrage eingebettet ist. Bei mehreren Subque-

6

1 SQL (Structured Query Language)

ries wird zunächst die innerste ausgeführt, danach alle weiteren in Richtung der äußersten (Sub)Query (vgl. das Beispiel weiter unten). Je nachdem, ob nun Tabellen, Views oder „nur“ Queries benötigt werden, unterscheidet sich die Arbeit mit der SQL Syntax in wenigen, aber zentralen Punkten: Ausführen einer Abfrage (Query) Programmierkonvention: Queries enthalten zumindest ein SELECT und ein FROM. Queries enthalten nicht den CREATE (TABLE/VIEW)-Befehl und werden nicht mit QUIT abgeschlossen. Queries geben ihr Resultat automatisch in den SAS Output aus und legen keine Views oder Tabellen an. Um ein CREATE TABLE oder CREATE VIEW ergänzt, legen Queries das Ergebnis einer Abfrage jedoch in einer Tabelle oder einer View ab. Beispiel: Die nachfolgende Query verlangt, dass von der Tabelle SASHELP.SHOES die Spalten REGION, SUBSIDIARY und SALES und alle Zeilen behalten werden, in denen der Wert in SALES über 750.000 liegt. Syntax: proc sql; select REGION, SUBSIDIARY, SALES from sashelp.shoes where SALES > 750000 ;

Ergebnis: Region

Subsidiary

Total Sales

ƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒ Canada

Vancouver

$757,798

Canada

Vancouver

$756,347

Middle East

Tel Aviv

$1,298,717

Direkte Ausgabe in SAS Output. Zstzl. Zugriff nicht erforderlich. Würde die Abfrage (Query) noch eine weitere, vorangehende Abfrage (in Klammern) enthalten, wäre diese eine sog. Subquery (Unterabfrage). proc sql; select REGION, SUBSIDIARY, SALES from sashelp.shoes where SALES in (select SALES from sashelp.shoes where SALES > 750000); quit ; Direkte Ausgabe in SAS Output. Zstzl. Zugriff nicht erforderlich.

Ergebnis: Region

Subsidiary

Total Sales

ƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒ Canada

Vancouver

$757,798

Canada

Vancouver

$756,347

Middle East

Tel Aviv

$1,298,717

1 SQL (Structured Query Language)

7

Anlegen einer SAS Tabelle Programmierkonvention: Verwendung von CREATE TABLE. Die Tabellen bestehen aus Zeilen und Spalten und enthalten, sofern nicht leer, Daten und benötigen insofern Speicherplatz. Ein SQL Programm mit CREATE TABLE wird mit QUIT; abgeschlossen. PROC SQL gibt diese Inhalte nicht automatisch aus; diese können z.B. über ein zusätzliches PROC PRINT angezeigt werden. Beispiel: Die oben vorgestellte Query soll ausgeführt und das Ergebnis zusätzlich in eine SAS Tabelle abgelegt werden. Über ein zusätzliches CREATE TABLE, AS und QUIT wird die Tabelle MYDATA angelegt und mittels PROC PRINT eingesehen. Syntax: proc sql; create table MYDATA as select REGION, SUBSIDIARY, SALES from sashelp.shoes where SALES > 750000 ; quit;

Ergebnis: Region

Subsidiary

Canada

Vancouver

Canada

Vancouver

Middle East

Tel Aviv

Sales $757,798 $756,347 $1,298,717

Im SAS Log steht außerdem: Zstzl. Zugriff auf Tabelle MYDATA: proc print data=MYDATA noobs ; run ;

HINWEIS:

Tabelle

WORK.MYDATA

wurde

erstellt mit 3 Zeilen und 3 Spalten.

Anlegen einer SAS View Programmierkonvention: Verwendung von CREATE VIEW. Views enthalten selbst keine Daten. CREATE VIEW wird mit QUIT abgeschlossen. Eine View ist ebenfalls nach Zeilen und Spalten strukturiert, enthält jedoch selbst keine Daten und benötigt daher keinen Speicherplatz. Ein SQL Programm mit CREATE VIEW wird mit QUIT; abgeschlossen. PROC SQL gibt diese Inhalte nicht automatisch aus; diese können z.B. über ein zusätzliches PROC PRINT angezeigt werden. Beispiel: Die oben vorgestellte Query soll ausgeführt und das Ergebnis alternativ in einer SAS View abgelegt werden. Über ein zusätzliches CREATE VIEW, AS und QUIT wird nun die View MYVIEW angelegt und mittels PROC PRINT eingesehen. Views und Tabellen können nicht mit demselben Namen bezeichnet werden (SAS reserviert die Namen). Im Beispiel mit CREATE VIEW wird daher ein anderer Name als im CREATE TABLE-Beispiel oben verwendet.

8 Syntax: proc sql; create view MYVIEW as select REGION, SUBSIDIARY, SALES from sashelp.shoes where SALES > 750000 ; quit;

1 SQL (Structured Query Language) Ergebnis: Region

Subsidiary

Canada

Vancouver

Canada

Vancouver

Middle East

Tel Aviv

Sales $757,798 $756,347 $1,298,717

Im SAS Log steht außerdem: Zstzl. Zugriff auf View MYVIEW: proc print data=MYVIEW noobs ; run ;

HINWEIS:

SQL

View

WORK.MYVIEW

wurde

definiert.

Um aus didaktischen Gründen eine gewisse Einheitlichkeit zu gewährleisten, werden in diesem Buch vorrangig SQL Beispiele für das Anlegen von Tabellen vorgestellt (CREATE TABLE). Die Beispiele gelten im Wesentlichen auch für Queries bzw. Views. Für weitere Hinweise auf Unterschiede zwischen Tables und Views wird auf Abschnitt 2.4 verwiesen.

2

Erste Schritte mit PROC SQL

Kapitel 2 stellt erste Schritte mit SQL vor. Abschnitt 2.1 spielt an einer kleinen überschaubaren SAS Tabelle schrittweise durch, wie sich eine SAS Tabelle in Struktur und Inhalt ändert, wenn die SQL Syntax Schritt für Schritt um kleine, aber wichtige Optionen variiert wird. Abschnitt 2.2 stellt zahlreiche weitere Grundoperationen vor, darunter u.a. das Anlegen einer temporären bzw. permanenten Tabelle, die Abfrage aller oder nur bestimmter Spalten (Variablen) sowie auch das gleichzeitige Berechnen weiterer Variablen. Weitere wichtige Beispiele für spezielle Anwendungen von PROC SQL sind z.B. das Erzeugen eines kartesischen Produktes oder das Vermeiden bzw. das Zulassen von sog. rekursiven Referenzen. Der nächste Abschnitt könnte für Anwender interessant sein, die neu in SQL oder der Programmierung sind. Abschnitt 2.3 stellt mit dem SQL Query Window einen unkomplizierten Einstieg in das Erstellen von Abfragen mit SQL vor. Das SQL Query Window ist ein mausgesteuertes, interaktives Menü, mit dem u.a. SQL Abfragen unkompliziert per Mausklick erstellt, gespeichert und ausgeführt werden können. Als Beispiele werden das Erstellen einer SQL Abfrage und das Joinen zweier Tabellen erläutert. Abschnitt 2.4 hebt die diversen Unterschiede zwischen SAS Tabellen und SAS Views hervor. Abschnitt 2.5 ist für SAS Base Programmierer gedacht, die sich einen ersten Eindruck von Unterschieden in Programmierung, Anwendungen und Effizienz im Vergleich zu SAS Base verschaffen wollen. Weitere Unterabschnitte werden zeigen: Programmierung derselben Anforderung (z.B. wenn-dannBedingung), jeweils mit SAS Base (DATA Step) und PROC SQL, sowie Unterschiede in den Programmierkonventionen, wie auch ggf. Hinweise auf mögliche Unterschiede in der Performanz von SAS Base und PROC SQL. Der Leistungsumfang bzw. die Differenziertheit des SQL von SAS geht oftmals über den ANSI Standard hinaus. Abschnitt 2.6 hebt hervor, inwieweit PROC SQL von den ANSI Richtlinien für SQL (American National Standards Institute, ANSI) abweicht, z.B. im Hinblick auf Missings bzw. die dreiwertige Logik.

2.1

Variationen eines Beispiels: Abläufe innerhalb einer Tabelle

Dieser Abschnitt demonstriert an einer kleinen überschaubaren SAS Tabelle, wie sich eine Tabelle in Struktur und Inhalt ändert, wenn die SQL Syntax Schritt für Schritt um kleine, aber wichtige Optionen variiert wird.

10

2 Erste Schritte mit PROC SQL

Die Beispieldaten data DATATABLE ; input STRING $ VAR ; datalines ; A 1 B 4 C 5 A 2 B 3 C 6 ; run ; SQL Syntax

Funktion

proc sql ; create table MYDATA

Die SAS Prozedur SQL initiiert eine SQL Abfrage und legt eine temporäre Datei MYDATA an.

as select STRING, VAR

Die Variablen STRING und VAR werden ausgewählt.

from DATATABLE ;

SQL soll dazu auf die Datei DATATABLE zugreifen.

quit ;

Abschluss bzw. Ausführung der definierten SQL Abfrage.

Inhalt der angelegten Datei MYDATA: STRING

VAR

A

1

B

4

C

5

A

2

B C

3 6

Dieses Beispielprogramm kann um viele weitere Anweisungen (WHERE, GROUP BY usw.) bzw. Subqueries (Unterabfragen) erweitert werden. Im nächsten Beispiel wird dieses erste SQL Programm um ein WHERE erweitert werden. SQL Syntax erweitert um WHERE. proc sql ; create table MYDATA as select STRING,VAR

Funktion Die SAS Prozedur SQL initiiert eine SQL Abfrage und legt eine temporäre Datei MYDATA an. Die Variablen STRING und VAR werden ausgewählt.

2.1 Variationen eines Beispiels: Abläufe innerhalb einer Tabelle

11

from DATATABLE

SQL soll dazu auf die Datei DATATABLE zugreifen.

where VAR < 6 ;

Es sollen nur Zeilen mit VAR-Werten kleiner als 6 ausgewählt werden.

quit ;

Abschluss bzw. Ausführung der definierten SQL Abfrage.

Inhalt der angelegten Datei MYDATA: STRING

VAR

A

1

B

4

C

5

A B

2 3

Im nächsten Beispiel wird dieses SQL Programm um eine spaltenweise Aggregierungsfunktion (Summenbildung) erweitert werden. SQL Syntax erweitert um eine Summenbildung. proc sql ; create table MYDATA

Funktion

Die SAS Prozedur SQL initiiert eine SQL Abfrage und legt eine temporäre Datei MYDATA an.

as select STRING,VAR, sum(VAR) as VARSUM

Die Variablen STRING und VAR werden ausgewählt. Die Summe von VAR wird in die Variable VARSUM abgelegt.

from DATATABLE

SQL soll dazu auf die Datei DATATABLE zugreifen.

where VAR < 6 ;

Es sollen nur Zeilen mit VAR-Werten kleiner als 6 ausgewählt werden.

quit ;

Abschluss bzw. Ausführung der definierten SQL Abfrage.

Inhalt der angelegten Datei MYDATA: STRING

VAR

VARSUM

A

1

15

B

4

15

C

5

15

A B

2 3

15 15

Im nächsten Beispiel wird dieses SQL Programm um eine Summenbildung für jede Zeile in einer Gruppe erweitert werden.

12

2 Erste Schritte mit PROC SQL

SQL Syntax erweitert um einen Summenwert pro Zeile in jeder Gruppe. proc sql ; create table MYDATA

Funktion

Die SAS Prozedur SQL initiiert eine SQL Abfrage und legt eine temporäre Datei MYDATA an.

as select STRING,VAR, sum(VAR) as VARSUM

Die Variablen STRING und VAR werden ausgewählt. Die Summe von VAR wird in VARSUM abgelegt. VAR wird behalten.

from DATATABLE

SQL soll dazu auf die Datei DATATABLE zugreifen.

where VAR < 6 group by STRING ;

Es sollen nur Zeilen mit VAR-Werten kleiner als 6 ausgewählt werden. Der gruppenweise ermittelte Summenwert soll dabei für jede Ausprägung von STRING in jeder Zeile von DATATABLE abgelegt werden (Anzahl der Zeilen bleibt).

quit ;

Abschluss bzw. Ausführung der definierten SQL Abfrage.

Inhalt der angelegten Datei MYDATA: STRING

VAR

VARSUM

A

1

3

A

2

3

B

4

7

B C

3 5

7 5

Im nächsten Beispiel wird dieses SQL Programm um eine Summenbildung für eine Zeile einer Gruppe erweitert werden. SQL Syntax eingeschränkt auf einen Summenwert pro Gruppe proc sql ; create table MYDATA

Funktion

Die SAS Prozedur SQL initiiert eine SQL Abfrage und legt eine temporäre Datei MYDATA an.

as select STRING, sum(VAR) as VARSUM

Es wird nur die Variable STRING ausgewählt. Die Summe von VAR wird in VARSUM abgelegt. VAR wird nicht behalten.

from DATATABLE

SQL soll dazu auf die Datei DATATABLE zugreifen.

2.1 Variationen eines Beispiels: Abläufe innerhalb einer Tabelle

13

where VAR < 6 group by STRING ;

Es sollen nur Zeilen mit VAR-Werten kleiner als 6 ausgewählt werden. Der gruppenweise ermittelte Summenwert soll dabei nur für jede Ausprägung von STRING einmal abgelegt werden (VAR-Summen pro Zeilen werden aggregiert, Anzahl der Zeilen ändert sich).

quit ;

Abschluss bzw. Ausführung der definierten SQL Abfrage.

Inhalt der angelegten Datei MYDATA: STRING

VARSUM

A

3

B C

7 5

Dieses Beispielprogramm kann um viele weitere SAS Tabellen, Anweisungen (ORDER BY, HAVING usw.) und Verschachtelungen (Subqueries, Unterabfragen) erweitert werden. Der Ablauf der letzten Programmversion im Detail: Die Anweisungen werden von PROC SQL in einer anderen Abfolge ausgeführt als sie in der Syntax angegeben sind. Im Prinzip geht PROC SQL immer von „innen“ nach „außen“ vor. proc sql ; from DATATABLE

SQL soll auf die (ebenfalls temporäre) Datei DATATABLE zugreifen, ...

group by STRING

Die Daten werden nach den Ausprägungen von STRING gruppiert.

where VAR < 6

Dazu sollen nur Zeilen mit VAR-Werten kleiner als 6 verwendet werden.

STRING

VAR

A

1

B

4

C

5

A

2

B

3

C

6

STRING

VAR

A

1

A

2

B

4

B

3

C

5

C

6

STRING

VAR

A

1

A

2

B

4

B

3

C

5

14

2 Erste Schritte mit PROC SQL

select STRING, sum(VAR) as VARSUM

… die Variable (Spalte) STRING anlegen und die Summe von VAR (abgelegt in VARSUM) ermitteln. Die Spalte VAR wird nicht behalten.

STRING

VARSUM

A

3

B

7

C

5

create table MYDATA

Die temporäre Datei MYDATA wird angelegt. quit ;

Zusammenfassung Inhalt der Datei DATATABLE: data DATATABLE ; input STRING $ datalines ; A

1

B

4

C

5

A

2

B

3

C

6

; run;

2.2

VAR ;

SQL Programm:

proc sql ; create table MYDATA as select STRING, sum(VAR) as VARSUM from DATATABLE where VAR < 6 group by STRING ; quit ; proc print noobs ; run ;

Inhalt der Datei MYDATA (Ausgabe): STRING

VARSUM

A

3

B C

7 5

Von hier aus weiter: Beispiele für grundlegende SQL Anwendungen

Der folgende Abschnitt zeigt zahlreiche Beispiele für grundlegende SQL Anwendungen. Darunter u.a. das Anlegen einer temporären bzw. permanenten SAS Tabelle, die Abfrage aller oder nur bestimmter Spalten (Variablen) sowie auch das gleichzeitige Berechnen weiterer Variablen. Der Sinn der folgenden Beispiele ist, Neueinsteigern in der Programmierung einen ersten Eindruck von der unkomplizierten SQL Programmierung zu vermitteln. Kapitel 2.5 bietet etwas komplexere SQL Beispiele. Kapitel 2.5 ist für SAS Base Programmierer gedacht, die sich einen ersten Eindruck von Unterschieden in Programmierung, Anwendung und Effizienz im Vergleich zu SAS Base verschaffen wollen. Zu allen Beispielen finden sich SQL Syntax, die erzielte Ausgabe und eine kurze Erläuterung. Die SQL Syntax wird im Kapitel 3 in der Theorie und in den sich anschließenden Praxis-Kapiteln wiederholt und ausführlich erläutert werden.

2.2 Von hier aus weiter: Beispiele für grundlegende SQL Anwendungen

15

Die Beispieldaten data EINS ; input ID A B C ; datalines; 01 1 2 3 02 1 2 3 03 99 99 99 04 1 2 3 05 1 2 3 ; run ; Das Durchführen einer Query: Abfrage aller Spalten aus einer Tabelle proc sql ; select * from EINS ;

ID A B C ƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒ 1 1 2 3 2 1 2 3 3 99 99 99 4 1 2 3 5

1

2

3

Anm.: Über „*“ wird der komplette Inhalt von EINS abgefragt und automatisch in der SAS Ausgabe angezeigt. Das FROM zeigt an, aus welcher Tabelle der Inhalt von MYDATA stammt. Abfragen verwenden kein CREATE TABLE bzw. kein CREATE VIEW. Bei einer Query (Abfrage) wird keine Tabelle bzw. View angelegt. Um den Inhalt von EINS in eine (temporäre) Tabelle abzulegen, braucht dem SELECT-Statement nur ein CREATE TABLE [Tabellenname] AS vorangestellt werden (vgl. das folgende Beispiel). Abfrage aller Spalten aus einer Tabelle und Anlegen eines temporären Datensatzes proc sql ; create table MYDATA as select * from EINS ; quit ;

Beob. 1 2 3 4 5

ID 1 2 3 4

A 1 1 99 1

B 2 2 99 2

C 3 3 99 3

5

1

2

3

Anm.: Über „*“ wird der komplette Inhalt von EINS in MYDATA abgelegt. Die über CREATE TABLE angelegte Tabelle MYDATA hat einen einstufigen Namen und ist daher temporär. Das FROM zeigt an, aus welcher Tabelle der Inhalt von MYDATA stammt. Mittels „*“ wird eine komplette Kopie von EINS in Gestalt von MYDATA angelegt; die Merkmale der Spalten (Name, Label, Typ usw.) entsprechen den Spalten der Quelldatei EINS. Um den Inhalt von MYDATA in der SAS Ausgabe angezeigt zu bekommen, muss der PROC SQL

16

2 Erste Schritte mit PROC SQL

Schritt um einen PROC PRINT-Schritt ergänzt werden (vgl. das Beispiel weiter unten). In dieser Ausgabe wird im PROC PRINT-Schritt zusätzlich zum Tabelleninhalt eine automatisch ausgegebene Zeilennummer angezeigt (diese kann durch die Option NOOBS unterdrückt werden). Abfrage bestimmter Spalten (Variablen) proc sql ; create table MYDATA as select A, B, C from EINS ; quit ;

ID 1 2 3 4

A 1 1 99 1

B 2 2 99 2

C 3 3 99 3

5

1

2

3

Anm.: Nach AS SELECT werden die abzufragenden Variablen (Spalten) angegeben, jeweils mit einem Komma voneinander getrennt. Im Beispiel werden die Variablen A, B und C ausgewählt und in die temporäre Tabelle MYDATA abgelegt. Werden nach SELECT-Variablen abgefragt, die nicht in der referenzierten Datei (z.B. EINS) enthalten sind (z.B. „D“), bricht SAS die Verarbeitung ab und gibt folgende Fehlermeldung aus: FEHLER: Die folgenden Spalten wurden in den beitragenden Tabellen nicht gefunden: D.

Anlegen eines permanenten Datensatzes proc sql ; create table PFAD.MYDATA as select A, B, C from EINS ; quit ; proc print data= PFAD.MYDATA noobs ; run;

ID 1 2 3 4

A 1 1 99 1

B 2 2 99 2

C 3 3 99 3

5

1

2

3

Anm.: Der angelegte Datensatz PFAD.MYDATA hat einen zweistufigen Namen und ist daher permanent. Voraussetzung ist, dass vorher der Pfad mittels des LIBNAME-Statement vergeben wurde. Die Option NOOBS im PROC PRINT-Schritt unterdrückt die Anzeige einer automatisch vergebenen Zeilennummer.

2.2 Von hier aus weiter: Beispiele für grundlegende SQL Anwendungen

17

Umstellen der Variablenabfolge proc sql; create table MYDATA as select C, B, * from EINS ; quit ;

C 3 3 99 3

B 2 2 99 2

ID 1 2 3 4

A 1 1 99 1

3

2

5

1

Anm.: Im angelegten (temporären) Datensatz MYDATA gehen die Variablen C und B allen weiteren Variablen in ihrer Originalabfolge voran. Die Abfolge in der angelegten Tabelle MYDATA ist daher C, B, ID und A. Umbenennen von Variablen (Variationen) proc sql; create table MYDATA as select ID, A, B, C as D from EINS ; quit ;

ID 1 2 3 4

A 1 1 99 1

B 2 2 99 2

D 3 3 99 3

5

1

2

3

Anm.: Die Variable C wird mittels AS in D „umbenannt“. Genau betrachtet wird von C eine Kopie unter der Bezeichnung D abgelegt und zusätzlich die original Variable C nicht übernommen. proc sql; create table MYDATA as select *, C as D from EINS ; quit ;

ID 1 2 3 4

A 1 1 99 1

B 2 2 99 2

C 3 3 99 3

D 3 3 99 3

5

1

2

3

3

Anm.: Die Variable C wird in D „umbenannt“. Die original Variable C wird jedoch wegen „*“ behalten. proc sql; create table MYDATA(rename=(C=D))as select A,B,C from EINS ; quit ;

ID 1 2 3 4

A 1 1 99 1

B 2 2 99 2

D 3 3 99 3

5

1

2

3

Anm.: Die Variable C wird in D umbenannt. Auf die Klammern um die alten und neuen Variablennamen kann verzichtet werden (s.u.).

18

2 Erste Schritte mit PROC SQL

proc sql; create table MYDATA(rename=C=D)as select A,B,C from EINS ; quit ;

ID 1 2 3 4

A 1 1 99 1

B 2 2 99 2

D 3 3 99 3

5

1

2

3

Anm.: Die Variable C wird in D umbenannt. Abfrage zweier Variablen und gleichzeitige Berechnung einer dritten Variablen proc sql; create table MYDATA as select A, C, B*0.10 as B_10 from EINS ; quit ;

A

C

B_10

1 1 99 1

3 3 99 3

0.2 0.2 9.9 0.2

1

3

0.2

Anm.: Es werden die Variablen A und C ausgewählt sowie B_10, das zuvor aus einer Multiplikation von B mit 0,10 ermittelt wurde. B muss für die Multiplikation nicht extra ausgewählt werden; die Angabe im Multiplikationsausdruck reicht aus. Da B nicht explizit behalten wurde, wird B nicht in MYDATA übernommen. Zur Berechnung neuer Variablen bzw. Spalten können fast alle SAS Funktionen und Operatoren eingesetzt werden (vgl. Kap. 9, Band II). proc sql; create table MYDATA as select A,B,A-C as A_C_diff from EINS ; quit ;

A

B

A_C_diff

1 1 99 1

2 2 99 2

-2 -2 0 -2

1

2

-2

Anm.: Es werden die Variablen A und B ausgewählt sowie A_C_diff, das zuvor aus einer Differenz zwischen A und C ermittelt wurde. proc sql; create table MYDATA as select A,B,A-C as A_C_diff from EINS where calculated A_C_diff > -1.5 ; quit ;

A

B

99

99

A_C_diff 0

2.2 Von hier aus weiter: Beispiele für grundlegende SQL Anwendungen

19

Anm.: Es wird die Variable A_C_DIFF ermittelt. Die Daten werden vor der Ablage in MYDATA nach der Bedingung in WHERE gefiltert. Die Referenz auf die erst berechnete Variable (z.B. A_C_DIFF) erfordert, dass ihr der Hinweis CALCULATED vorangestellt wird. Behalten bzw. Löschen von Zeilen proc sql; create table MYDATA as select * from EINS where A = 1 ; quit ;

ID 1 2 4

A 1 1 1

B 2 2 2

C 3 3 3

5

1

2

3

Anm.: Aus der Tabelle EINS werden mittels SELECT alle Zeilen behalten und in MYDATA abgelegt, die in der Spalte A den Wert 1 aufweisen. Es werden also all die Zeilen nicht in MYDATA abgelegt, die in der Spalte A einen anderen Wert als 1 aufweisen. proc sql; delete from EINS as MYDATA where A ne 1 ; quit ;

ID 1 2 4

A 1 1 1

B 2 2 2

C 3 3 3

5

1

2

3

Anm.: Aus der Tabelle EINS werden mittels DELETE alle Zeilen gelöscht und in MYDATA abgelegt, die in der Spalte A nicht den Wert 1 aufweisen. Es werden also alle Zeilen in MYDATA abgelegt, die in der Spalte A den Wert 1 aufweisen. Ob mittels SELECT bzw. DELETE eine oder mehrere Zeilen behalten werden, entscheidet letztlich die Häufigkeit der Ausprägungen in der betreffenden SAS Tabelle. Letztlich sind SQL Statements wie SELECT bzw. DELETE grundsätzlich in der Lage, eine oder auch mehrere Zeilen zu behalten bzw. zu löschen. Erzeugen Kartesischer Produkte proc sql; create table MYDATA as select A, G from EINS, DREI ; quit ;

A 1 1 1 1 1 1 1 1 1 1 99 99

G 4 4 99 4 4 4 4 99 4 4 4 4 (gekürzt)

20

2 Erste Schritte mit PROC SQL

Anm.: Dieses Beispiel erzeugt ein sog. Kartesisches Produkt zweier Variablen (A, G) aus zwei separaten Tabellen (EINS, DREI). Jeder Wert einer ersten Spalte (z.B. A) wird mit jedem Wert einer mind. zweiten Spalte (z.B. G) kombiniert. Bei 5 mal 5 Werten entstehen in MYDATA zwei Spalten mit insgesamt 25 Kombinationen der Werte aus A und G. Die Ausgabe ist gekürzt. Ein wichtiger Hinweis: Vermeiden rekursiver Referenzen proc sql; create table EINS as select A, B, C from EINS ; quit ; proc print data = EINS ; run ; Anm.: Mittels CREATE TABLE wird eine SAS Tabelle mit demselben Namen der SAS Tabelle angelegt, aus der die Daten stammen (vgl. die referenzierte Tabelle EINS). Eine solche Vorgehensweise ist technisch möglich, allgemein wird allerdings davon abgeraten, weil sie die Datenintegrität gefährdet (z.B. durch versehentliches Überschreiben der Originaldaten) und auch zu fehlerhaften Ergebnissen führen kann. In seiner Voreinstellung führt SAS diese rekursive Referenzen nicht aus und gibt stattdessen einen Hinweis aus. WARNUNG: Die Anweisung CREATE TABLE verweist rekursiv auf die Zieltabelle. Dadurch kann es zu Datenintegritätsproblemen kommen.

Um solche Referenzen zuzulassen ist daher explizit die UNDO_POLICY=NONE zu setzen. NONE bewirkt, dass rekursive Referenzen zugelassen werden. Die Fälle in der Datei EINS würden entsprechend aktualisiert werden. Optionen der UNDO_POLICY werden in späteren Kapiteln vorgestellt.

2.3

SQL per Mausklick mit dem SQL Query Window

SAS bietet mit dem SQL Query Window seinen Anwendern, die sowohl neu in SQL wie auch der Programmierung sind, einen unkomplizierten Einstieg in das Erstellen von Abfragen mit SQL. Das SQL Query Window ist ein mausgesteuertes, interaktives Menü, mit dem u.a. SQL Abfragen unkompliziert per Mausklick erstellt, gespeichert und ausgeführt werden können. Ein Vorteil des SQL Query Windows ist, dass es übersichtlich und klar strukturiert ist und jeden, der zumindest Grundkenntnisse im Umgang mit menügesteuerten Computern mitbringt, in die Lage versetzen sollte, selbständig eigene Abfragen zu erstellen und auszuführen. Das Erstellen einer SQL Abfrage ist dabei menügesteuert, erfordert keine Programmier-

2.3 SQL per Mausklick mit dem SQL Query Window

21

kenntnisse und führt durch die jeweils angezeigte SQL Syntax nebenbei in Logik und Programmierung von PROC SQL ein. Vorteilhaft ist auch, dass für den Report des erzeugten Outputs ein eigenes Design angepasst werden kann, ohne dass dafür das SQL Query Window verlassen zu werden braucht. Vor allem wegen der intuitiven, annähernd selbsterklärenden Benutzerführung braucht im Folgenden nur noch das Notwendigste zum schnellen Einstieg in die Benutzung des SQL Query Windows vorgestellt werden:  Anwendung 1: Erstellen einer Abfrage (Arbeitsumgebung: Spalten-Fenster)  Anwendung 2: Joinen zweier Tabellen (Arbeitsumgebung: Fenster „Spalten für SQL Abfrage“)  Anwendung 3: Abspeichern der SQL Syntax  Anwendung 4: Entwurf eines Reports (Option „Bericht entwer.“)

Auf mehrere Einschränkungen des SQL Query Windows sollte jedoch von Anfang an hingewiesen werden: Das SQL Query Window unterstützt nur zwei Join-Modi: Inner Joins und Outer Joins. Auch können im SQL Query Window immer nur zwei Tabellen miteinander gejoined werden, dies kann bei umfangreichen und komplexen Joins schnell umständlich geraten. Viele Anwender könnten es auch als unnötig umständlich empfinden, dass das SQL Query Window im Gegensatz zu vielen anderen SAS Anwendungen (z.B. Enterprise Guide) die SAS Befehlssyntax nur ausschnittsweise direkt in das Log ausgibt. Alternativ kann eine erstellte SQL Syntax über das Fenster „SQL Abfrage“ als SAS Programm abgespeichert werden. Weiter unten zeigt Anwendung 3, wie SQL Syntax abgespeichert werden kann. Das SQL Query Window kann u.a. auf folgende Weise aufgerufen werden:  Geben Sie im SAS Befehlsfenster (links oben) den Befehl „QUERY“ bzw. „query“ ein.  Aus jedem SAS Fenster über die Menüleiste: z.B. „Extras“ → „Abfrage“.

22

2 Erste Schritte mit PROC SQL

 Falls die Oberfläche SAS/ASSIST installiert ist, über den Menüpfad: Tasks → Data Management → Query → SQL Query. Weitere Modi des Zugriffs sind möglich, z.B. über SAS/AF-Anwendungen oder den Enterprise Guide. Je nach Systemumgebung (z.B. Windows) können über die rechte Maustaste die am häufigsten verwendeten Tools und Views aus dem Pop-Up Menü angezeigt werden. Je nach Installation können die angezeigten Menüs in deutsch und englisch gleichzeitig sein. Das SQL Query Window ist übersichtlich aufgebaut und selbsterklärend. Die folgenden Erläuterungen werden sich daher auf das Wesentliche konzentrieren. Wird das SQL Query Window erstmalig geöffnet, steht der Anwender vor dem TabellenFenster mit seinen drei Unterfenstern.

 Das Fenster „Tabell.Quellen“ in der Mitte enthält die Tabellenquellen, also die Ordner und Verzeichnisse. Ist dieses Fenster leer, so wurden vor dem Ausführen des SQL Query Window keine Pfade an SAS übergeben (z.B. mittels LIBNAME). Wird auf einen der angezeigten Ordner geklickt, z.B. SASHELP, werden im Fenster links die darin enthaltenen SAS Tabellen angezeigt.  Das Fenster links, „Verfügbare Tabellen“, enthält vorhandene SAS Tabellen. Ist dieses Fenster leer, enthält das gewählte Verzeichnis keine SAS Tabellen oder zumindest nicht im SAS Format. Wird eine vorhandene Tabelle angeklickt, markiert und dann über den Pfeil nach rechts verschoben, befindet sie sich im Fenster „Ausgewählte Tabellen“.  Das Fenster rechts, „Ausgewählte Tabellen“, enthält ausgewählte SAS Tabellen. Ist dieses Fenster leer, wurden zuvor keine SAS Tabellen ausgewählt. Sind eine oder mehr SAS Tabellen ausgewählt, springt der Klick auf „OK“ (links unten) zum Spalten-Fenster mit zwei Unterfenstern. Über das Menü „Tabellen…“ im Pop-Up Menü

2.3 SQL per Mausklick mit dem SQL Query Window

23

(rechter Mausklick) kann vom Spalten-Fenster wieder zum Tabellen-Fenster zurückgesprungen werden.

 Das Fenster links, „Verfügbare Spalten“, enthält vorhandene Spalten. Ist dieses Fenster leer, ist die gewählte SAS Tabelle leer. Wird eine vorhandene Spalte angeklickt, markiert und dann über den Pfeil nach rechts verschoben, befindet sie sich im Fenster „Ausgewählte Spalten“.  Das Fenster rechts, „Ausgewählte Spalten“, enthält ausgewählte Spalten. Ist dieses Fenster leer, wurden zuvor keine Spalten ausgewählt. Wird nun eine ausgewählte Spalte markiert, kann sie weiterverarbeitet werden, z.B. kann ihr über einen Klick über das Auswahlfeld in der Mitte eine Summierungsfunktion oder auch ein Label zugewiesen werden. Anwendung 1: Erstellen einer Abfrage (Arbeitsumgebung: Spalten-Fenster) Das Erstellen einer SQL Abfrage ist vom Prinzip her nichts anderes als das Ausführen von SQL Syntax, allerdings nicht getippt, sondern mit der Maus (vgl. die Syntax im Screenshot oben). Über die Option „Spalte erstellen“ (Mitte, unten) wird zunächst die benötigte Summierungsfunktion festgelegt (z.B. AVG), dann die dazugehörige Spalte (z.B. AGE), anschließend über Alias der Name der neu anzulegenden Spalte (z.B. AGE_MEAN sowie ein Label (z.B. „mean of age“). Mit „OK“ wird die Definition der Query abgeschlossen und als SQL im Fenster angezeigt. Wurden nun eine Spalte oder mehr angelegt oder zumindest eine Summierungsfunktion zugewiesen, wird nun nicht (wie evtl. vermutet) auf „OK“ geklickt (links unten ist kein OK), sondern, entweder über die rechte Maustaste oder über „Extras“ (in der Menüleiste), unter „Abfrage ausführen“ jeweils auf „Sofort ausführen“. Hinweis: Es hängt von der Betriebsumgebung und der Installation ab, ob die SQL Syntax nach der Anforderung der Ausführung der Abfrage über Menüleiste oder Pop-Up Menü im SAS Log wiedergegeben wird.

24

2 Erste Schritte mit PROC SQL

Anwendung 2: Joinen zweier Tabellen (Arbeitsumgebung: Fenster „Spalten für SQL Abfrage“) Das Fenster rechts, „Ausgewählte Tabellen“, enthält genau zwei ausgewählte SAS Tabellen. Wird nun „OK“ geklickt (links unten), öffnet sich das Spalten-Fenster. Wird nun die rechte Maustaste geklickt, bietet das Pop-Up Menü die Option „Join-Typ…“. Wird diese Option angeklickt, kann im sich öffnenden Fenster „Jointypen“ zwischen „Inner / Equi-Join“ und „Outer Join“ gewählt werden. Wird z.B. „Inner / Equi-Join“ gewählt, öffnet sich das Fenster „Spalten für Join-Kriterien“. Bei diesem Auswahlfenster wird aus den vorhandenen Spalten aus den beiden gewählten Tabellen jeweils mindestens eine Key-Variable wie auch der Typ des Joins (Inner, On) gewählt werden können. Aus den beiden SASHELP Dateien PRDSAL2 und PRDSAL3 könnte z.B. die Spalte COUNTRY als Key-Variable festgelegt werden. Wird „OK“ geklickt, öffnet sich das Fenster „Spalten für SQL Abfrage“.

Im Auswahlfenster „Spalten für SQL Abfrage“ können nun die Spalten für die Abfrage ausgewählt und weitere Einstellungen vorgenommen werden, z.B. neue Spalten anlegen, die Abfolge der Spalten in der erzeugten Tabelle festlegen, Summierungsfunktionen anfordern oder auch Labels für Spalten vergeben. Sind alle Einstellungen festgelegt, kann die Ausführung der Abfrage über Menüleiste oder Pop-Up Menü angefordert werden. Hinweis: Es können immer nur zwei Tabellen miteinander gejoined werden. Werden mehr als zwei Tabellen ausgewählt, wird die Option „Join-Typ…“ im Pop-Up Menü grau unterlegt, kann also wegen Deaktivierung nicht benutzt werden. Es wird im Log die wichtigste SQL Syntax angezeigt, auch wenn die Abfrage über das Pop-Up Menü ausgeführt wird. Anwendung 3: Abspeichern der SQL Syntax Wurde eine Abfrage festgelegt, ist es möglich, diese via Menüleiste oder Pop-Up Menü jeweils mittels der Option „Abfrage anzeigen...“ einzusehen. Vom nächsten geöffneten Fenster,

2.3 SQL per Mausklick mit dem SQL Query Window

25

„SQL Abfrage“, kann die angezeigte Syntax (und mehr!) über den Button „Abfrage spei.“ (rechts, zweiter von oben) abgespeichert werden.

Es öffnet sich, je nach Installation, u.a. das Untermenü als „Als ext. Datei mit Create Table sp“. Im nächsten Menü werden Bibliotheksname, Tabellenname und Etikett für die SAS Syntax angegeben. Anschließend öffnet sich ein „Speichern unter“-Menü, in dem die Bezeichnung für die SAS Syntax, Format (*.sas, *.lst usw.) sowie u.a. der Speicherort (Laufwerk usw.) angegeben werden können. Mit „Speichern“ wird die Syntax aus dem Fenster „SQL Abfrage“ abgespeichert, nun allerdings u.a. mit dem CREATE TABLE-Statement (vgl. die angezeigte SQL Syntax). Anwendung 4: Entwurf eines Reports (Option „Bericht entwer.“) Wird für die Abfrage über Menüleiste oder Pop-Up Menü die sofortige Ausführung gewählt, werden die Abfrageergebnisse automatisch im voreingestellten Standardformat im SAS Output ausgegeben. Wird jedoch die Option „Bericht entwer.“ gewählt, haben Anwender die Möglichkeit, vor der Ausgabe ein anwenderdefiniertes Ausgabeformat festzulegen, in dem dann die Abfrageergebnisse in den SAS Output ausgegeben werden.

26

2 Erste Schritte mit PROC SQL

Die Bedienung basiert auf PROC REPORT im Prompt-Modus, d.h. Anwender klicken in der angezeigten Tabelle auf die angezeigten Spaltennamen. Dadurch wird ein Auswahlfenster geöffnet, mit dem Anwender u.a. Farben, Formate und weitere Optionen vor der Ausgabe einstellen können. Angesichts der weiteren Möglichkeiten von SAS, z.B. mittels ODS, sollte man allerdings keine allzu großen Erwartungen an die Funktionalität dieses Menüs haben.

2.4

Unterschiede zwischen SAS Tabellen und SAS Views

Tabellen und Views sind jeweils ein Ergebnis einer Abfrage (sog. Query) und beschreiben jeweils Daten. Der Hauptunterschied zwischen Tabellen und Views wurde am Anfang des Buches so beschrieben: Tabellen enthalten Daten und benötigen dafür Speicherplatz. Views dagegen enthalten selbst keine Daten und benötigen deshalb auch keinen Speicherplatz. Aus dem zentralen Unterschied, dass Tabellen Daten selbst enthalten und Views nicht, ergeben sich zahlreiche weitere Konsequenzen, die für die Entscheidung zwischen der Arbeit mit SAS Tabellen oder SAS Views relevant sein könnten:  Eine SAS Tabelle ist statisch, weil sie die Daten nur in der Aktualität des Zeitpunkts enthalten kann, zu dem die Tabelle zuletzt angelegt oder aktualisiert wurde. Eine SAS View ist dagegen dynamisch, weil sie die Daten so anzeigt, wie sie aktuell existieren und nicht zu dem Zeitpunkt, zu dem die View definiert wurde.  Eine SAS Tabelle kann daher auf Band oder jedem anderen Speichermedium gespeichert werden. Weil Views dagegen dynamisch sind, können sie nicht auf Band gespeichert werden.  SAS Tabellen können gelesen und geschrieben werden. SAS Views sind nur read-only. In Views kann nicht geschrieben werden, u.U. allerdings aktualisiert (jedoch nicht Views mit einem ORDER BY).  SAS Tabellen können einen optionalen Audit Trail haben, der Änderungen an der Tabelle in Form einer separaten Datei protokolliert. Jedes Mal, wenn ein Fall hinzugefügt, gelöscht oder aktualisiert wird, wird ins Protokoll geschrieben, wer die Änderung vornahm, welche Änderung vorgenommen wurde und wann die Änderung vorgenommen wurde.  Von SAS Tabellen können Kopien (sog. „generation data sets“) angelegt werden. Generation data sets sind historische Kopien einer SAS Tabelle. Das Anlegen von generation data sets kann mittels der SAS Data Set Option GENMAX= aktiviert werden. Jedes Mal, wenn eine Tabelle ersetzt wird, wird eine (Backup)Kopie abgelegt.  Für SAS Tabellen können Integrity Constraints definiert werden und diese selbst enthalten. Sobald eine Tabelle aktualisiert wird, werden die Prüfregeln aktiviert. Für SAS Views können keine Prüfregeln definiert werden. SAS Views können daher selbst keine Integrity Constraints enthalten. Integrity Constraints könnten allerdings auf die SAS Tabellen angewandt werden, aus denen Views ihre Daten beziehen.  In SAS Tabellen können Indexe angelegt werden, in SAS Views nicht.  SAS Tabellen können für größere Sicherheit verschlüsselt werden, SAS Views nicht.

2.5 PROC SQL für SAS Base Programmierer

27

 SAS Tabellen können komprimiert werden und benötigen dann weniger Speicherplatz. SAS Views können nicht komprimiert werden.  SAS kann u.U. SAS Datasets reparieren bzw. wiederherstellen (z.B. mit dem REPAIRStatement von PROC DATASETS), jedoch keine SAS Views.  Für SAS Views gibt es nicht so viele SAS Befehle wie für Tabellen; es gibt z.B. nicht das Pendant zu ALTER TABLE usw. für Views. Zwischen einer SAS View und einer SAS Tabelle gibt es demnach zwei zentrale Unterschiede, zum einen ihren Inhalt (Daten), zum anderen ihre Dynamik (Aktualität), woraus sich wiederum ein Abwägen von Sicherheit vs. Effizienz ableitet: Wird auf Daten z.B. mehrfach referenziert, ist es u.U. effizienter, mit einer (temporären) Tabelle anstelle einer View zu arbeiten, da bei jeder View die Daten neu referenziert werden müssen (z.B. bei der Arbeit mit Dictionaries). SAS Tabellen sind v.a. dann zu verwenden, falls das Risiko besteht, dass die Strukturen der zugrunde liegenden Tabellen verändert werden. Eine View ist nicht mehr einheitlich bzw. gültig, wenn sie auf veränderte bzw. nichtexistierende Daten zugreift. Aus Sicherheitsgründen sollten also (temporäre) Tabellen anstelle von (möglicherweise effizienteren) Views verwendet werden.

2.5

PROC SQL für SAS Base Programmierer

Dieses Kapitel ist für SAS Anwender gedacht, die sich einen ersten Eindruck von Unterschieden in Programmierung, Anwendung und Effizienz im Vergleich zu SAS Base verschaffen wollen. SAS Base Language gilt i.A. zwar als flexibler als SQL, mit Datensätzen in sehr komplizierten Strukturen zurechtzukommen, weil die Funktionalität von SAS Base bekanntermaßen deutlich umfangreicher und leistungsfähiger ist als SQL. PROC SQL ist z.B. weder zu DATA Step Arrays, noch zu Schleifen (loops) fähig. SQL weist allerdings demgegenüber Leistungsmerkmale auf, die wiederum in der SAS Base Language keine Entsprechung haben, z.B. die Integrity Checks oder auch die dynamische IN-Liste. SQL gilt auch i.A. für große bis sehr große Datenmengen als besser geeignet als SAS Base. Die folgenden Abschnitte werden zeigen:  grundlegende Anwendungen mit SAS Base (DATA Step) und PROC SQL.  Unterschiede in den Programmierkonventionen sowie  Unterschiede in der Performanz.

2.5.1

Programmierbeispiele: SAS Base vs. PROC SQL

Für SAS Anwender, die die SAS Base Language schon kennen, folgt hier eine vergleichende Zusammenstellung von ausgewählten Programmierungen von grundlegenden Anwendungen mit SAS Base (v.a. DATA Step) und PROC SQL (z.B. Lafler, 2004; Foley, 2005; Dickstein et al., 2007; Droogendyk & Dosani, 2008; Williams, 2008). Dieser Abschnitt setzt SAS Base

28

2 Erste Schritte mit PROC SQL

Programmierkenntnisse voraus. Die Erläuterungen werden sich daher in diesem Abschnitt auf das Wesentliche beschränken. DATA Step

SQL Einlesen von Daten (INPUT)

data EINS ; input ID $ A B C ; datalines; 01 1 2 3 02 1 2 3 03 99 99 99 04 1 2 3 05 1 2 3 ; run ;

proc sql ; create table EINS (ID char(2),A num,B num,C num) ; insert into EINS values ("01", 1, 2, 3) values ("02", 1, 2, 3) values ("03",99,99,99) values ("04", 1, 2, 3) values ("05", 1, 2, 3) ; quit ;

Der PROC SQL Ansatz unterscheidet sich in zweierlei Hinsicht in Bezug auf Effizienz. Programmiertechnisch gesehen ist das „Hardcoden“ der einzelnen Fälle in den repetitiven INSERT-Zeilen deutlich aufwendiger als der DATA Step Ansatz. Der PROC SQL Ansatz benötigt zum Anlegen der Daten zwei Durchläufe, SAS Base nur einen. Im Gegensatz zur sonst verwendeten Beispieldatei EINS ist hier die Spalte ID als Typ String definiert. Anlegen von leeren Dateien inkl. Spaltenattributen data LEER ; length ID $30 D E F 3 ; input ID $ 1-30 D E F ; label ID="ID" D="D" E="E" F="F" ; format F ddmmyy8. ; datalines ; run ;

proc sql ; create table LEER (ID num label="ID", D char (30) label="D", E num label="E", F date format=ddmmyy8. label="F") ; quit ;

Ausdrucken einer Datentabelle in den Bildschirm proc print data= EINS ; run ;

proc sql ; select * from EINS ; quit ;

Das Design der voreingestellten PRINT bzw. SQL Ausgabe unterscheidet sich minimal.

2.5 PROC SQL für SAS Base Programmierer

29

Ändern von Spaltenattributen innerhalb derselben Datei

data EINS ; format B dollar12.2 set EINS ; run ;

;

proc sql ; alter table EINS modify B format=dollar12.2 ; quit ;

Unterteilen einer Datei: Zeilen I: FIRSTOBS/OBS vs. INOBS/OUTOBS data demo ; set SASHELP.CLASS (firstobs=2 obs=10) ; run;

proc sql inobs=10 outobs=2; create table demo as select * from SASHELP.CLASS ; quit;

Die DATA Step Optionen FIRSTOBS= bzw. OBS= bezeichnen den Beginn und das Ende einer Zeilenmenge für die weitere Verarbeitung. Die Funktionalität der PROC SQL Optionen INOBS= bzw. OUTOBS= ist eine andere. INOBS= beschränkt das Einlesen auf die ersten n Zeilen einer Datenmenge. OUTOBS bewirkt dagegen die Ausgabe (von den vorhandenen bzw. eingelesenen) der ersten n Zeilen. OBS ist größergleich FIRSTOBS. OUTOBS ist kleinergleich INOBS. Unterteilen einer Datei: Zeilen II: WHERE data ZWEI ; set EINS ; where A >= 1 & C = 3 ; run ;

proc sql ; create table ZWEI as select * from EINS where A >= 1 & C = 3 ; quit ;

Das Programmieren von Bedingungen (u.a. mit WHERE) ist in Logik, Funktionalität und Programmierkonvention in SAS Base und PROC SQL technisch gleich. Ein sog. „subsetting IF“ im DATA Step kann in PROC SQL mit WHERE oder HAVING programmiert werden. Unterteilen einer Datei: Zeilen III: DELETE data EINS ; set EINS ; if B= 99 then delete ; run ;

proc sql ; delete from EINS where B= 99 ; quit;

30

2 Erste Schritte mit PROC SQL Unterteilen einer Datei: Spalten I: KEEP

data ZWEI ; set EINS (keep=ID B); run ;

proc sql ; create table ZWEI as select ID, B from EINS ; quit ;

Unterteilen einer Datei: Spalten II: DROP data ZWEI ; set EINS (drop= B) ; run ;

proc sql ; create table ZWEI as select * from EINS ; alter table ZWEI drop B ; quit;

Der PROC SQL Ansatz benötigt zum Selegieren von Spalten zwei Durchläufe, SAS Base in dieser Programmiervariante nur einen. Sortieren proc sort data = EINS out = ZWEI ; by ID ; run ;

proc sql ; create table ZWEI as select * from EINS order by ID ; quit;

PROC SQL kann Daten unkompliziert sortieren. Anstelle von SAS Base kann auf die Prozedur SORT ausgewichen werden. Auswertungsfunktionen I: Spaltenweise proc summary data = EINS nway missing ; var A ; output out=ZWEI N=N_Zeilen sum=A_sum mean=A_mean ; run ;

proc sql ; create table ZWEI as select count(*) as N_Zeilen, sum(A) as A_sum, mean(A) as A_mean from EINS ; quit ;

2.5 PROC SQL für SAS Base Programmierer

31

PROC SQL ermöglicht, diverse Aggregierungsfunktionen direkt auf Daten anzuwenden. Mit dem DATA Step können Auswertungsfunktionen mit etwas Aufwand selbst programmiert werden. Unerreicht sind jedoch die SAS Prozeduren SUMMARY oder MEANS. Auswertungsfunktionen II: Zeilenweise data ZWEI ; set EINS; QUOT= A / B ; STRING=(trim(ID)||'/'||ID) ; run ;

proc sql ; create table ZWEI as select *, A / B as QUOT, (trim(ID)||'/'||ID) as STRING from EINS ; quit ;

Abgesehen von minimalen Unterschieden in den Programmierkonventionen können zeilenweise Berechnungen und Transformationen in PROC SQL genauso wie im DATA Step programmiert werden. Zusammenfügen von Daten I: Untereinanderhängen

data ZWEI ; set EINS EINS ; run;

proc sql ; create table ZWEI as select * from EINS union all select * from EINS ; quit ;

Zusammenfügen von Daten II: Nebeneinanderstellen data FULLJOIN ; merge EINS DREI ; by ID ; run ;

proc sql ; create table FULLJOIN as select coalesce (a.ID, b.ID) as ID,A,B,C,E,F,G from EINS a full join DREI b on a.ID=b.ID order by ID ; quit ;

In SAS Base ist es erforderlich, dass die zusammenzufügenden SAS Dateien einheitlich sortiert sind (Sortierung mit PROC SORT nicht dargestellt), nicht jedoch in PROC SQL. Missings in Schlüsselvariablen können in PROC SQL u.U. zu unerwünschten Ergebnissen führen; aus Sicherheitsgründen wird empfohlen, immer standardmäßig den Effekt der Optionen COALESCE, ON und ORDER BY zu prüfen.

32

2 Erste Schritte mit PROC SQL wenn-dann-Bedingungen (IF-THEN-ELSE)

data ZWEI ; set EINS ; if ID = "3" then CODE= " mit 99" ; else CODE= "ohne 99" ; run ;

proc sql ; create table ZWEI as select *, case when ID = "3" then " mit 99" else "ohne 99" end as CODE from EINS ; quit ;

Wenn-dann-Bedingungen (IF-THEN-ELSE) lassen sich in PROC SQL zwischen CASE und END analog mit WHEN-THEN-ELSE programmieren. Ausfiltern von doppelten Werten I: Bereinigen einer Datei proc sort data = EINS nodups out = ZWEI ; by ID A B ; run ;

proc sql ; create table ZWEI as select distinct * from EINS order by ID A B ; quit;

PROC SORT und PROC SQL eliminieren jeweils alle doppelt vorkommenden Datenzeilen und legen die verbleibenden Datenzeilen in die Tabelle ZWEI ab. Die SQL Option DISTINCT ist genauso effektiv wie die SAS Base Option NODUPS. Weitere Optionen für das Einstellen von PROC SORT im Umgang mit doppelten Zeilen oder Werten sind z.B. NODUPKEY oder NODUPRECS. Ausfiltern von doppelten Zeilen II: Ablage in separate Datei data DOPPELTE (where= (DOPP_CNT=1)) ; set EINS ; by ID B ; DOPP_CNT=1 ; if first.ID and last.ID then DOPP_CNT=0 ; run ;

proc SQL ; create table DOPPELTE as select ID, A, B, C, count(*) as DOPP_CNT from EINS group by ID, B having calculated DOPP_CNT > 1 ; quit ;

2.5 PROC SQL für SAS Base Programmierer

33

Die Funktion beider Programme ist zunächst dieselbe. Beide Programme identifizieren doppelte Datenzeilen und legen sie in eine separate Datei ab. Die angelegte Variable DOPP_CNT funktioniert jedoch verschieden. Im DATA Step markiert sie Datenzeilen, die doppelt vorkommen mit einer 1 (alle anderen sind 0); alle Zeilen mit der Markierung 1 werden in DOPPELTE abgelegt. In PROC SQL werden doppelte Datenzeilen dagegen hochgezählt; anschließend werden alle Zeilen mit einem DOPP_CNT-Wert > 1 in DOPPELTE abgelegt. Sonstiges I : Zuweisen von Formaten (Beispiel für Stringeinträge) data ZWEI (drop=A B C); set EINS; A1 = input(A,yymmdd8.); B2 = input(B,comma12.2); C3 = input(C,time5.); attrib A1 informat= yymmdd8. format= yymmdds10. B2 informat= comma12.2 format= dollarx12.2 C3 informat= yymmdd8. format= hour4.1 ; run ;

proc sql ; create table ZWEI as select input(A,yymmdd8.) as A format=yymmdds10., input(B,comma12.2) as B format=dollarx12.2, input(C,time5.) as C format=hour4.1 from EINS ; quit ;

PROC SQL und der DATA Step weisen Stringeinträgen das jeweils korrekte Einleseformat zu, und ändern dieses auf das jeweils gewünschte Ausgabeformat. Die Programmierung mit PROC SQL erscheint bei dieser Aufgabe etwas effizienter zu sein als mit dem DATA Step. Diese Beispielsyntax funktioniert nur eingeschränkt für die eingangs angegebene Beispieldatei EINS. Sonstiges II : Subsetting IF (String mit einem bestimmten Wert) data ZWEI ; set EINS ; if ID eq: "0" ; run ;

proc sql ; create table ZWEI as select * from EINS where ID like "0%" ; quit ;

Das Subsetting IF (mit EQ:) im DATA Step, und LIKE (zusammen mit der %Wildcard) in SQL filtern jeweils alle Zeilen aus, deren Einträge in der Spalte ID mit „0“ beginnen.

34

2.5.2

2 Erste Schritte mit PROC SQL

Unterschiede in den Programmierkonventionen

Die Programmierung mit PROC SQL unterscheidet sich in mehrerer Hinsicht vom Programmieren mit SAS Base:  In PROC SQL sind die Namen von Tabellen, Spalten und Aliasen auf 32 Zeichen beschränkt und können Groß- und Kleinschreibung gleichzeitig enthalten.  In PROC SQL weisen einzelne SAS Funktionen u.U. etwas von SAS Base abweichende Funktionalitäten auf. Die SAS Funktion CAT gibt z.B. in einer WHERE-Klausel in PROC SQL einen Wert mit bis zu 200 Zeichen Länge zurück, im DATA Step bis zu 32767 Zeichen Länge (außer in WHERE-Klauseln) und im Makroprozessor sogar bis zu 65534 Zeichen.  Ein PROC SQL Statement läuft, sobald es abgeschickt wird. Es muss im Gegensatz zu SAS Base kein RUN-Statement angegeben werden. Wird ein PROC SQL Statement dennoch mit einem RUN-Statement abgeschlossen, ignoriert SAS dieses RUN und schickt die Statements wie sonst ab. SQL Programme können also mit QUIT abgeschlossen werden, müssen aber nicht (z.B. Queries); ein abschließendes RUN-Statement hat jedoch keinen Effekt.  Wird ein PROC SQL Statement ausgeführt, läuft PROC SQL solange, bis ein QUITStatement, ein DATA Step oder eine andere SAS Prozedur ausgeführt wird. Danach muss wieder ein PROC SQL Statement ausgeführt werden.  Das PROC SQL Statement braucht nicht für jedes SQL Statement wiederholt werden. Anders ausgedrückt: Nach einem PROC SQL Statement können mehrere SQL Statements ausgeführt werden.  Die Statements der SQL Prozedur sind in sog. Klauseln (clauses) unterteilt. Das grundlegende SELECT-Statement enthält die SELECT- und FROM-Klauseln. Items innerhalb der Klauseln werden in SQL mit Kommas getrennt und nicht mit Blanks wie in anderem SAS Code.  Das SELECT-Statement, mit dem die Daten abgerufen werden, schreibt den Output gleichzeitig auch ins SAS Output Fenster (außer wenn nach PROC SQL die Option NOPRINT angegeben wurde). PROC SQL erspart dadurch das Aufrufen der PRINTProzedur.  Das Sortieren von Daten in SQL ist nicht notwendig (man kann daher auf die SORTProzedur verzichten); im Gegensatz dazu sortiert die ORDER BY-Klausel die Daten nach den Ausprägungen einer oder mehrerer Spalten.  PROC SQL reserviert entsprechend dem ANSI Standard diverse Schlüsselwörter. Diese Schlüsselwörter können z.B. nicht als Spaltennamen oder als Tabellenaliase verwendet werden (vgl. Kap. 9, Band II).  In der SQL Syntax werden i.A. weniger Semikola verwendet als in der gewohnten SAS Programmiersprache.  Die Ausgaben von PROC SQL und die mittels sonstiger SAS Syntax unterscheiden sich etwas in Aufbau und Design.  Das Programmieren mit PROC SQL ähnelt dem mittels der SAS Base Syntax, manchmal sind SQL Programmiersätze eleganter bzw. effizienter, manchmal SAS Base Ansätze (vgl. z.B. die nachfolgenden Programmierbeispiele).

2.5 PROC SQL für SAS Base Programmierer

35

Beispiel 1: Anlegen einer temporären Tabelle (Behalten einer Variablen) data MYDATA ; set PFAD.MYDATA ; keep A ; run ;

proc sql ; create table MYDATA as select A from PFAD.MYDATA ; quit ;

Anm.: CREATE TABLE entspricht z.B. dem DATA im DATA Step, FROM dem SETStatement und AS SELECT in etwa dem KEEP. Beispiel 2: Behalten zweier Variablen (Trennzeichen in Listen) data MYDATA ; set PFAD.MYDATA ; keep A B ; run ;

proc sql ; create table MYDATA as select A, B from PFAD.MYDATA; quit ;

Anm.: In PROC SQL werden Elemente (z.B. in der FROM-Klausel) in Listen durch Kommas voneinander getrennt, im DATA Step (z.B. im KEEP-Statement) jedoch durch Blanks. Beispiel 3: Behalten zweier Variablen und Berechnen einer dritten Variablen. data MYDATA ; set PFAD.MYDATA ; C = A - B ; run ;

proc sql ; create table MYDATA as select A, B, A - B as C from PFAD.MYDATA ; quit ;

Anm.: In PROC SQL werden neue Variablen im SELECT-Statement rechts von den datenliefernden Variablen angegeben, im DATA Step dagegen links. Beispiel 4: Behalten aller uniquen Werte in einer Spalte (Ausschluss von Doppelten). data MYDATA ; set PFAD.MYDATA ; keep A B ; by A B ; if first.A ; run ;

proc sql ; create table MYDATA as select distinct A, B from PFAD.MYDATA ; quit ;

Anm.: Die Programmierung bestimmter Anforderungen, z.B. das Behalten aller Zeilen mit uniquen Werten in einer bestimmten Spalte, kann mit SQL oft deutlich eleganter sein als mit dem DATA Step. Das DISTINCT im SELECT-Statement entspricht z.B. im Prinzip den BYund IF-Zeilen im SAS Base-Beispiel. „Eleganz“ bezieht sich hier in diesem Zusammenhang jedoch nur auf die Kürze und Prägnanz des geschriebenen SQL Programms, nicht notwendi-

36

2 Erste Schritte mit PROC SQL

gerweise auf seine Performanz. Nicht alles, was für einen Programmierer schnell und elegant zu programmieren ist, ist auch für ein Verarbeitungssystem, wie z.B. SAS oder ein DBMS bei sehr großen Datenmengen ebenso schnell und elegant zu verarbeiten (vgl. Kapitel 7, Band II, zu Effizienz und Performanz).

2.5.3

Performanz: „Es kommt darauf an“

SQL gilt i.A. für große bis sehr große Datenmengen als besser geeignet als SAS Base, z.B. „In almost every case, SQL requires less code and processing time“ (Droogendyk & Dosani, 2008, 15; Hervorhebung vom Verfasser). Diese Aussage kann auf der Grundlage neuerer Benchmarktests (u.a. von Feder (2003) und Smith et al. (2003)) präzisiert werden. Feder (2003) führte z.B. diverse Benchmarktests mit SAS Base und PROC SQL u.a. auf MVS und Windows NT durch, in deren Verlauf z.B. SAS und DB2 Dateien eingelesen, gefiltert und u.a. aggregiert werden sollten. In vielen Tests waren SQL und Base-Programmierungen vergleichbar performant. In zwei Tests jedoch schnitt SQL deutlich besser ab. Der erste Test umfasste u.a. das Zusammenfügen zweier SAS Tabellen, ein Sortieren und u.a. das Ausgeben aller möglichen Kombinationen der Werte beider Tabellen. PROC SQL war dabei bis zu 4mal schneller als zwei Methoden mit SAS Base sowie etwas mehr als 3mal schneller als PROC FREQ. SQL:

SAS Base:

PROC FREQ:

proc sql; create table temp2 as select distinct fcex8577, fcex8578 from in.CUV_fcex01 where fcex8577 43, 64 IX, 4, 6–8, 18, 29, 32, 33, 43–46, 48–51, 53, 56–61, 63–65, 67, 68, 74, 82, 87, 89, 90, 110, 112, 114, 115, 121, 123, 124, 136, 137, 141, 143, 144, 152, 153, 200, 215– 217, 292, 293, 300, 301, 303, 306–310, 331, 333, 334 >= IX, 29, 43, 63, 64, 82, 90, 110, 115, 300, 301, 334 ¬ 43, 64 ¬= 43, 64

8.2 XIII, XVIII, 53, 79, 145, 265, 267, 305, 332 _ALL_ 262 _AUTOMATIC_ 262 _GLOBAL_ 262 _LOCAL_ 262 _METHOD VII, VIII, XIII, 41, 291, 294, 295 _NULL 311 _TREE VII, VIII, XIII, 41, 291, 294, 296 _USER_ 262 A ABS 43 ADABAS 256 ADD 48, 92 AIRY 43 ALL 45, 53, 54, 116, 141–143, 172, 174–176, 262, 280, 282 ALTER TABLE X, 27, 47, 48, 50, 77–79, 89, 91, 307 AND 32, 36, 37, 56, 59, 64, 69, 73, 103, 107, 110, 111, 113–115, 118, 122, 123, 145, 148, 152, 153, 155, 182, 196, 203, 211, 253, 257, 283, 285–287, 293, 294, 311, 336, 345, 346, 349 ANYALPHA 43 AS 5, 7, 15–17, 35, 38, 45, 48–51, 63, 81, 83– 86, 89, 93, 105, 107, 125–127, 138, 157, 200, 224–226, 286, 295 AS400 256 ASC 108, 109, 118, 331 ASCENDING 109 ATTRIB 260 AVG 23, 53, 115, 116, 123, 145, 274–276, 320, 325, 326, 328, 329, 334

352 B B2_UNIX 256 BETWEEN IX, 41, 43, 53, 56, 115 BTRIM IX, 41, 43, 53, 56 BUFFERSIZE 52, 98, 296 BY XVIII, 35, 39, 50, 107, 115, 119, 121, 123, 162, 164, 193, 210–212, 214, 223, 230, 238, 249, 260, 261, 263, 264, 297 C CALCULATED IX, XI, 19, 41, 53, 56, 106, 107, 112, 117, 121, 126, 196, 210, 216, 303, 304 CALL PRXDEBUG 262 CALL SYMPUT XIII, 265, 277, 279 CALL SYMPUTX XIII, 265, 277, 279 CASE X, XVII, XVIII, 32, 38, 43, 53, 57, 66, 69, 77, 100, 101, 107, 124–127, 129–137, 208, 287 CDF 43 CHAR 60 CHARACTER 60, 61 CHECK 82 CLASS 69, 74, 84, 88, 94, 95, 148–150, 155, 215, 288, 303 CLOSE 308–310 COALESCE IX, XI, 31, 39, 41, 43, 53, 57, 58, 164, 186, 192, 193, 197, 210, 214, 215, 230, 238, 249, 292, 293 COMMA10. 72, 85, 202, 203 COMMA12.2 33 COMMA14. 119, 120, 329 COMMA2. 299 COMMA20. 99, 118 COMMA8.2 79, 123, 305 COMMIT 40, 91 COMPBL 43 COMPGED 300 COMPLEV 300 COMPRESS 43 CONNECT TO 47, 49, 50 CONNECTION TO 47, 49, 53, 58 CONSTRAINT 48, 82 CONTAINS 43, 53, 58, 64, 115

Syntaxverzeichnis CORR 45, 71, 156, 163, 166, 168–170, 302, 303 CORRESPONDING 45, 168 COUNT XIII, XVIII, 43, 53, 115, 116, 123, 265, 274, 280, 281, 283, 284, 286, 300, 301 CREATE 5–8, 15, 20, 25, 35, 39, 47, 48, 50, 51, 63, 65, 75, 81–89, 91, 93–97, 99, 104, 105, 107, 138, 162, 200, 295 CREATE INDEX 47, 50, 81, 162 CREATE TABLE 6–8, 15, 20, 25, 35, 47, 48, 50, 51, 63, 65, 75, 81–89, 91, 93, 94, 96, 97, 104, 105, 138, 200, 295 CREATE VIEW 6, 7, 15, 39, 47, 48, 51, 84– 86, 95, 99 CROSS JOIN 46, 183, 194, 196, 197 CSS 43, 53, 274 CUROBS 162 CV 53, 273, 274, 279, 282 D D3D 309 D3DSTYLE 309 DACC 43 DATALINES 10, 14, 15, 28, 130, 150, 154, 166, 181, 208, 209, 213, 221, 238, 288, 298, 318, 319, 341–343 DATE 60, 68, 114, 337 DATE7. 60 DATETIME 43 DB2 36, 256 DBASE 256 DBMS XIV, 2, 5, 36, 39, 40, 47, 49–52, 58, 80, 90–92, 115, 214, 256–259 DDE 311 DDMMYY8. 28, 81, 82, 92 DEBUG 262 DEC 60 DECIMAL 60 DELETE 19, 29, 47, 48, 51, 86, 87, 91, 97 DEP 43 DESC 69, 109, 118, 283, 284, 332 DESCENDING 107, 109 DESCRIBE TABLE 47, 48, 51, 87–89 DESCRIBE TABLE CONSTRAINTS 47, 48, 51, 89

Syntaxverzeichnis DESCRIBE VIEW 47, 48, 51, 89 DICTIONARY.MEMBERS 88 DIF 43 DISCONNECT 47, 49–51, 80, 81, 90 DISCONNECT FROM 47, 49, 50 DISTINCT 32, 35, 44, 49, 53, 116, 280–282 DOLLAR. 209, 343 DOLLAR12.2 29, 79 DOLLAR14.2 305 DOLLARX12.2 33 DOUBLE 52, 60, 98, 99, 306 DOUBLE PRECISION 60 DQUOTE 38, 52, 98 DROP 30, 33, 47, 48, 51, 78, 79, 89, 91, 95, 277, 292 DROP INDEX 48, 51, 91 DROP TABLE 48, 51, 91 DROP VIEW 48 E ELSE X, 32, 57, 77, 101, 107, 124–129, 131, 133–137, 289 END 32, 57, 68, 101, 107, 125–129, 131– 137, 289 EQ 33, 43, 64, 113, 145, 277, 278, 330 EQ: 33 EQT 43, 300 EQT IX, 63, 64, 299, 300 EQUAL 64 ERRORSTOP 52, 98 ESCAPE 59, 60 EURDFWDX. 79 EURO. 208, 209, 343 EXCEL 256, 259, 310–312 EXCEPT 38, 45, 165, 167, 168, 172–176 EXCEPT ALL 175–177 EXEC 52, 98 EXECUTE 40, 47, 50, 52, 90–92 EXISTS 43, 53, 58, 59, 141–143, 199, 204, 335 F FEEDBACK VII, XIII, XVIII, 52, 98, 291, 292 FETCH 162

353 FETCHOBS 162 FIND 43, 300 FIRST 32, 35, 36 FIRSTOBS 29 FLOAT 60 FLOW 52, 98 FOREIGN KEY 48 FORMAT 28, 29, 33, 60, 61, 65, 67, 69, 72, 79, 81–85, 92, 96, 99, 106, 118–120, 123, 145, 148–150, 202, 203, 205, 206, 208, 209, 257, 259, 285, 302, 305, 307, 329, 332, 336, 343 FREQ XIII, 36, 37, 53, 265, 266, 274, 277, 281 FROM IX, X, XII, 6, 15, 34, 35, 38, 41, 44– 46, 48, 49, 51–53, 56, 61, 65, 77, 86, 87, 97, 99, 103, 147, 150, 157, 179, 180, 182, 184–192, 198, 199, 219, 220, 223, 229– 231, 237, 239, 248, 250, 253 FULL 38, 46, 161, 179, 180, 185, 186, 193, 224, 228, 236, 241, 247 FULL JOIN 46, 161, 179, 185, 186, 193, 224, 241 G GE 37, 43, 55, 64, 109, 110, 144, 196 GENMAX 26 GET 64 GETNAMES 256, 257 GRANT 39, 92 GREATER THAN 64 GREATER THAN OR EQUAL 64 GROUP BY IX, X, XVIII, 10, 37, 41, 44, 49, 52, 54, 55, 77, 99, 108, 115, 119, 121–124, 130, 132, 283, 284, 287, 295, 304 GT 43, 64, 99, 201, 289, 292, 333 GTT IX, 63, 64 H HARMEAN 43 HAVING IX, X, 13, 29, 38, 41, 44, 45, 49, 52–54, 59, 63, 77, 99, 110, 114, 115, 119, 121–124, 138–141, 143, 144, 199 HOUR4.1 33 HTML XIII, 291, 308, 310, 313

354 I IDXWHERE XIII, 291, 296 IF 29, 32, 33, 35–37, 115 IFNULL 39, 58, 214 IN 27, 43, 53, 59, 64, 111, 143–146 IN= 37 INDEX 48, 81, 300 INFILE 311 INFORMAT 33, 60 INGRES 256 INNER XVIII, 38, 45, 46, 179, 180, 182–184, 193, 223, 231, 239, 251 INNER JOIN 193, 223, 231, 239 INOBS 29, 52, 98 INPUT 10, 14, 15, 28, 33, 130, 150, 154, 166, 181, 208, 209, 213, 221, 238, 288, 298, 299, 311, 318, 319, 341–343 INSERT 3, 28, 47, 49, 51, 52, 70, 74, 75, 84, 87, 92–98, 156, 205 INSERT INTO 28, 49, 52, 74, 92–94, 96, 97, 155, 206 INT 60 INTCK 43 INTEGER 60 INTERSECT 38, 45, 165, 167, 171, 173–175, 177 INTO 44, 49, 97, 139, 200 IRR 43 IS X, 43, 53, 59, 68, 77, 87, 97, 103, 107, 110, 115, 155, 294, 334 IS NOT 68, 107, 110, 115, 155, 334 K KEEP 30, 35–37 L -L XIV, 27, 37, 61, 99, 101, 103, 134, 296, 299 LABEL 28, 66–68, 81, 82, 92, 96, 105, 131, 132, 155, 201, 205, 206, 259, 304, 307, 331, 336 LABEL=“#“ 307 LAG 43 LAST XV, 32 LE 64, 107, 126, 127

Syntaxverzeichnis LEFT JOIN 46, 179, 185, 224, 241 LENGTH 28, 61, 260, 301, 307, 331 LESS THAN 64 LET 64 LIBNAME 16, 22, 84, 86, 88, 256, 257 LIKE 33, 43, 48, 50, 53, 59, 60, 64, 82, 115, 300 LIST 256, 257 LOOPS 52, 98 LOTUS 256 LOWER 43, 53, 60 LT 43, 64, 126 LTT 64, 113, 299 M MAD 43 MAGIC XIII, 291, 296 MAX XIII, 53, 143, 265, 274, 280–282 MEAN 23, 30, 43, 53–55, 71, 116, 117, 119– 121, 123, 124, 274–276, 288, 289, 306, 307 MEDIAN 277 MEMBERS 37 MEMNAME 88 MEMTYPE 88 MERGE 31, 36, 37, 162, 164, 193, 222, 230, 238, 249, 260, 261, 263 MIN XIII, 53, 122, 265, 274, 280–282 MISSING 4, 30, 59, 68, 87, 107, 110, 115, 155, 334 MIXED 256, 257 MLOGIC 262 MLOGICNEST 262 MODE 259, 278 MODIFY 48, 79, 162, 261, 263, 264 MONOTONIC 303 MPRINT 262 MPRINTNEST 262 N N XIII, 30, 53, 65, 67, 73, 75, 99, 116, 139– 141, 143, 144, 183, 193, 194, 196, 197, 265, 266, 274–276, 280, 281, 285, 320– 322, 325, 326, 328–330, 334, 336 NATURAL XI, XVIII, 46, 159, 193, 197, 293 NATURAL JOIN 198, 332

Syntaxverzeichnis NDEC 60 NE 19, 43, 64, 69, 111, 148, 149, 253, 336 NET IX, 63, 64 NMISS 53, 274, 281 NO 61, 209, 343 NODOUBLE 52, 98 NODUPKEY 32 NODUPRECS 32 NODUPS 32 NOERRORSTOP 52, 98 NOEXEC 52, 98, 262 NOFEEDBACK 52, 98 NOFLOW 52, 98 NONUMBER 52, 98 NOOBS 7, 8, 14, 16, 65, 95, 132, 157, 166– 178, 181, 183, 184, 186–198, 209, 223– 240, 242–249, 254, 255, 282, 289, 294, 303 NOPRINT 34, 36, 52, 98, 143, 156, 177, 178, 277 NOPROMPT 52, 98 NOSORTMSG 52, 98 NOSTIMER 52, 98 NOT 43, 56, 58, 59, 64, 92, 102, 103, 110, 113, 115, 142, 149, 199, 292, 293, 335 NOT EQUAL 64, 149, 292 NOT EXISTS 59, 142, 199 NOT IN 102, 103, 293 NOTE 54, 162 NOTHREADS 52, 98 NOXSYNC 311 NOXWAIT 311 NPV 43 NULL 4, 39, 59, 92, 115 NUMBER 52, 98 NUMERIC 60 NWAY 30 O OBS 29, 152, 153, 211, 302, 331 ODS 308–310 ODS HTML 310 ODS LISTING 308–310 ODS LISTING CLOSE 308–310 ODS OUTPUT 308 ODS PDF 309

355 ODS RTF 309 ON 31, 38, 45, 46, 48, 54, 59, 179, 180, 182– 185, 210–212, 214, 223–227, 229–235, 237, 239–242, 244, 245, 247, 248, 250, 293 OPEN 162 OR 64, 293, 345, 346 ORACLE 80, 90, 92, 256 ORDER BY 13, 26, 31, 34, 39, 48, 49, 51, 84, 99, 107, 108, 118, 119, 130, 180, 186, 224– 226, 231, 240, 242, 283, 284, 304 OUT 30, 32, 36, 211, 310 OUTER 38, 45, 46, 71, 156, 160, 163, 165, 166, 168–170, 224, 232, 241, 302, 303 OUTER UNION 71, 98, 166, 168–170, 177, 302, 332 OUTER UNION CORR 71, 98, 166, 168– 170, 177, 302, 332 OUTFILE 312 OUTOBS 5, 29, 52, 69, 71–74, 98, 183, 194– 196, 304 OUTPUT OUT 30, 277–279 P P25 278, 280 P75 278, 280 P90 278 P95 278 P99 278 PASS 80, 90–92 PATH 80, 90, 92, 256 PCTL 43 PDF XIII, 291, 308, 309 POINT 162, 263 PRIMARY KEY 48, 82 PRIME 256 PRINT 16, 28, 34, 52, 98, 312, 337 PRIVILEGES 39 PROBCHI 43 PROBMC 43 PROC ACCESS 256, 257 PROC APPEND 163, 264 PROC COMPARE 260 PROC CONTENTS 259 PROC DATASETS 27, 163, 259, 260 PROC EXPORT 312

356 PROC IMPORT 256, 257, 310 PROC MEANS 277, 288 PROC PRINT 5, 7, 16, 98, 209, 259, 261, 306, 308 PROC REPORT 5, 26, 259, 308 PROC SORT 30, 32, 36, 211 PROC SQL passim PROC SUMMARY 30 PROC UNIVARIATE 278, 279 PROMPT 52, 98 PRT 53, 274, 282 PRXMATCH 43, 300, 302 PUT 299 Q Q1 271, 278, 280 Q3 271, 278, 280 QRANGE 279 QUANTILE 43 R RANBIN 43 RANGE 53, 106, 274, 279 RANNOR 43 REAL 60 RENAME 17, 18, 83, 86, 256, 257 REPAIR 27 REPLACE 312 RESET 47, 49, 52, 98, 99 RESOLVE 43 RIGHT JOIN 46, 179, 185, 224, 241 ROLLBACK 40 RTF 309 RUN 7, 8, 10, 14, 15, 20, 28–35, 37, 65, 79, 87, 94, 97, 98, 117, 128, 130, 132, 134, 139, 143, 148, 151, 154–156, 166–178, 181, 183, 184, 186–192, 194–198, 209, 211, 221, 223–240, 242–249, 254–257, 274, 277–279, 288, 289, 294, 298, 299, 303, 310, 311, 318, 319, 341–344 S SAME 115 SASHELP.VCOLUMN 89 SAVING 43

Syntaxverzeichnis SCANTYPE 256, 257 SELECT IX, X, XVII, 5, 6, 15, 16, 19, 34, 35, 38, 41, 44, 47, 49, 52–54, 56, 63, 65, 69, 77, 79, 83, 84, 86, 89, 92, 98, 99, 103– 105, 107, 108, 112, 119, 121, 122, 140, 149, 150, 155–157, 163, 178–180, 185, 186, 188–191, 193–195, 198, 215, 216, 220, 225, 228–230, 232, 233, 235–237, 242, 246–248, 253, 295, 302, 306, 307 SET 35, 44, 49, 100, 156, 162, 168, 209, 260, 261, 263 SKIPROWS 256, 257 SLEEP 311 SMALLINT 60 SORTMSG 52, 98 SORTSEQ 52, 98 SOUND 43 SOUNDEX 301 SQL_RESULTS 308 SQXCRTA 295 SQXFIL 295 SQXJHSH 295, 296 SQXJM 295, 296 SQXJNDX 295 SQXJSL 295 SQXSLCT 295 SQXSORT 295 SQXSRC 295 SQXSUMG 295 SQXSUMN 295 SQXUNIQ 295 STD 53, 274, 279, 288 STDERR 53, 274, 282 STIMER 52, 98 STYLE 309 SUBSTR 43, 61, 68, 101, 115, 131, 132, 134, 135 SUBSTRING IX, 41, 43, 53, 61 SUM XIII, XVIII, 11, 12, 14, 30, 53, 65–69, 71, 73, 99, 117–120, 131, 132, 139, 140, 143–145, 156, 157, 178, 179, 253, 265, 274–276, 280, 282–284, 286, 287, 289, 320, 321, 329–332 SUMWGT 53, 274 SYBASE 256

Syntaxverzeichnis SYMBOLGEN 262 SYMGET 43 T T 53, 340 TERADATA 80, 90, 91 THEN X, 29, 32, 57, 68, 77, 101, 107, 124– 137, 289 THREADS 52, 98 TIME5. 33 TINV 43 TODAY 43 TRANSCODE 61 TRIGAMMA 43 TRIM 31, 152, 155, 307 U ULTRIX 256 UNDO_POLICY 20, 40, 52, 97, 98, 147, 156 UNIFORM 43 UNION XI, XVIII, 31, 38, 45, 46, 71, 156, 159, 160, 162, 163, 165–173, 176–178, 193, 198, 302, 303, 332 UNION ALL 31, 172, 332 UNION JOIN 46, 162, 198 UNIQUE 48, 92 UPDATE IX, X, XVII, 3, 41, 47, 49–52, 75, 77, 81, 84, 86, 91, 92, 100, 124, 125, 132– 138, 162, 208, 260, 261, 263, 264 UPPER 43, 53, 62 USER 92, 345 USING 86 USING LIBNAME 86 USS 53, 274 V VALIDATE VII, X, XIII, XVIII, 47, 49, 52, 77, 102, 103, 262, 291, 293

357 VALUES 49, 93 VAR 10–14, 30, 53, 58, 274, 277–279, 282, 288, 303, 341 VARCHAR 60, 61 VLENGTH 259 VLENGTHX 259 VTYPE 259 W WEIGHT 215, 288 WHEN X, 32, 38, 57, 77, 100, 101, 107, 124– 129, 132, 133, 135, 136 WHERE IX, X, 6–8, 10–14, 18, 19, 29, 32– 34, 36–38, 41, 44–46, 48–54, 56, 58, 59, 63, 65, 67–74, 77, 86–88, 90, 94–97, 99, 100, 102, 103, 109–115, 118, 120–122, 124, 125, 132–134, 138–146, 148–150, 152, 153, 155, 157, 162, 175, 178–182, 193, 195–197, 199–205, 208–212, 214– 217, 252–254, 256, 257, 274, 277–279, 283–287, 292, 293, 297, 300, 301, 303, 308–310, 328–331, 333–336 WIDTH 60 WK4 256 WORKSHEET 256 X X 56, 311 XLS 256, 311 Y YES 61 YYMMDD8. 33 YYMMDDS10. 33 Z Z3. 299 ZIPFIPS 43

Sachverzeichnis %PUT-Statement 262 *.lst 25 *.sas 25, 259 *.sas7bdat 259 25%-Grenze 271, 280 32 Tabellen 45, 46, 180 50.Zentil 269 75%-Grenze 271, 280 I. Quartil 271 III. Quartil 271 A Abfolge der Spalten 24, 109, 185, 307 Abfolge der Tabellen in der FROM-Klausel XII, 180, 185, 219, 220 Abfrage V, VI, VIII–X, XVII, 1–3, 5, 6, 9, 14–16, 18, 20, 21, 23–26, 41, 44, 54, 63, 66, 68, 69, 77, 108, 110, 112, 114, 138, 139, 183, 194, 197, 199, 257, 273, 274, 300, 320–325, 327, 331 Abfrage aller Spalten 15 Abfrage anzeigen 24 Abfrage ausführen 23 Abfrage bestimmter Ausprägungen X, 77, 114 Abfrage bestimmter Ausprägungen einer (oder mehrerer) Datumsvariablen 114 Abfrage bestimmter Spalten 16 Abfrage bzw. Ausschluss bestimmter Ausprägungen 110, 112 Abfrage zweier Variablen 18 Abfrageergebnisse 25, 63 Abläufe innerhalb einer Tabelle XVII, 9 Absatzzahlen 136 Abspeichern der SQL Syntax 21, 24 Absteigendes Sortieren 108

Abstimmen der Programmierung 115 Abweichung vom Zentrum einer Verteilung XII, 265, 268, 271 access method 160 accumulated declining depreciation 43 Addis Ababa 69, 70, 118, 120, 122, 123, 142, 145, 146, 211, 212, 283–287, 307, 340 Addition 116, 135 Afrika 70, 118, 283–287 Aggregieren 36, 65, 68, 69, 115 Aggregierte Werte 283, 284 Aggregierung XIII, 265, 280 Aggregierungsfunktion X, XIII, XVIII, 31, 53–55, 77, 108, 110, 115–117, 119–124, 131, 132, 138, 199, 261, 265, 280 Aktualisieren VI, IX–XI, 3, 41, 47, 77, 100, 124, 135, 138, 160, 205, 208, 263 Aktualisieren mehrerer Variablen 138 Aktualisieren von Werten IX, X, 41, 47, 77, 100, 205, 208 Aktualisierung XI, XVII, XVIII, 77, 100– 102, 124–126, 132–135, 138, 160, 205, 208, 209 Aktualisierung durch Multiplikation 100 Aktualität 2, 26, 27 Alias 23, 38, 42, 45, 48–50, 56, 58, 69, 80, 90, 149, 152, 155, 180, 186–188, 191, 194– 196, 204, 205, 209, 215, 220, 225–227, 230, 237, 243–245, 248, 253 Als ext. Datei mit Create Table sp 25 American National Standards Institute 2, 4, 9, 345 Analyse V, VI, XII, 71, 151, 258, 262, 265– 267, 287, 288, 315, 316, 347, 349 Analyst 5 Anbaugebiet 161

360 Ändern 29, 47, 79, 99, 298, 320 Ändern des Zeilenabstands der ausgegebenen Tabellen 99 Ändern von Attributen von Variablen/Spalten 79 Ändern von Spaltenattributen 29 Änderungen 26, 80, 81, 97, 100, 263, 310 Anfordern einer Summe 66 Animationen 266 Anlegen VIII, X, XIII, 7–9, 14–16, 26, 28, 35, 47, 77, 79, 81, 82, 86, 96, 105, 115, 124–127, 130, 138, 139, 200, 256, 257, 291, 298, 303 Anlegen einer ID-Variablen XIII, 291, 298, 303 Anlegen einer leeren Tabelle 81, 82 Anlegen einer neuen Spalte 127 Anlegen einer SAS Tabelle 7 Anlegen einer temporären Tabelle 35 Anlegen eines Index für eine Variable 81 Anlegen eines Index für mehrere Variablen 81 Anlegen eines permanenten Datensatzes 16 Anlegen neuer Spalten X, 77, 105 Anlegen und Verwenden eines Index 115 Anlegen von leeren Dateien 28 Anlegen von leeren Spalten 79 Anlegen zweier Tabellen einschl. anschließendem Join 96 Ansehen des Inhalts eines ganzen Verzeichnisses 88 ANSI VI–IX, XIV, XVII, 1, 2, 4, 9, 34, 37– 39, 41, 43, 45, 59, 139, 300, 345 ANSI Compliance 37 ANSI SQL Funktion IX, 41, 43 ANSI Konformität VII, 1 ANSI Standard VI, VIII, XIV, 1, 2, 4, 9, 34, 37, 38, 45, 59, 139 anwenderdefiniert 39, 74 Anwendungen VI–IX, XVII, 2, 3, 9, 14, 21– 25, 27, 41, 43, 47, 53, 69, 78, 172, 308, 311 Anzahl fehlender Werte 53, 274 Anzahl nichtfehlender Werte 53, 274 Anzeige 16, 47, 85 Anzeige aller Tabellen/Spalten 85

Sachverzeichnis Anzeigen ausgewählter Tabellen/Spalten 85 Anzeigen des Inhalts einer Query 83 Äpfel/Birnen-Vergleich 161 Äpfel und Birnen XI, 159 Arbeit mit einer Tabelle VI, VII, IX, X, XVIII, 77, 156 Arbeit mit Strings XIII, 291, 298, 299 Arbeit mit zwei und mehr Tabellen IX, X, XVIII, 77, 78, 157, 258 Arbeiten innerhalb einer Tabelle XVII, 77 Arbeiten mit drei und mehr Tabellen XVIII, 249 Arbeitsblatt 311 Argument 43, 61 Arithmetisches Mittel 53, 120, 121, 269, 270, 273, 274 Arrays 27, 43, 54 asymmetrisch 270 Attribute 3, 61, 82, 87, 88, 220, 260, 261, 302 Attribute übernehmen 302 Attributstrukturen 3 Audit Trail 2, 26, 82, 259, 263 Aufgabe XIII, XIX, 33, 208, 311, 315, 316, 320–336 Auflösung 292, 293 Aufsteigendes Sortieren 108 Ausdruck IX, XVII, 2–4, 38, 39, 41–52, 54, 56–59, 63, 64, 83, 84, 99, 102, 103, 108, 115, 124–126, 129, 133, 135, 138, 139, 141–144, 146, 164, 179, 180, 183–186, 189–191, 199, 223–237, 239–242, 244– 248, 250–252, 261, 262, 298 Ausdrucken einer Datentabelle 28 Ausfiltern von doppelten Werten 32 Ausfiltern von doppelten Zeilen 32 Ausführen 5, 6, 22, 23, 47, 91, 92, 156, 294 Ausführung IX, XIV, 10–13, 23, 24, 63, 103, 165, 183, 194, 197, 293, 294, 296 Ausführungshierarchie 43 Ausgabe von gruppierten Anteilen 286 Ausgabe von gruppierten Prozentwerten 284 Ausgabeformat 25, 33, 309 Ausgangszustand 40 Ausgewählte Spalten 23 Ausgewählte Tabellen 22, 24

Sachverzeichnis Auslieferung V Ausreißer 270–273 Ausschluss von Doppelten 35 Auswählen IX, 41, 47, 294 Auswahlfeld 23 Auswahlfenster 24, 26 Auswertungsfunktion VIII, IX, 1, 4, 30, 31, 37, 41, 43, 53, 54, 115, 274, 279, 280 automatisch V, IX, 3, 5–7, 15, 16, 25, 45, 50, 63, 88, 163, 260, 277, 289, 298, 302, 309 Automatisierung 2 Autor VI, XV, XIX, 294, 349 Avatar 318, 322, 324, 325, 327 B Backup-Kopie 26, 263 Baum-Diagramm 296 Bearbeiten 3 Bedeutung V–VII, XI, 1, 2, 4, 210, 265, 273 Bedingte Auswahl 68 Bedingtes Aktualisieren 100, 101, 132 Bedingtes Einfügen/Aktualisieren von Werten 134 Bedingung VIII–X, XVII, 5, 19, 29, 32, 41, 43, 47, 52, 57, 59, 60, 63, 64, 74, 77, 90, 100, 101, 107, 109, 110, 112, 114, 115, 119–129, 132–136, 141, 142, 144, 147, 149, 150, 153, 155, 175, 182–184, 193– 196, 199, 204, 205, 211, 216, 217, 224, 226, 228, 232, 234, 236, 241, 243, 247, 250, 253, 261, 277, 293 Bedingungen für kategorialskalierte Variablen 129 Beenden einer Verbindung 90 Befüllungsgrad 175 Behalten aller uniquen Werte 35 Behalten ausgewählter Tabellen/Spalten 83 Behalten bzw. Löschen von Zeilen 19 Beispiel passim Beliebtheit V Benchmarktest 36 Beobachtungen 3, 4, 161, 185, 200, 224, 226, 228, 232, 234, 236, 241, 243, 247, 262, 271, 308, 312 Beobachtungsnummer 162

361 Berechnen VIII, 9, 14, 35 Berechnung VI, X, XI, XIII, XVII, XVIII, 3, 18, 31, 43, 53, 71, 77, 105–107, 115, 117, 121, 124, 160, 161, 205–207, 216, 253, 265, 266, 269–280, 283, 287 Berechnung gruppierter aggregierter Werte X, 77 Berechnung von Lage- und Streuungsmaßen XIII, XVIII, 265, 273 Berechnung von Quantilen 43, 278 Berechtigung 92, 253, 255 Bereinigen einer Datei 32 Bericht entwer. 21, 25 Beschleunigung 2 Beschreibung VII, VIII, XIII, 1, 4, 265, 266, 269, 274, 347 Besonderheiten IX, XI, XII, XIV, 41, 63, 80, 81, 84, 90, 159, 162, 219, 221, 222, 250, 258, 259, 289 Betriebsumgebung 23 BETWEEN-Bedingung IX, 41, 53, 56 Beziehung XI, 159–162, 164, 165, 180, 212, 220–222, 238, 261, 315, 316 Bezugnahme auf mehrere Tabellen XVII, 70 bi- oder multimodal 267, 270 Bibliotheksname 25 Blank 59 Bookmark 311 Boole 4, 39, 64, 124, 125 Boole'scher Wert 124 Breite 60, 79, 271, 307 BTRIM-Funktion 53, 56 Bündelung V BY-Merge XVIII, 223 BY-processing 260 BY-Variable 115, 119, 121, 132, 164, 261, 263, 264 BY-Wert 164 C CALL-Routinen 300 Canada 6–8, 72, 74, 113, 119, 123, 141, 144, 178, 179, 201–205, 217, 304 Case Control Studies X, 78, 150, 151 CASE/END-Ausdruck X, 77, 125, 133

362 CASE-Ausdruck 38, 43, 53, 57, 66, 69, 124– 126, 208 Character 39, 260 Clusteranalyse XV, 346 COALESCE-Funktion 39, 53, 57, 58, 164, 186, 197, 214, 230, 238, 249 Codes 294, 296 coefficient of variation 273 collating sequence 39 COMMIT-Statement 40, 91 Concatenating XI, 159, 162, 163 Constraint-Spezifikation 48 CONTAINS-Bedingung 53, 58 CRM V Cross Joins IX, 41 CSV 313 CV 53, 273, 274, 279, 282 D DACC 43 Dashboards 266 Data Management 22 data relation XI, 159, 160 DATA Step VIII, 9, 27–29, 31, 33–35, 40, 43–45, 61, 83, 115, 155, 163, 164, 193, 222, 230, 238, 249, 260, 262, 263, 277, 298, 311, 312, 345, 346 Data Step Debugger 262 data structure XI, 159, 160 Data Warehouse V, 266 Dateiattribute 81, 82 Daten passim Datenanalyse XV, 346, 349 Datenbanken V, IX, 1, 4, 37, 61, 63, 80, 81, 256 Datenbeziehungen XII, 219, 220 Datendatei VIII, 1, 3, 4 Datenintegrität VI, 3, 20, 97 Datenmanagement XV, 346 Datenmengen V, XIV, 27, 29, 36, 37, 51, 84, 114, 138, 199, 262, 266, 267, 272, 297 Datenqualität XIV, XV, 2, 51, 262, 346, 349 Datensatz VI, 3, 4, 16, 17, 45, 51, 80, 81, 84, 86, 100, 102, 107, 134, 153, 272, 288, 301, 303, 312, 320, 323

Sachverzeichnis Datensatz-Optionen 51, 84, 86 Datensatz-Optionen in Views 86 Datenspalte VIII, 1, 3 Datenstruktur XII, 219, 220 Datentyp 43, 58, 60 Datenzeile VIII, 1, 3, 4, 166, 187–191, 193, 212, 214, 230, 238, 249 Datum 43, 61, 109, 205, 206 Datums- und Kalenderberechnungen 43 Datumsformat 60, 80 Datumsspalten 114 DB2 36, 256 DBCS 43, 54 DBMS XIV, 2, 5, 36, 39, 40, 47, 49–52, 58, 80, 90–92, 115, 214, 256–259 DBMS Zugriff XIV DBMS-Query 49, 58 DDE 311, 312 DDE-Triplet 311 Deaktivierung 24 declining balance depreciation 43 Definition X, 2, 3, 23, 47, 51, 57, 61, 78, 89, 92, 156, 178, 179, 182, 183, 207 Definition neuer Variablen im SELECTStatement X, 78, 156, 178 DEP 43 Design 21, 28, 34, 310 Designen der Spalten einer Tabelle 307 Designen des Inhalts (Zeilen) einer Tabelle 306 Designen des Kopfes einer Tabelle 307 Designen einer SQL Ausgabe XIII, XIV, 291 Designen einer Tabelle 306 Deskriptive Statistik VI, VII, XII, XVIII, 265 Details IX, 39, 41–46, 52, 53, 56–62, 69, 98 Dezimalstellen 61 Dichtester Wert 269 Dictionary Tables 5 Differenzbildung 207 Differenzwert 208 direkt V, XI, 5, 21, 31, 40, 63, 65, 70, 84, 85, 99, 106, 117, 121, 124, 159, 162–164, 169, 172, 173, 176, 208, 262, 263, 272, 288, 294, 296, 302, 308–312 Direktes Mergen 164

Sachverzeichnis Dispersion 267 Division 65–67, 74, 100, 116 Divisor 275, 276 Dokumentation XIV, XV, 38, 39, 43, 52, 98, 122, 259 doppelt 32, 33, 186, 189–191, 225, 228, 229, 232, 233, 235, 236, 242, 246–248 Doppelte 104, 116, 117, 169, 171, 175, 194, 261 Download XV Dreiwertige Logik VIII, 9, 39 Durchläufe 28, 30, 54 Durchschnitt 201, 270, 288 Durchschnittswerte von Werten bzw. Zeilen 116 DWH-Daten 266 Dynamic Data Exchange 311 Dynamik 27 dynamisch 26, 27, 58 Dynamische IN-Liste 27 Dynamischer Datenaustausch 311 E eBay V Effizienz VI, VIII, XIV, 2, 9, 14, 27, 28, 36, 114, 141, 142, 320 Effizienz beim Schreiben von WHEREKlauseln 114 Einfügen 3, 51, 82, 92, 93, 95, 100, 101, 135 Einfügen einer Zeile "von Hand" 93 Einfügen von Werten 100, 101 Einfügen von Zeilen in sortierter Reihenfolge 95 Einfügen zweier (oder mehr) Zeilen "von Hand" 93 Einfügen zweier (oder mehr), auch nicht vollständiger Zeilen 93 Einführung VI, XIV, 2, 4, 37, 39, 166, 181, 221, 238 Einführungskapitel VII Eingebettetes PROC SQL 40 Einheit 207, 320 Einheitlichkeit 8, 138, 200 Einleseformat 33 Einlesen von Daten 28

363 Einschränkung IX, 21, 41, 46, 50–52, 72, 89, 92, 99, 100, 193 Einspielergebnis XIII, 315, 316, 320, 322– 326 Einsteiger XIV, 2 Einstellungen 5, 24 Eleganz 35 Elemente der PROC SQL Syntax XVII, 41 embedded SQL 40 Empfehlungen von SAS XIII, 291 Empfehlungen zur Problemlösung 52, 102, 262, 293 Enterprise Guide 21, 22 Entwurf eines Reports 21, 25 Equi-Join XI, 24, 46, 70, 71, 159, 179–183, 220, 250–254 Erdbeben 270 Ergebnis-Ausdruck 57 Erlaubnis 92 ERM 3 Ermitteln eines Maximums 118 Ermitteln von Durchschnittswerten X, 77 Ermittlung von Summen 117 Errechnen vs. Ablesen 267 Erstellen einer Abfrage 21, 23 Erzeugen kartesischer Produkte 19 Erzwingen von Konkatenierungen 172 Etikett 25, 61 Euro 208, 209, 349 EXISTS-Bedingung 53, 58, 59, 142 Exklusiver Union 172, 176 Exkurs IX, 41, 54, 55, 163 Explizite Verweise 186, 189–191, 225, 228, 229, 232, 233, 235, 236, 242, 246–248 Export XIII, 291 Exportieren von SQL Output 309, 310 Exportieren von Tabellen aus PROC SQL nach SAS 308 Externe Dateien und Routinen 43, 54 Extremwerte 270, 272 F Fall-Kontroll-Analysen X, 78 Fall-Operand 57

364 Fallstricke XVIII, 127, 129, 130, 207, 210, 215 Fallstricke beim Angeben von numerischen Bedingungen 127 Fallstricke und Variationen beim Anlegen alphanumerischer Kodierungen 130 falsch 39, 57, 59, 64, 125, 129, 208, 276, 292 Farben 26 Feedback 47, 52, 102, 262, 347 Fehlende Werte XIV, 4, 110 Fehlerart 52, 102, 262, 293 Fehlermeldung 16, 54, 124, 184, 260, 299 Fehlerquelle 208, 261 Fehlersuche 262 Fehlschlüsse verhindern 267 Feld 3, 320, 323 Fenster 21–25, 34, 51, 87, 262 Fernsehen V Fileref 311 Film 322, 323, 325–327, 331, 336 Filtern X, XVIII, 65, 68, 77, 109, 110, 121– 123, 199, 303, 304, 310 Filtern einzelner Zeilen 109, 110, 121 Filtern gruppierter Zeilen 121 Filtern mit Aggregierungsfunktion 122, 123 Filtern mit Subqueries XVIII, 199 Filterung XI, 159, 283, 284, 295 Finance V, 82, 90 Finanzfunktionen 43, 54 Flexibilität 38, 139, 143 Fluch der Karibik 318–320, 324, 325, 327 Fokus VI, VII, XII, XIII, XVIII, 265, 291, 304, 315 Fokuskapitel VII, XII, XIII, 291, 315 Foreign Key VIII, 1, 4 Format XII, XIII, 25, 26, 38, 61, 79, 80, 84, 99, 100, 109, 208, 209, 219, 256, 258–260, 291, 298, 299, 302–305, 309, 310, 312, 313 Formatierungsoptionen 304 formatw.d 61 Formmaße 267 Fortgeschrittene XIV, 2 four-way join XII, 219, 253 Fragestellung 267, 269 Fremdschlüssel VIII, 1, 4

Sachverzeichnis FROM-Klausel X, 34, 35, 44–46, 53, 78, 99, 103, 147, 150, 157, 179, 180, 182, 184, 185, 188, 199, 223, 229–231, 237, 239, 248, 250 Full XII, 31, 46, 58, 164, 179, 180, 185, 186, 191, 192, 206, 211, 214, 215, 219, 220, 224, 229, 230, 232, 236–238, 241, 247– 250, 252, 255, 294, 324, 333, 335, 349 Funktion VI–IX, XIII, XVII, 1, 2, 10–12, 33, 34, 38, 39, 41, 43, 47, 52–54, 58, 61, 64, 121, 143, 155, 162, 193, 214, 259, 262, 265, 274–276, 280, 282, 286, 291, 298– 301, 303, 307 Funktion MONOTONIC XIII, 291, 298, 303 Funktionalität 3, 26, 27, 29, 80, 90, 91 Funktionen und Komparatoren für StringVariablen 299 Funktionsaufrufe 38 Funktionsumfang 2, 38 Funktionsweise IX, X, XIII, 41, 73, 77, 78, 121, 122, 124, 263, 291, 292, 296 G Ganzzahlen 108 Gemischtes Sortieren 108 generation datasets 263 genestet 138, 199 (Geo)Daten V German First Level Support XV gesperrt 259 Gewicht XIII, 150–153, 160, 265, 288, 342 Gewichtswerte 289 Gewichtungen 287 Gewichtungsvariablen XIII, 265, 288 gleich 29, 39, 53, 64, 110, 142, 160, 168, 180, 185, 220, 221, 268, 269, 273, 274, 288, 289, 300 Gleich trunkierte Strings 64 Google V Grafiken XV, 266, 308, 309 grand total 117 GRANT-Statement 39 Groß- und Kleinschreibung 34, 39, 59, 130, 282

Sachverzeichnis größer als 5, 56, 64, 74, 114, 121, 124, 144, 215–217 Größer als trunkierte Strings 64 größergleich 29, 64, 82, 127, 196, 301 Größergleich als trunkierte Strings 64 Großschreibung 62 Grundgesamtheit 53, 266, 274, 287 Grundlegende Bedeutung VII, XIII, 1 Grundlegende SQL-Anwendungen XVII, 14 Grundoperationen VI–VIII, X, XVII, 9, 77, 103 Grundoperationen und Berechnungen X, XVII, 77, 103 Gruppenausprägung 119, 283, 289 gruppenweise 12, 13, 110, 121, 124, 263 Gruppenweises Filtern 121, 124 Gruppieren X, 77, 107, 119 Gruppieren/Sortieren von Tabellen X Gruppieren von Daten 119 Gültige Werte 39, 115, 142 H Harmonisches Mittel 271 Harry Potter 318–321, 325–329, 336 Hash-Join 295, 296 Häufigkeitstabelle XIII, 265 Haushaltsanschrift 161 HAVING-Bedingung X, 77, 119, 122, 139 Heiserkeit 206 Herkunftsbezeichnung 157, 178 Herr der Ringe 318, 319, 324, 325, 327 Hersteller V, VII, 1, 2 Hierarchie 130, 294 Hilfen VI–XIII, XVIII, 291 Hilfsmittel XII, 219, 258, 316, 328 Himmelskörper V Hinzufügen XIII, 5, 47, 52, 97, 98, 155, 291, 304–306 Hinzufügen von Leerzeilen oder Zählvariablen 305 Hinzufügen von Zeilen aus einer Tabelle zu sich selbst 155 Hinzufügen von Zeilen zu sich selbst 97 Historische Kopien 26

365 Hold-Zustand 311 HTML XIII, 291, 308, 310, 313 I IBM VII, 1, 2 Identifikation VIII, 1, 4 Identifikatoren 161 IDs XII, 4, 46, 153, 155, 162, 166, 170, 176, 180, 181, 183–187, 189–192, 197, 199, 212–214, 219, 221–227, 231–236, 239– 245, 247, 248, 253, 261 IFNULL-Funktion 39, 58, 214 IF-THEN-ELSE 32 Ihre Meinung VI, XIX, 347 Import XIII, 291 IN-Bedingung 53, 59 Index 47, 50, 81, 115, 162, 164, 261, 295, 296 Indexname 48 Industriestandard XIV, 1 Inferenzstatistik 265 Informat 61, 79, 100 informatw.d 61 Inhalt VIII, XVII, 1, 9–15, 27, 94, 160, 179, 181, 208, 210, 259, 261, 306, 307, 312, 315 In-Line View 37, 99, 103 IN-Liste 27 Inner Join IX, XI, 21, 41, 45, 46, 96, 159, 179, 180, 182–185, 194, 197, 212, 219, 220, 222–224, 231, 232, 239–241, 250, 251, 254 Inner Join1 45, 46, 179, 180, 182, 183, 220, 250, 251 Inner Join2 45, 46, 179, 180, 182–185, 212, 219, 220, 222–224, 231, 232, 239–241, 250, 251 Innere Query 138, 199 INPUT-Funktion 299 Installation 22, 23, 25, 88, 313, 337 Integritätsbeschränkungen 51, 90 Integrity Checks 27 Integrity Constraints VI, XIV, 26, 50, 51, 78 interaktiv 262 Interleaven 262 Interleaving XI, 159, 162, 164 internal rate of return 43

366 Interne Optimierer XIII, 291, 294, 296 Interpretation 115, 254, 266, 270, 272 Interpretierbarkeit 136 Interquartilsabstand XII, 265, 267, 271, 279 Interquartilsrange 271 intervall 267 Intervallskalierung 270 IQR 271, 278–280 IRR 43 IS-Bedingung 53, 59 ISO 2, 345 IT Consulting V J Join VI, X–XII, XIV, XVII, XVIII, 3, 21, 24, 37, 42, 45, 46, 58, 66, 69–71, 77, 78, 147, 155, 156, 159, 163, 164, 179–182, 185, 186, 189, 191, 193, 197, 199, 200, 205, 214, 219–227, 229–238, 240, 241, 243– 245, 247–251, 253, 255, 258, 261, 291, 294–296, 323, 324, 327, Join-Abfolge 220 Join-Algorithmus XIV, 296 Joinen VIII, XI, XII, XVIII, 4, 9, 21, 24, 36, 39, 159, 160, 179, 180, 205, 210, 212, 214, 215, 219, 221, 222, 261, 294 Joinen zweier Tabellen VIII, 9, 21, 24, 36 Join-Methoden XIII, 291, 294, 295 Join-Modi 21 Join-Operator XII, 179–181, 221 Join-Typ 24, 250 K Kanal V kartesisch 194 Kartesisches Produkt 194 Kataloge 88 kategorial 107, 130 Kategorisierung 131 Keine Rückmeldung 102 Kennzahlen V Kennziffern 265 Key XI, 4, 24, 150, 153, 155, 159, 162, 163, 212, 213, 220–222, 239, 255, 259, 260

Sachverzeichnis Key-Variable XI, 24, 150, 155, 159, 162, 163, 213, 220–222, 239, 255, 259 Kino 316, 322 Kinofilme VII Klammer 5, 6, 17, 59, 63, 93, 111, 138, 141– 143, 251, 252, 293, 310 Klammerpaar 43 Klauseln IX, X, 34, 41, 49, 52, 53, 77, 99, 103, 104, 108, 114, 144, 157, 215 kleiner als 11–13, 39, 56, 64, 74, 113, 145, 202, 216 Kleiner als trunkierte Strings 64 kleinergleich 29, 64, 110, 126, 127 Kleinergleich als trunkierte Strings 64 Kleinschreibung 60 Kodierung 99, 130, 131, 259 Kombination von WHERE und HAVING 114 Komma 16, 45, 99, 120, 179, 182, 183, 270, 299, 305 Komparatoren XIII, 43, 110, 113, 126, 291, 298, 299, 301 Komplexität X, XII, 77, 78, 219, 259 komprimiert 27 Konditionale Operatoren X, 77, 138, 139, 141, 143 Konditionale Operatoren (HAVING) 143 Konditionale Operatoren (WHERE) 141 Konfidenzintervalle 266 Konflikte mit CREATE TABLE 85 Konkatenieren 43, 152, 153, 160, 164, 210 Konkatenierung 160, 163, 165, 168 Konkatieren 262 Konstante 43, 59, 118, 127, 135 Konsumentenverhalten V Kontobewegungen V Kontrolliertes Zusammenfügen XI, 159 Konvertieren XIII, XVIII, 291, 298 Konzentration 269 Konzept VIII, 1, 250, 266 Kopie X, 15, 17, 26, 45, 78, 80, 83, 85, 104, 105, 147, 155, 199, 263, 264 Kopieren 105 Korrektheit 47, 52, 102, 258, 262, 293 Korrekturen 136, 137 Korrelierte Subqueries X, 77, 204, 205

Sachverzeichnis Korrigierte Quadratsumme 53, 274 Krankenhaus 207 Kreissymbole 163 Kunst 315 Kurzbeschreibung IX, 41, 42, 44, 45, 53,56–62 L Label 15, 23, 61, 82, 84, 105, 155, 259, 302 Lag- und Differentialfunktionen 43 Lagemaße XII, XVIII, 265, 267–269, 271 Länder 69, 200 Länge 34, 61, 82, 180, 186, 213, 221, 239, 260, 299, 301, 302, 325 Laufwerk 25, 309, 310 Left IX, 41, 46, 179, 180, 185, 186, 205, 224– 226, 232, 233, 241–243, 250 LENGTH-Statement 61, 260 Lesen von Daten in Teradata 80 Lesezeichen 309, 311 Libname-Klausel 48 LIBNAME-Statement 16, 84, 256, 257 Libraries 5 Liebeskummer 206 LIKE-Bedingung 53, 59, 60 Liste 44, 45, 49, 57, 64, 68, 88, 90, 147, 182, 214 Literal 43 Literatur VI, VII, XIII, XIX, 345 Logik IX, 5, 21, 29, 39, 63, 101, 134, 135, 175, 261, 316 Logistics V Lokation 267 Löschen 3, 47, 51, 52, 78, 82, 86, 87, 91, 98 Löschen aller Zeilen 87 Löschen einer View 91 Löschen eines Datensatzes 91 Löschen von Variablen/Spalten 78 Löschen von Zeilen 86 Lösung VII, XIII, XIX, 3, 312, 315, 316, 328 Lotus 1-2-3 XII, 219, 256 LOWER-Funktion 53, 60 M Makrofähigkeit VIII, 1 Makroprogrammierung VI, XIV, 4, 39, 43, 54, 109

367 Makroprozessor 34 Makrovariable 44, 143, 144, 277, 279 Makrovariablendefinition 49 Management V, 303 Managementpositionen 287 Manipulation 2, 3 Many-to-Many XI, XII, XIV, XVIII, 159, 162, 165, 212, 219–222, 238, 240–250, 254, 261 Many-to-One XI, XII, XIV, XVIII, 159, 162, 165, 219–222, 230–233, 237, 238, 250, 254, 261 Markt- und Wirtschaftsinformationen 135 Maßzahlen 266 Matchen X, 78, 150, 152 Matchen für Fall-Kontroll-Analysen 150, 152 Match-Mergen 164, 261 mathematisch 43, 54, 105, 116 Mathematische Funktionen 43 Mathematische Operatoren 43 mausgesteuert X, 9, 20 Mausklick VIII, XVII, 9, 20, 23, 259 MaxDB 2 Median XII, 53, 265, 267, 269, 270, 274, 276, 277, 279 Mediennutzung V Mehrere Bedingungen 114 Meinung VII, XIII Member 88, 89 Menüleiste 21, 23–25 Menüpfad 22 Merge-Join 295, 296 Mergen XI, XII, 159–161, 164, 219–221, 260–262 Merging XI, 159, 162, 212 Messwiederholungen 162 Microsoft Access 2002 310, 312 Microsoft Excel XII, XIII, XVIII, 219, 256, 291, 310–312 Microsoft Excel 2002 312 missing values 4 Missings VIII, IX, XI, XII, XIV, 1, 2, 4, 9, 31, 39, 41, 45, 46, 58, 59, 68, 70, 73, 74, 78, 92, 100, 101, 103–105, 107, 110, 111, 113, 115–117, 132, 133, 135, 138, 142,

368

Sachverzeichnis

159, 162, 164, 180, 189, 190, 192, 210, 212–214, 217, 219–227, 229–235, 237, 239–245, 247, 248, 250, 253, 258, 259, 261, 273, 275, 276, 280–282, 320, 323 Mittelster Wert 269 Mittelwert XII, 53, 66, 117, 145, 201, 265– 276, 288 Mitternachtsstatistik 207 mnemonisch IX, 63, 54 Mobile Endgeräte V Modalwert 269, 278 Modelle 3 Modellierung 2 Modellierungssprachen 3 Modifikatoren 38 MODIFY-Statement 162, 261, 263 Modus XII, 222, 259, 265, 267, 269, 273, 274, 277–279 Multikonditionales Aktualisieren von Werten 135 multimodal 267, 270, 273, 277, 278 Multimodale Verteilung 277 Multiple (temporäre) Queries X, 77, 139 multiple responses 162 Multiplikation 18, 100, 102, 132, 134, 138, 273, 298, 299 Multiplizieren mit dem Wert 1 298 multi-way join 250, 252 Muster 59 Musterzeichen 60 MVS 36 MySQL VII, 1, 2

Nebeneinanderstellen XI, XVIII, 31, 159, 161–164, 179, 210, 211, 294 negativ 51, 84, 175, 177, 208, 272, 289 „negative“ Schnittmenge 175 net present value 43 Neuanlegen X, 77, 105, 107 Neuanlegen von kategorial skalierten Variablen/Spalten X, 77, 107 Neuanlegen von metrisch skalierten Variablen/Spalten 105 Neuanlegen von Variablen/Spalten über Kopieren 105 Nicht korrigierte Quadratsumme 53, 274 Nicht One-to-One XII, 219, 250, 253, 254 Nicht SAS Tabellen XII, 219, 250, 256–259 Nichtgleich trunkierte Strings 64 nichtnegativ 289 Nicht-NULL Zahlen 39 Nicht SAS Tabellen XII, 219, 250, 265–259 Nicht-Schnittmenge 172, 176 Nichtübereinstimmung 180, 241 Nichtzutreffen 57 Niederlassung 70, 118, 283–287, 304, 306– 308 Nomenklatur VIII, 1 nominal 267 Nonaggregierte Werte 284 NPV 43 NULL 4, 39, 59, 92, 115 NULL-Wert XIV, 39 numerisch 43, 56, 61, 91, 99, 109, 118, 130, 208, 260, 283, 284, 291, 298, 299

N N XIII, 30, 53, 65, 67, 73, 75, 99, 116, 139– 141, 143, 144, 183, 193, 194, 196, 197, 265, 266, 274–276, 280, 281, 285, 320– 322, 325, 326, 328–330, 334, 336 Name 7, 15, 23, 42, 49, 50, 56, 58, 69, 75, 88, 91, 92, 94, 96, 114, 129, 147–150, 154, 155, 216, 259, 274, 292, 293, 300–303, 310, 319, 325–327, 336, 338, 342 Namensreservierung 85 Natural Join IX, 41, 46, 58, 197, 324

O Object Linking and Embedding 311 Objekt-Item 44, 49 objektorientiert 3 objektrelational 3 Obsthändler 160 ODS XIII, XIV, XVIII, 3, 26, 291, 308–310 ODS Style 309 OLE 311 One-to-Many XI, XII, XIV, XVIII, 159, 162, 165, 219–230, 234–237, 250, 251, 254, 255, 261

Sachverzeichnis One-to-One VI, XI, XII, 159, 161, 162, 164, 165, 180, 212, 219, 220, 250, 254, 261 One-to-One Mergen mit BY 164 One-to-One Mergen ohne BY 164 Open Source V Operand 42, 43, 59, 124–127, 129 Operatoren IX, XI, XVIII, 18, 38, 41–45, 59, 63, 64, 70, 115, 141, 143, 156, 159, 162, 163, 165, 166, 168, 179, 181, 221, 238, 292, 293 Optimieren XIV, 296, 316 Optimieren von Joins XVIII, 294 Optionen VII, VIII, XIII, 5, 9, 20, 26, 29, 31, 32, 47, 52, 60, 86, 98, 165, 169, 262, 263, 291, 294, 296, 304, 308, 310, 311 Oracle V, VII, 1, 2, 40, 50, 51, 80, 90, 92, 259 Oracle-spezifisch 92 ordinal 267 Ordinalniveau 267, 271 Ordner 22 Outer Full Join 229, 230, 236–238, 247–249, 252, 255 Outer Join IX, XI, XII, 21, 37, 41, 46, 159, 179, 180, 185, 219, 220, 224, 232, 241, 250, 251 Outer Left Join 225, 226, 232, 233, 242, 243 Outer Right Join 226–228, 234–236, 244– 246, 251, 252, 254 Output Delivery System XIII, XIV, XVIII, 3, 291, 308 P Parameter VI, IX, 3, 63, 65, 132, 266, 267, 269, 274, 277, 308 Passnummer 161 Pass-Through Facility 81, 90, 256, 257 Passwort 91, 92 Patient 207 PDF XIII, 291, 308, 309 PDV 115, 262 performant X, 36, 77, 146 Performante WHERE-Klauseln X, 77, 114, 297 Performanz V, VIII, XIII, XIV, XVII, 2, 9, 27, 36, 37, 50, 114, 162, 175, 257, 291, 294, 297

369 periodic savings 43 Perl 262, 300 permanent 16, 97 Petabyte V Pfad 16, 81, 84, 90, 92, 310, 311 Pfeil 22, 23 Planen 258 Plattformen 68 Platzhalter 60, 108, 109, 113 Pop-Up Menü 22–25 Position 4, 61, 108, 140, 163, 166, 300, 302 Positionshinweis 107 positiv 207, 271–273 PostgreSQL 2 Postleitzahlen 43, 54 PostScript XIII, 291, 308 Potenz 43 Präfix 42, 300 Praxis-Beispiele VII Präzision 61 Primärschlüssel XII, 4, 82, 220 Primary Key VIII, 1, 4, 90, 220 Priorität 43 Probabilistische Funktionen 43, 54 PROC ACCESS 256, 257 PROC APPEND 163, 264 PROC COMPARE 260 PROC CONTENTS 259 PROC DATASETS 27, 163, 259, 260 PROC EXPORT 312 PROC FREQ XIII, 36, 265 PROC IMPORT 256, 257, 310 PROC MEANS 36, 277, 288, 289 PROC PRINT 5, 7, 16, 98, 209, 259, 261, 306, 308 PROC REPORT 5, 26, 259, 308 PROC SORT 31, 32, 37, 107, 164, 261 PROC SQL passim PROC SQL Optionen 29, 52, 98 PROC SUMMARY 30 PROC UNIVARIATE 277–280 Produkt 19, 46, 134, 135, 183, 193, 194, 264 Produktperformanz V Prognosen V Program Data Vector 115, 262

370 Programm V, VII, 1, 2, 4, 7, 10–12, 14, 21, 69, 74, 75, 131, 132, 149, 205, 214, 215, 217, 222, 253, 255, 258, 261, 286, 289, 308, 315, 316 Programmieraufwand 109 Programmierbeispiele IX, XVII, 27, 34, 41, 250 Programmieren V, XI, 29, 34, 37, 127, 136, 214, 253, 255, 262 Programmierer V, VIII, XVII, 9, 14, 27, 36 Programmierfehler 261 Programmierkapitel VII Programmierkonvention VIII, 1, 6, 7, 29 Programmierlogik 216, 277 Programmiersprache V, VI, 1–3, 34 Programmierung VI–IX, XIV, 1, 3, 5, 9, 14, 20, 21, 27, 33–35, 37, 47, 51, 63, 80, 81, 84, 114, 122, 125, 126, 133, 253, 257, 258, 300, 309, 315, 316 Prompt-Modus 26 Protokoll 26, 259 Protokollieren 263 Prozedur IX, 10–12, 30, 34, 41, 47, 52, 98, 256, 257, 263, 279, 312 Prozeduren für das Zusammenfügen von Tabellen XII, 162, 219, 262 Prozent- und Quotientwerte XIII, XVIII, 265, 283 Prozentwert 128, 283–285 Prozentwertberechnungen X, 77, 118, 146 Prozesshierarchie 294 Prüfregeln XII, XIV, 26, 47, 48, 50, 51, 81, 82, 87, 89, 91, 92, 219, 258, 261, 316, 328 Prüfschritte XI, XII, XVIII, 159, 165, 219, 258, 316, 328 Prüfschritte und Hilfsmittel XVIII, 258 PRX-Funktionen 300 PUT-Statement 262, 299 Q Q1 271, 278, 280 Q3 271, 278, 280 Quartil 267, 271, 278 Quasi-Standard V

Sachverzeichnis Query VI–XI, XIII, XVII, 5–9, 15, 20–23, 26, 34, 39, 41–52, 56, 58, 59, 61, 65, 66, 70– 75, 77, 83, 84, 99, 102, 103, 132, 138, 139, 141, 142, 144–146, 159, 165, 174, 197, 199–205, 210, 217, 262, 286, 291–293, 302, 307 Query-Ausdruck IX, 41 QUIT-Statement 34 Quotient 84, 287 Quotientwerte XVIII, 283 R Radio V Range XII, 106, 213, 221, 239, 265, 267, 271, 272, 279 Rangplatz XIII, 315 RDBMS VIII, 1, 3, 4 read-only 5, 26 Rechnen mit Gewichtungen XVIII, 287 Rechnungsnummer 210 record 3 redundant 315 Referenzen VIII, 9, 20, 97 Reflexive Join IX, X, XVIII, 41, 45, 66, 69, 78, 147, 199, 307 Regelbezeichnung 48 Regisseur XIII, 315, 318, 319, 321, 322, 324– 326, 329, 332, 333 Registrierung V Regressionsanalyse XV, 346 Reihenfolge IX, X, 39, 41, 43, 47, 52, 58, 77, 93, 95, 99, 103, 127, 129, 136, 184, 301 Rekursive Referenz 20 relational V, 1, 256 Relationale Algebra 3 Relationale Datenbanken 2 Remergen 37 Remerging IX, 41, 54, 55 Reparieren 27 repetitiv 28 Reports V repräsentativ 261, 269, 288 reserviert 7, 34, 37, 38, 164 RESET-Statement 52, 98, 99 Richter-Skala 270

Sachverzeichnis Richtige Reihenfolge der Klauseln 99 Richtung IX, XII, 6, 37, 45, 63, 107, 138, 180, 200, 219, 220, 267, 269, 298, 299 Richtung des/der Joins XII, 180, 220 Right IX, XII, 41, 46, 179, 180, 185, 186, 189–191, 219, 220, 224, 226–228, 232, 234–236, 241, 244–246, 250, 251, 254 Rohdaten V, 207 Rollback 40, 97 ROLLBACK-Statement 40 Routinen 38, 43, 54, 300 Rückmeldung VII, XIII, 64, 86, 87, 97, 102, 103, 107, 122, 293–296 Rückmeldung bei fehlerhafter bzw. unvollständiger SQL Syntax 102 RUN-Statement 34 S Sachverzeichnis VI, XIX SAS passim SAS Ausgabe IX, 41, 131, 307, 309 SAS Base VIII, XVII, 1–4, 9, 14, 27–32, 34– 37, 262, 298, 299, 310 SAS Base Language 27 SAS Base Syntax 2, 34, 262 SAS Base vs. PROC SQL XVII, 27 SAS Befehlsfenster 21 SAS Befehlssyntax 21 SAS Data Set Option 26 SAS Datasets VII, XIII, XIX, 27, 337, 341 SAS Datei IX, 3–5, 31, 36, 43, 63, 84, 86, 162, 262–264, 273, 277, 303, 310, 312, 337 SAS Datei I/O 43, 162 SAS Datensatz IX, 63, 135, 155 SAS Explorer 259 SAS Fenster 21 SAS Format 22, 61, 256, 257, 259, 312 SAS Funktionen XIV, 5, 18, 34, 38, 43, 54, 115, 300 SAS Funktionen und Funktionsaufrufe XIV, 5 SAS Funktionen und Routinen 38 SAS Informat 61 SAS Institute XIX, 337, 345 SAS Log 7, 8, 23, 51, 52, 54, 87–89, 102, 103, 262, 292–296

371 SAS Macro Facility 3 SAS Makros XIV, 4, 5, 39, 108 SAS Makrosprache 4, 39 SAS Output X, 5, 6, 25, 34, 77, 78, 84, 88, 309 SAS Pass-through Facility XIV, 81, 90, 256, 257 SAS Sample Library 256 SAS Statements XII, 162, 219, 262 SAS System XIII, XV, 5, 36, 87, 89, 123, 262, 291, 294, 311, 346 SAS System Optionen 262 SAS Systemdatei 89 SAS Systeminformationen 87 SAS Tabelle VI, VIII, XII, XIII, 3, 5, 7, 9, 13, 14, 19, 20, 22–24, 26, 27, 36, 65, 70, 82, 83, 87, 163, 165, 200, 219, 220, 250, 253, 255, 257–264, 291, 308, 309, 312, 316 SAS Views 5, 26, 27, 89 SAS/ACCESS 48–52, 80, 86, 90, 91, 312 SAS/ACCESS Interface 52, 91, 312 SAS/ACCESS Interface to PC Files 312 SAS/ACCESS Software 50, 51, 80, 90, 91 SAS/ASSIST 22 SASHELP 6, 22, 24, 29, 54, 55, 57, 65–69, 72–75, 86, 88, 89, 94, 103–105, 107–114, 116–123, 125, 126, 129, 132–136, 138– 145, 147, 149–151, 156, 157, 178, 179, 199–205, 210, 217, 273–280, 283–287, 292, 293, 300–305, 307–310, 337–341 SASHELP.BUY 68, 114, 337 SASHELP.CLASS 29, 69, 75, 86, 88, 94, 114, 129, 147, 149–151, 273–275, 277– 280, 292, 293, 300–303, 308–310, 338 SASHELP.PRDSAL2 72, 178, 179, 201–203, 205, 338 SASHELP.PRDSAL3 72–74, 178, 179, 200– 204, 339 SASHELP.PRDSALE 57, 65–69, 73, 125, 126, 132–136, 138, 156, 157, 200–204, 217, 339 SASHELP.SHOES 6, 54, 55, 69, 73, 103– 105, 107–113, 118–123, 126, 139–145, 202, 205, 210, 217, 283–287, 304, 305, 307, 340

372 SASHELP.SYR1001 116, 276, 340 SASHELP.YR1001 117, 341 SAVING 43 schief 270 Schlüssel VIII, 1, 3, 4, 37, 71, 153, 179, 181, 212, 315, 316 Schlüsselvariable 184, 186, 189–192, 213– 215, 223–238, 240–249 Schlüsselwörter XI, 34, 37–39, 44, 45, 180, 182, 183, 223, 278, 280 Schnellfinder VI, IX, 41, 47 Schnittmenge 45, 163, 165, 167, 171, 173– 175, 177, 195, 196 Schreibweise 60, 62, 144, 217, 259, 301 Schuhfirma 103, 200 Screening 262 SDSS V Security 39 Selbstgeschriebene SQL Queries XIII, 291 SELECT-Anweisung 5 SELECT-Statement IX, X, XVII, 15, 34, 35, 41, 44, 52, 53, 63, 69, 77, 83, 84, 86, 89, 92, 98, 99, 103, 105, 112, 121, 140, 149, 150, 156, 157, 178, 180, 188, 194, 195, 198, 253, 295, 302, 306 Selegieren X, 30, 77, 103 Selegieren von Spalten aus einer Tabelle 103 Self-Join X, XVIII, 78, 147, 199, 307, 316 Semikolon 45, 58, 63, 138 semistrukturiert 4 Sender V Sendungen V SEQUEL 1, 3 sequentiell XI, 159, 162–164, 263 Server 258, 259, 311 Set Operatoren XI, XVIII, 38, 159, 165 Sicherheit 2, 26, 27, 156 Sicherheitsgründe 27, 31, 311 Signifikanztest 43, 266 Simulation 287 Skalenniveau 267, 269 Sloan Digital Sky Server V Sofort ausführen 23 Sofortige Ausführung 25 Software V, VII, XV, 1, 2, 40, 313

Sachverzeichnis Sortieren X, 4, 30, 34, 36, 37, 77, 107–109, 257, 261, 295, 321 Sortieren mit Platzhalter X, 77, 109 Sortieren über mehrere Platzhalter 109 Sortierreihenfolge 39 Sortierrichtung 108, 213, 221, 239 Sortiersequenz 39 Sortierung 31, 107, 108, 131, 140, 161, 164, 180, 186, 192, 210–212, 214, 239, 255, 278 Sortiervariable 48, 49 Spalten passim Spalten für Join-Kriterien 24 Spalten für SQL Abfrage 21, 24 Spaltenattribute 50, 78, 81 Spalten-Definition 42, 48, 53, 60, 61 Spalten-Fenster 21–24 Spalten-Modifikator 38, 53, 60, 61 Spaltenspezifikation 48 spaltenweise 11, 275, 277, 279 Spaltenweise Aggregierungsfunktion 11 Spaltenzahl 38 Spannweite XII, 265, 267, 271 Speichermedium 26 Speichern unter 25 Speicherort 25, 259 Speicherplatz VIII, 1, 5, 7, 26, 27, 61, 262 Spreadsheets 310, 312 SQL passim SQL Abfrage VIII, 9–13, 20, 21, 23–25, 103, 293 SQL Ausdruck IX, 41–46, 48, 49, 53, 54, 56– 62, 102, 103, 180, 182, 183, 185, 223–227, 229–235, 237, 240–242, 244, 245, 247, 248, 280 SQL Programmieren 131, 315 SQL Prozesse XIII, 291, 294 SQL Query Window VIII, XVII, 2, 9, 20–22 SQL Syntax VI–VIII, X, XIII, XIV, XVII, 5, 6, 9–12, 14, 21, 23–25, 34, 41, 42, 47, 53, 58, 77, 78, 102, 115, 136, 165, 294, 296 Standard V, VII, VIII, XIV, XVII, 1, 2, 4, 9, 34, 37, 38, 45, 59, 139, 258 Standardabweichung XII, 53, 265–267, 271– 274, 279 Standardfehler des Mittelwertes 53

Sachverzeichnis Start 61 statisch 26 Statistiken VI, 3, 54, 266, 267, 269, 273, 295 Statistische Beschreibung 266, 280 Statistische Grundlagen XVIII, 267 stetig 267 Stichprobe XII, 265, 266, 269, 270, 273, 287 Stichprobenstatistik 43 Streubereich 271 Streuung 268, 270–273 Streuungsmaße XII, XVIII, 265, 267, 268, 271, 273 String X, XVIII, 28, 33, 39, 43, 56, 58–61, 64, 77, 79, 91, 99, 101, 105, 109, 112, 113, 120, 125, 126, 129, 130, 132–135, 153, 157, 178, 179, 217, 259, 280–282, 291, 298–302, 307 String enthält 64 String klingt wie 64 String-Funktionen XVIII, 298 String-Keys 259 String-Variablen 60, 112, 113, 125, 126, 129, 299 Structured English Query Language 3 Structured Query Language V, VII, XIV, XVII, 1 Struktur VIII, XI, XVII, 3, 9, 27, 42, 47, 63, 69, 87, 131, 132, 147–149, 153, 154, 159, 163, 220, 222, 225–227, 230, 233–236, 242–245, 259, 261, 262, 312, 315, 316 Strukturierung 160–162, 210, 265 Strukturmerkmale der Daten 265 Student's t-Wert 53, 274 Styles XIII, 291, 308, 309 Subqueries IX–XI, XVII, 5, 10, 13, 37, 45, 63, 65, 70, 72, 73, 77, 78, 138, 141, 143, 144, 146, 159, 178, 180, 199–201, 203, 217 (Sub)Query VII, IX, X, XIII, 6, 45, 63, 70, 73, 74, 77, 138, 139, 199–201, 203, 204, 217 Subqueries und Effizienz 146 Subquery für zwei Tabellen 200–203, 217 Subquery in Kombination mit ANY, WHERE und IN 145

373 Subquery in Kombination mit AVG, WHERE, und IN 145 Subquery in Kombination mit WHERE und IN 144 subsetting IF 29, 115 Substring 61 SUBSTRING-Funktion 53, 61 Suchen-und-Ersetzen 300 summary functions 53, 115 Summe aller Summen 117 Summe der Werte der WEIGHT-Variable 53, 274 Summenbildung 11, 12, 71, 131, 143 Summenwert 12, 13, 67, 140, 141 Summierungsfunktion 23, 24, 53, 122 Symbol IX, 43, 63, 64, 198 symmetrisch 267 Syntax VI, VII, IX, X, XIII, XIV, 3, 6–8, 13, 14, 21, 23, 25, 34, 36, 41, 42, 44, 45, 47, 52, 53, 56–62, 77, 78, 102, 127, 128, 136, 148, 149, 155, 178, 206, 251, 262, 292– 294, 296, 299, 300, 308, 315, 323 Syntaxelement IX, 41, 47, 53 Syntaxkapitel VII, VIII, 41 Syntax-Theorie VII Syntaxverzeichnis VI, XIX System R 1 Systemdatei 89 systemdefiniert 39, 104, 222 Szenario VI, XII, 135, 212, 219, 222, 250, 251 T Tabell.Quellen 22 Tabelle V–XIV, XVII–XIX, 1, 3–9, 15–17, 19–22, 24, 26, 27, 32, 34, 36–42, 44–47, 50–52, 54, 57, 58, 61, 63, 65, 66, 68–75, 77–82, 85–89, 91–101, 104–121, 124, 126, 127, 131–135, 138–150, 152–157, 159– 210, 212–215, 217, 219–264, 266, 283– 285, 293–295, 297, 303, 306–312, 315, 316, 319–324, 326–328, 332 Tabellenaliase 34, 38, 42, 46 Tabellen-Ausdruck IX, 41, 42, 44 Tabellenbeziehungen 160

374 Tabellen-Fenster 22, 23 Tabellen-Join IX, 42, 45, 78 Tabellenkalkulationsprogramm 310 Tabellenname 15, 25, 42, 45, 46, 48–51, 63, 81, 83, 86, 87, 89 Tabellenquellen 22 Tabellentypen XII, 219 Tanzkurs 129, 147, 150, 153, 193 Tasks 22 Telefoniedaten V Telefonnummern 161 Telekommunikation V temporär 10–16, 27, 73, 75, 80, 82–87, 94, 95, 97, 98, 101, 104, 105, 108–110, 112, 113, 132–135, 138, 139, 156, 157, 252, 261, 312 Teradata VI, VII, 1, 2, 40, 50, 51, 80, 81, 90, 91, 259 Teradata-spezifisch 91 Terminologie VIII, 1, 3, 4, 131, 311 Test auf Gleichheit 125 Text(zeichen) XIII, 5, 291, 304, 306 The Dark Knight 318, 319, 325–327 three-way join XII, 219, 250–252 Tipps VI, VII, XIII, XVIII, 258, 291, 298 Titanic 318, 319, 322, 324–328, 334 Titel XIII, 315, 318–320, 322, 324–328, 332, 333, 335, 336 Transformationen 31, 253, 272, 303 transkodiert 61 Transponieren 65, 68, 69, 131, 132 Transport V Trends 136 Trennzeichen 35, 304 Tricks VI, VII, XIII, XVIII, 291, 298 Trunkierung 43, 54 Tücken XIII, 291, 298 Tupel 3, 4 two-way join 250 TXT 313 Typ XII, 15, 24, 28, 39, 46, 60, 61, 82, 88, 90, 129, 161, 180, 181, 184, 185, 212, 213, 219–221, 223–249, 251, 253, 254, 260, 273, 277, 298 Typ der Tabellen 220

Sachverzeichnis U Übereinstimmung 204, 205 Übergeben ausgewählter Zeilen an andere SAS Tabellen 94 Überlappung 165, 173 Übernahme aller Tabellen/Spalten 83 Übernahme von Dateiattributen aus anderen Dateien 82 Übernehmen von ausgewählten Zeilen 74 Überprüfen 47, 102, 261 Überschneidung 168 Überschreiben 20, 97 Übungsaufgaben VI, VII, XIII, 315 Übungsteil XIX, 315 Umbenennen von Variablen 17, 83, 260 Umbenennen von Variablen/Spalten 83 Umbenennung 253 Umgebung 47, 269 Umgehen mit doppelten Datenzeilen 168, 181 UML 3 Umstellen der Variablenabfolge 17 Umwandeln von gruppenweisen Zeilen in Spalten 131 Unabhängigkeit V, VII, 1, 2 Unerwünschte Ergebnisse 108, 109, 210, 211, 215, 222, 255, 277, 303, 304 ungleich 64, 125, 170 Union IX, 41, 42, 46, 70, 71, 177 Union Join IX, 41, 42, 46 unique 4, 153, 171, 173, 176, 212, 280, 281, 295, 335 Unterabfrage IX, 5, 6, 10, 13, 45, 63, 138, 199 Unterbedingungen 136 Unterdrücken der Zeilennummer 98 Untereinanderhängen XI, XVIII, 31, 159, 161–165, 168–170, 210 Unterfenster 22 Unternehmen V, 37, 135, 349 Unterschiede zwischen SAS Tabellen und SAS Views VIII, XVII, 9, 26 Unterteilen einer Datei 29, 30 Unverständliche SQL Queries XIII, 291 UPDATE/CASE-Beispiele X, 77, 125, 132, 134, 135

Sachverzeichnis UPDATE-Processing 50–52, 81, 86, 91, 92, 100 Updaten 124, 262 UPPER-Funktion 53, 62 Ursachen häufig auftretender Probleme 260 UserID 38, 43 V Variabilität 272, 273, 301 Variabilitätskoeffizient 273 Variable passim Variablennamen 17, 93, 107, 168, 180 Varianz XII, 53, 265, 267, 271, 272, 274, 279 Variationsbreite 271 Variationskoeffizient XIII, 53, 265, 267, 271, 273, 274, 279 Venn-Diagramm 163 Verarbeitung 16, 29, 98, 115, 122, 123, 156, 315 Verarbeitungslogik 277 Verarbeitungsort 115, 257–259 Verarbeitungsort und -weise von Missings 115 Verarbeitungszeiten 114, 297 Verbinden mit Teradata 80 Verbinden und Lesen von Daten in Oracle 80 Verbindung 47, 49–51, 80, 81, 90, 92 Verbindungsparameter 49, 50 Verbleib in Studie 206 Verdeutlichung 265 Vereinfachung 265 Vererben 302 Verflechten 164 Verfügbare Spalten 23 Verfügbare Tabellen 22 Vergeben von Prüfregeln 82 Vergleich von Strings IX, 63, 64 Vergleich von Werten IX, 63 Vergleichen 65, 175, 261, 300 Vergleichsoperatoren 4 Verhältnis zwischen Lagemaßen und Streuungsmaßen 268 Verkaufsprognosen 135 Verkaufszahlen 137, 200 Verkettung 221

375 Verknüpfen XVIII, 159, 165 Vermeiden des NOT-Operator 115 Vermeiden rekursiver Referenzen 20, 87, 97 Vermeiden rekursiver Referenzen bei INSERT 97 Vermeiden von arithmetischen Ausdrücken in einem Prädikat 115 Vermeiden von LIKE-Prädikaten 115 verschachtelt IX, 63, 135, 200 verschlüsselt 26 Versicherte V Versicherungen V Verstehen und Testen VII, XIII, XVIII, 291 verteilt V Verteilung 267–273, 277, 287 Verteilungstyp 269 Verwaltung 1, 4, 207 Verwenden des BETWEEN-Prädikats 115 Verwenden eines LIBNAME 86 Verzeichnis VII, XIII, 22, 88, 89, 160, 161 View VI, VIII, IX, 1, 3, 5–8, 15, 22, 26, 27, 39, 42, 43, 45, 47–52, 57, 58, 61, 63, 65, 78, 82, 84–92, 95, 99, 100, 105, 124, 165, 180, 186, 189–191, 225, 228, 229, 232, 233, 235, 236, 242, 246–248, 256, 257, 298, 307 Visualisierungen 266 Vollerhebung XII, 265 Vollständige Kombination 193 Volumen 315 Von Hand 93, 205, 302, 303, 311 Vorarbeiten 254 Voraussetzungen 5, 222, 269 Vorzeichen 43, 151 W wahr 4, 39, 46, 57, 59, 60, 124–129, 141, 142, 180, 185, 223–227, 229–235, 237, 240– 242, 244, 245, 247, 248 Wahre Verteilung 270 Wahrscheinlichkeit eines größeren absoluten Student's t-Wertes 53, 274 Währungsumrechnung 43, 54 Warnung 223–238, 240–249 „was wäre, wenn“-Simulation 287

376 Websuche V Web-Transaktionen V Wechselkurse 136 Weltschmerz 206 Wenn-Bedingung 57 wenn-dann VIII, 9, 32 Wenn-dann-Bedingung VIII, 9, 32 Wert passim Wertekombinationen 105, 214 Werteliste 72, 202, 203 WHEN vs. WHERE 132 WHEN-THEN-ELSE Bedingung X, 77 WHERE-Ausdruck 115, 139, 252 WHERE-Bedingung 69, 120, 125, 133, 146, 149, 150, 155, 197, 208, 256, 257 WHERE-Klausel X, 34, 53, 77, 114, 216, 297 Wiederherstellen 27 Wiederzusammenführung IX, 41, 54 Wildcard 33 Windows 21, 22, 36 Windows NT 36 Wirklichkeit 86, 270, 288 X XRM 1 Y Yahoo V Z z1s1 311, 312 Zählen von Werten X, 77, 115, 116 Zählen von Werten bzw. Zeilen X, 77, 116 Zeichen 34, 39, 56, 58–60, 67, 183, 185, 205, 307, 308 Zeichenkette 42, 43, 54, 56, 60–62, 300 Zeichenlänge 39 Zeichen-Operanden 58 Zeichensatz 39

Sachverzeichnis Zeile passim Zeilenabstand 99, 306 Zeilennummer 16, 98 zeilenweise X, XII, 31, 77, 165, 220 Zeilenweises Filtern 122, 123 Zeilenweises reflexives Zusammenfügen 147 Zeit- und Datumsfunktionen 43, 54 Zeit- und Datumsvariablen 39, 280–282 zeitlich/kausal 295 Zeitreihendaten 270 Zentrale Position 269 Zentrale Tendenz 269, 270 Zentralwert 269 Zentrum einer Verteilung XII, 265, 268, 269, 271 Zielverhältnis 287 z-Transformation 272 Zu klärende Aspekte 258, 259 Zufallszahlenfunktion 43, 54 Zufriedenheit 287 Zugriff V, XVIII, 5–8, 80, 81, 84, 97, 162, 256, 259, 264, 310 Zugriff auf SAS Dateien über ihren physikalischen Speicherort 84 Zugriffsmethode 160, 257, 263, 264 Zulassen rekursiver Referenzen 97 Zurücksetzen 40, 47 Zurücksetzen aller Änderungen 40 Zusammenfassen von Zeilen 115 Zusammenfügen XI, XII, 31, 36, 153, 159– 163, 165, 169, 187, 188, 191, 210, 212, 215, 219, 220, 222, 230, 249, 251, 253, 255, 257–262, 315 Zuverlässigkeit 267 Zuweisen von (numerischen) Formaten 305 Zuweisen von Formaten 33 Zuweisen von Labels für Variablennamen/Spalten 304 Zuweisungs-Statement 64