Eine Einführung in Abfragen in PostgreSQL

Einführung

Datenbanken sind eine Schlüsselkomponente vieler Websites und Anwendungen und bilden den Kern der Speicherung und des Austauschs von Daten über das Internet. Einer der wichtigsten Aspekte der Datenbankverwaltung ist das Abrufen von Daten aus einer Datenbank, sei es auf Ad-hoc-Basis oder als Teil eines Prozesses, der in eine Anwendung codiert wurde. Es gibt verschiedene Möglichkeiten, Informationen aus einer Datenbank abzurufen. Eine der am häufigsten verwendeten Methoden wird jedoch ausgeführt, indem queries über die Befehlszeile gesendet werden.

In relationalen Datenbankverwaltungssystemen ist eine query ein beliebiger Befehl, der zum Abrufen von Daten aus einer Tabelle verwendet wird. In SQL (Structured Query Language) werden Abfragen fast immer mit der Anweisung + SELECT + durchgeführt.

In diesem Handbuch werden die grundlegende Syntax von SQL-Abfragen sowie einige der am häufigsten verwendeten Funktionen und Operatoren erläutert. Wir werden auch üben, SQL-Abfragen unter Verwendung einiger Beispieldaten in einer PostgreSQL-Datenbank durchzuführen.

PostgreSQL, oft mit „Postgres“ abgekürzt, ist ein relationales Datenbankverwaltungssystem mit einem objektorientierten Ansatz, bei dem Informationen in PostgreSQL-Schemata als Objekte oder Klassen dargestellt werden können. PostgreSQL ist eng an Standard-SQL angelehnt, enthält jedoch auch einige Funktionen, die in anderen relationalen Datenbanksystemen nicht vorhanden sind.

Voraussetzungen

Im Allgemeinen können die in diesem Handbuch vorgestellten Befehle und Konzepte auf jedem Linux-basierten Betriebssystem verwendet werden, auf dem eine SQL-Datenbanksoftware ausgeführt wird. Es wurde jedoch speziell für einen Ubuntu 18.04-Server geschrieben, auf dem PostgreSQL ausgeführt wird. Um dies einzurichten, benötigen Sie Folgendes:

Ein Ubuntu 18.04-Computer mit einem Nicht-Root-Benutzer mit Sudo-Berechtigungen. Dies kann in unserem Initial Server Setup-Handbuch für Ubuntu 18.04 eingerichtet werden.
PostgreSQL auf dem Computer installiert. Hilfe zum Einrichten finden Sie im Abschnitt „Installieren von PostgreSQL“ in unserem Handbuch unter https://www.digitalocean.com/community/tutorials/how-to-install-and-use-postgresql-on-ubuntu-18-. 04 # installation-postgresql [So installieren und verwenden Sie PostgreSQL unter Ubuntu 18.04].

Mit diesem Setup können wir mit dem Tutorial beginnen.

Beispieldatenbank erstellen

Bevor wir mit Abfragen in SQL beginnen können, erstellen wir zunächst eine Datenbank und einige Tabellen und füllen diese Tabellen mit einigen Beispieldaten. Auf diese Weise können Sie praktische Erfahrungen sammeln, wenn Sie später anfangen, Fragen zu stellen.

Stellen Sie sich für die in diesem Handbuch verwendete Beispieldatenbank das folgende Szenario vor:

Sie und einige Ihrer Freunde feiern alle Ihre Geburtstage miteinander. Bei jeder Gelegenheit begeben sich die Mitglieder der Gruppe zur örtlichen Kegelbahn, nehmen an einem Freundschaftsturnier teil, und dann geht jeder zu Ihrem Platz, an dem Sie das Lieblingsessen der Geburtstagsperson zubereiten.

_Jetzt, da diese Tradition schon eine Weile besteht, haben Sie beschlossen, die Aufzeichnungen dieser Turniere zu verfolgen. Um die Planung des Abendessens zu vereinfachen, erstellen Sie eine Aufzeichnung der Geburtstage Ihrer Freunde und ihrer bevorzugten Vorspeisen, Beilagen und Desserts. Anstatt diese Informationen in einem physischen Hauptbuch aufzubewahren, entscheiden Sie sich, Ihre Datenbankkenntnisse durch Aufzeichnen in einer PostgreSQL-Datenbank zu üben.

Öffnen Sie zunächst eine PostgreSQL-Eingabeaufforderung als Ihr * postgres * -Superuser:

sudo -u postgres psql

Erstellen Sie als Nächstes die Datenbank, indem Sie Folgendes ausführen:

CREATE DATABASE birthdays;

Wählen Sie dann diese Datenbank aus, indem Sie Folgendes eingeben:

\c birthdays

Als Nächstes erstellen Sie zwei Tabellen in dieser Datenbank. Wir werden den ersten Tisch verwenden, um die Aufzeichnungen Ihrer Freunde in der Bowlingbahn zu verfolgen. Der folgende Befehl erstellt eine Tabelle mit dem Namen "+ Turniere " mit Spalten für den " Namen " jedes Ihrer Freunde, die Anzahl der Turniere, die sie gewonnen haben (" Gewinne "), ihre Gesamtpunktzahl " Beste " , und welche Größe Bowlingschuh sie tragen (` size +`):

CREATE TABLE tourneys (
name varchar(30),
wins real,
best real,
size real
);

Sobald Sie den Befehl "+ CREATE TABLE" ausführen und mit Spaltenüberschriften auffüllen, erhalten Sie die folgende Ausgabe:

OutputCREATE TABLE

Füllen Sie die Tabelle "+ Turniere +" mit einigen Beispieldaten aus:

INSERT INTO tourneys (name, wins, best, size)
VALUES ('Dolly', '7', '245', '8.5'),
('Etta', '4', '283', '9'),
('Irma', '9', '266', '7'),
('Barbara', '2', '197', '7.5'),
('Gladys', '13', '273', '8');

Sie erhalten folgende Ausgabe:

OutputINSERT 0 5

Erstellen Sie anschließend eine weitere Tabelle in derselben Datenbank, in der Informationen zu den beliebtesten Geburtstagsgerichten Ihrer Freunde gespeichert werden. Der folgende Befehl erstellt eine Tabelle mit dem Namen "+ Abendessen " mit Spalten für den " Namen " jedes Ihrer Freunde, dessen " Geburtsdatum +", dessen Lieblingsgericht + ", dessen bevorzugte" + Beilage + "und dessen Lieblingsgericht + dessert + `:

CREATE TABLE dinners (
name varchar(30),
birthdate date,
entree varchar(30),
side varchar(30),
dessert varchar(30)
);

In ähnlicher Weise erhalten Sie für diese Tabelle eine Bestätigung, dass die Tabelle erstellt wurde:

OutputCREATE TABLE

Füllen Sie diese Tabelle auch mit einigen Beispieldaten:

INSERT INTO dinners (name, birthdate, entree, side, dessert)
VALUES ('Dolly', '1946-01-19', 'steak', 'salad', 'cake'),
('Etta', '1938-01-25', 'chicken', 'fries', 'ice cream'),
('Irma', '1941-02-18', 'tofu', 'fries', 'cake'),
('Barbara', '1948-12-25', 'tofu', 'salad', 'ice cream'),
('Gladys', '1944-05-28', 'steak', 'fries', 'ice cream');

OutputINSERT 0 5

Sobald dieser Befehl erfolgreich ausgeführt wurde, ist die Einrichtung Ihrer Datenbank abgeschlossen. Als nächstes gehen wir auf die grundlegende Befehlsstruktur von "+ SELECT +" - Abfragen ein.

Grundlegendes zu SELECT-Anweisungen

Wie in der Einleitung erwähnt, beginnen SQL-Abfragen fast immer mit der Anweisung + SELECT +. + SELECT + wird in Abfragen verwendet, um anzugeben, welche Spalten aus einer Tabelle in der Ergebnismenge zurückgegeben werden sollen. Abfragen enthalten außerdem fast immer "+ FROM +", mit dem angegeben wird, welche Tabelle von der Anweisung abgefragt wird.

Im Allgemeinen folgen SQL-Abfragen dieser Syntax:

SELECT  FROM  WHERE ;

Die folgende Anweisung gibt beispielsweise die gesamte Spalte "+ name " aus der Tabelle " dinners +" zurück:

SELECT name FROM dinners;

Output  name
---------
Dolly
Etta
Irma
Barbara
Gladys
(5 rows)

Sie können mehrere Spalten aus derselben Tabelle auswählen, indem Sie deren Namen durch ein Komma trennen.

SELECT name, birthdate FROM dinners;

Output  name   | birthdate
---------+------------
Dolly   | 1946-01-19
Etta    | 1938-01-25
Irma    | 1941-02-18
Barbara | 1948-12-25
Gladys  | 1944-05-28
(5 rows)

Anstatt eine bestimmte Spalte oder einen bestimmten Satz von Spalten zu benennen, können Sie dem Operator "+ SELECT " ein Sternchen (" * ") folgen, das als Platzhalter für alle Spalten in einer Tabelle dient. Der folgende Befehl gibt jede Spalte aus der Tabelle " tourneys +" zurück:

SELECT * FROM tourneys;

Output  name   | wins | best | size
---------+------+------+------
Dolly   |    7 |  245 |  8.5
Etta    |    4 |  283 |    9
Irma    |    9 |  266 |    7
Barbara |    2 |  197 |  7.5
Gladys  |   13 |  273 |    8
(5 rows)

+ WHERE + wird in Abfragen verwendet, um Datensätze zu filtern, die eine bestimmte Bedingung erfüllen, und alle Zeilen, die diese Bedingung nicht erfüllen, werden aus dem Ergebnis entfernt. Eine + WHERE + - Klausel folgt normalerweise dieser Syntax:

. . . WHERE

Der Vergleichsoperator in einer + WHERE + - Klausel definiert, wie die angegebene Spalte mit dem Wert verglichen werden soll. Hier sind einige gängige SQL-Vergleichsoperatoren:

Operator What it does

Operator	What it does
`=`	tests for equality
`!=`	tests for inequality
`<`	tests for less-than
`>`	tests for greater-than
`<=`	tests for less-than or equal-to
`>=`	tests for greater-than or equal-to
`BETWEEN`	tests whether a value lies within a given range
`IN`	tests whether a row’s value is contained in a set of specified values
`EXISTS`	tests whether rows exist, given the specified conditions
`LIKE`	tests whether a value matches a specified string
`IS NULL`	tests for `NULL` values
`IS NOT NULL`	tests for all values other than `NULL`

=

tests for equality

!=

tests for inequality

<

tests for less-than

>

tests for greater-than

<=

tests for less-than or equal-to

>=

tests for greater-than or equal-to

BETWEEN

tests whether a value lies within a given range

IN

tests whether a row’s value is contained in a set of specified values

EXISTS

tests whether rows exist, given the specified conditions

LIKE

tests whether a value matches a specified string

IS NULL

tests for NULL values

IS NOT NULL

tests for all values other than NULL

Wenn Sie beispielsweise die Schuhgröße von Irma ermitteln möchten, können Sie die folgende Abfrage verwenden:

SELECT size FROM tourneys WHERE name = 'Irma';

Output size
------
   7
(1 row)

SQL erlaubt die Verwendung von Platzhalterzeichen. Diese sind besonders praktisch, wenn sie in + WHERE + - Klauseln verwendet werden. Prozentzeichen (+% +) stehen für null oder mehr unbekannte Zeichen und Unterstriche (+ _ +) für ein einzelnes unbekanntes Zeichen. Diese sind nützlich, wenn Sie versuchen, einen bestimmten Eintrag in einer Tabelle zu finden, sich aber nicht sicher sind, um welchen Eintrag es sich genau handelt. Nehmen wir zur Veranschaulichung an, Sie haben das Lieblingsgericht einiger Ihrer Freunde vergessen, sind sich aber sicher, dass dieses bestimmte Gericht mit einem "t" beginnt. Sie können den Namen finden, indem Sie die folgende Abfrage ausführen:

SELECT entree FROM dinners WHERE entree LIKE 't%';

Output entree
-------
tofu
tofu
(2 rows)

Basierend auf der obigen Ausgabe sehen wir, dass das Entree, das wir vergessen haben, "+ tofu +" ist.

Es kann vorkommen, dass Sie mit Datenbanken arbeiten, die Spalten oder Tabellen mit relativ langen oder schwer lesbaren Namen enthalten. In diesen Fällen können Sie die Lesbarkeit dieser Namen verbessern, indem Sie einen Alias mit dem Schlüsselwort "+ AS " erstellen. Aliase, die mit " AS +" erstellt wurden, sind temporär und nur für die Dauer der Abfrage vorhanden, für die sie erstellt wurden:

SELECT name AS n, birthdate AS b, dessert AS d FROM dinners;

Output    n    |     b      |     d
---------+------------+-----------
Dolly   | 1946-01-19 | cake
Etta    | 1938-01-25 | ice cream
Irma    | 1941-02-18 | cake
Barbara | 1948-12-25 | ice cream
Gladys  | 1944-05-28 | ice cream
(5 rows)

Hier haben wir SQL angewiesen, die Spalte "+ name " als " n ", die Spalte " birthdate " als " b " und die Spalte " dessert " als " d +" anzuzeigen.

Die Beispiele, die wir bisher durchgearbeitet haben, enthalten einige der am häufigsten verwendeten Schlüsselwörter und Klauseln in SQL-Abfragen. Diese sind nützlich für grundlegende Abfragen, aber nicht hilfreich, wenn Sie versuchen, eine Berechnung durchzuführen oder einen Skalarwert (einen einzelnen Wert im Gegensatz zu einer Reihe von mehreren unterschiedlichen Werten) basierend auf Ihren Daten abzuleiten. Hier kommen Aggregatfunktionen ins Spiel.

Aggregatfunktionen

Wenn Sie mit Daten arbeiten, möchten Sie häufig nicht unbedingt die Daten selbst sehen. Sie möchten vielmehr Informationen über die Daten. Die SQL-Syntax enthält eine Reihe von Funktionen, mit denen Sie Berechnungen für Ihre Daten interpretieren oder ausführen können, indem Sie einfach eine "+ SELECT +" - Abfrage absetzen. Diese werden als Aggregatfunktionen bezeichnet.

Die Funktion "+ COUNT +" zählt und gibt die Anzahl der Zeilen zurück, die einem bestimmten Kriterium entsprechen. Wenn Sie beispielsweise wissen möchten, wie viele Ihrer Freunde Tofu für ihre Geburtstagsfeier bevorzugen, können Sie folgende Abfrage durchführen:

SELECT COUNT(entree) FROM dinners WHERE entree = 'tofu';

Output count
-------
    2
(1 row)

Die Funktion + AVG + gibt den Durchschnittswert (Mittelwert) einer Spalte zurück. Anhand unserer Beispieltabelle konnten Sie mit dieser Abfrage die durchschnittliche beste Punktzahl unter Ihren Freunden ermitteln:

SELECT AVG(best) FROM tourneys;

Output  avg
-------
252.8
(1 row)

+ SUM + wird verwendet, um die Gesamtsumme einer bestimmten Spalte zu ermitteln. Wenn Sie beispielsweise sehen möchten, wie viele Spiele Sie und Ihre Freunde im Laufe der Jahre gespielt haben, können Sie die folgende Abfrage ausführen:

SELECT SUM(wins) FROM tourneys;

Output sum
-----
 35
(1 row)

Beachten Sie, dass die Funktionen "+ AVG " und " SUM " nur bei Verwendung mit numerischen Daten korrekt funktionieren. Wenn Sie versuchen, sie für nicht numerische Daten zu verwenden, wird je nach verwendetem RDBMS entweder ein Fehler oder nur " 0 +" ausgegeben:

SELECT SUM(entree) FROM dinners;

OutputERROR:  function sum(character varying) does not exist
LINE 1: select sum(entree) from dinners;
              ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.

+ MIN + wird verwendet, um den kleinsten Wert innerhalb einer angegebenen Spalte zu finden. Mit dieser Abfrage können Sie den schlechtesten Bowling-Gesamtrekord (in Bezug auf die Anzahl der Siege) ermitteln:

SELECT MIN(wins) FROM tourneys;

Output min
-----
  2
(1 row)

In ähnlicher Weise wird "+ MAX +" verwendet, um den größten numerischen Wert in einer gegebenen Spalte zu finden. Die folgende Abfrage zeigt den besten Bowling-Rekord insgesamt:

SELECT MAX(wins) FROM tourneys;

Output max
-----
 13
(1 row)

Im Gegensatz zu "+ SUM" und "+ AVG" können die Funktionen "+ MIN" und "+ MAX" sowohl für numerische als auch für alphabetische Datentypen verwendet werden. Beim Ausführen einer Spalte mit Zeichenfolgenwerten zeigt die Funktion "+ MIN +" den ersten Wert alphabetisch an:

SELECT MIN(name) FROM dinners;

Output   min
---------
Barbara
(1 row)

Wenn Sie eine Spalte mit Zeichenfolgenwerten ausführen, zeigt die Funktion "+ MAX +" den letzten Wert in alphabetischer Reihenfolge an:

SELECT MAX(name) FROM dinners;

Output max
------
Irma
(1 row)

Aggregatfunktionen haben viele Anwendungsmöglichkeiten, die über die in diesem Abschnitt beschriebenen hinausgehen. Sie sind besonders nützlich, wenn sie mit der Klausel "+ GROUP BY +" verwendet werden, die im nächsten Abschnitt zusammen mit mehreren anderen Abfrageklauseln behandelt wird, die sich auf die Sortierung von Ergebnismengen auswirken.

Bearbeiten von Abfrageausgaben

Zusätzlich zu den Klauseln "+ FROM" und "+ WHERE" gibt es mehrere andere Klauseln, die zum Bearbeiten der Ergebnisse einer "+ SELECT +" - Abfrage verwendet werden. In diesem Abschnitt werden einige der am häufigsten verwendeten Abfrageklauseln erläutert und anhand von Beispielen erläutert.

Eine der am häufigsten verwendeten Abfrageklauseln, abgesehen von "+ FROM" und "+ WHERE", ist die "+ GROUP BY" -Klausel. Diese Option wird normalerweise verwendet, wenn Sie eine Aggregatfunktion für eine Spalte ausführen, jedoch in Bezug auf übereinstimmende Werte in einer anderen Spalte.

Angenommen, Sie möchten wissen, wie viele Ihrer Freunde die drei Hauptgerichte bevorzugen, die Sie erstellen. Sie können diese Information mit der folgenden Abfrage finden:

SELECT COUNT(name), entree FROM dinners GROUP BY entree;

Output count | entree
-------+---------
    1 | chicken
    2 | steak
    2 | tofu
(3 rows)

Die "+ ORDER BY" -Klausel wird zum Sortieren von Abfrageergebnissen verwendet. Standardmäßig werden numerische Werte in aufsteigender Reihenfolge und Textwerte in alphabetischer Reihenfolge sortiert. Zur Veranschaulichung listet die folgende Abfrage die Spalten "+ name" und "+ birthdate" auf, sortiert die Ergebnisse jedoch nach dem Geburtsdatum:

SELECT name, birthdate FROM dinners ORDER BY birthdate;

Output  name   | birthdate
---------+------------
Etta    | 1938-01-25
Irma    | 1941-02-18
Gladys  | 1944-05-28
Dolly   | 1946-01-19
Barbara | 1948-12-25
(5 rows)

Beachten Sie, dass das Standardverhalten von "+ ORDER BY " darin besteht, die Ergebnismenge in aufsteigender Reihenfolge zu sortieren. Um dies umzukehren und die Ergebnismenge in absteigender Reihenfolge sortieren zu lassen, schließen Sie die Abfrage mit ` DESC +`:

SELECT name, birthdate FROM dinners ORDER BY birthdate DESC;

Output  name   | birthdate
---------+------------
Barbara | 1948-12-25
Dolly   | 1946-01-19
Gladys  | 1944-05-28
Irma    | 1941-02-18
Etta    | 1938-01-25
(5 rows)

Wie bereits erwähnt, wird die Klausel "+ WHERE " verwendet, um Ergebnisse basierend auf bestimmten Bedingungen zu filtern. Wenn Sie jedoch die Klausel ` WHERE +` mit einer Aggregatfunktion verwenden, wird ein Fehler zurückgegeben, wie dies bei dem folgenden Versuch der Fall ist, herauszufinden, welche Seiten der Favorit von mindestens drei Ihrer Freunde sind:

SELECT COUNT(name), side FROM dinners WHERE COUNT(name) >= 3;

OutputERROR:  aggregate functions are not allowed in WHERE
LINE 1: SELECT COUNT(name), side FROM dinners WHERE COUNT(name) >= 3...

Die Klausel + HAVING + wurde zu SQL hinzugefügt, um ähnliche Funktionen wie die Klausel + WHERE + bereitzustellen und gleichzeitig mit Aggregatfunktionen kompatibel zu sein. Es ist hilfreich, sich den Unterschied zwischen diesen beiden Klauseln so vorzustellen, dass "+ WHERE " für einzelne Datensätze gilt, während " HAVING " für Gruppendatensätze gilt. Zu diesem Zweck muss jedes Mal, wenn Sie eine " HAVING" -Klausel absetzen, auch die "+ GROUP BY" -Klausel vorhanden sein.

Das folgende Beispiel ist ein weiterer Versuch, herauszufinden, welche Beilagen bei mindestens drei Ihrer Freunde am beliebtesten sind, obwohl dieses Beispiel ein fehlerfreies Ergebnis liefert:

SELECT COUNT(name), side FROM dinners GROUP BY side HAVING COUNT(name) >= 3;

Output count | side
-------+-------
    3 | fries
(1 row)

Aggregatfunktionen sind nützlich, um die Ergebnisse einer bestimmten Spalte in einer bestimmten Tabelle zusammenzufassen. Es gibt jedoch viele Fälle, in denen der Inhalt mehrerer Tabellen abgefragt werden muss. Im nächsten Abschnitt gehen wir einige Möglichkeiten durch, wie Sie dies tun können.

Mehrere Tabellen abfragen

In den meisten Fällen enthält eine Datenbank mehrere Tabellen mit jeweils unterschiedlichen Datensätzen. SQL bietet verschiedene Möglichkeiten, eine einzelne Abfrage für mehrere Tabellen auszuführen.

Die Klausel + JOIN + kann verwendet werden, um Zeilen aus zwei oder mehr Tabellen in einem Abfrageergebnis zu kombinieren. Dies geschieht, indem eine verwandte Spalte zwischen den Tabellen gefunden und die Ergebnisse in der Ausgabe entsprechend sortiert werden.

+ SELECT + -Anweisungen, die eine + JOIN + -Klausel enthalten, folgen im Allgemeinen dieser Syntax:

SELECT ., .
FROM
JOIN  ON .=.;

Beachten Sie, dass, da die Klauseln + JOIN + den Inhalt von mehr als einer Tabelle vergleichen, im vorherigen Beispiel angegeben ist, aus welcher Tabelle jede Spalte ausgewählt werden soll, indem dem Namen der Spalte der Name der Tabelle und ein Punkt vorangestellt werden. Sie können angeben, aus welcher Tabelle eine Spalte für eine Abfrage ausgewählt werden soll. Dies ist jedoch nicht erforderlich, wenn Sie eine einzelne Tabelle auswählen, wie in den vorherigen Abschnitten beschrieben. Lassen Sie uns anhand unserer Beispieldaten ein Beispiel durchgehen.

Stellen Sie sich vor, Sie wollten jedem Ihrer Freunde ein Paar Bowlingschuhe zum Geburtstag schenken. Da die Informationen zu den Geburtsdaten und Schuhgrößen Ihrer Freunde in separaten Tabellen gespeichert sind, können Sie beide Tabellen separat abfragen und dann die Ergebnisse der einzelnen Tabellen vergleichen. Mit einer + JOIN + - Klausel können Sie jedoch alle gewünschten Informationen mit einer einzigen Abfrage finden:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
JOIN dinners ON tourneys.name=dinners.name;

Output  name   | size | birthdate
---------+------+------------
Dolly   |  8.5 | 1946-01-19
Etta    |    9 | 1938-01-25
Irma    |    7 | 1941-02-18
Barbara |  7.5 | 1948-12-25
Gladys  |    8 | 1944-05-28
(5 rows)

Die in diesem Beispiel verwendete "+ JOIN" -Klausel ist ohne weitere Argumente eine innere "+ JOIN" -Klausel. Dies bedeutet, dass alle Datensätze mit übereinstimmenden Werten in beiden Tabellen ausgewählt und in der Ergebnismenge gedruckt werden. Nicht übereinstimmende Datensätze werden ausgeschlossen. Fügen Sie zur Veranschaulichung dieser Idee jeder Tabelle eine neue Zeile hinzu, für die in der anderen Tabelle kein entsprechender Eintrag vorhanden ist:

INSERT INTO tourneys (name, wins, best, size)
VALUES ('Bettye', '0', '193', '9');

INSERT INTO dinners (name, birthdate, entree, side, dessert)
VALUES ('Lesley', '1946-05-02', 'steak', 'salad', 'ice cream');

Führen Sie dann die vorherige Anweisung + SELECT + mit der Klausel + JOIN + erneut aus:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
JOIN dinners ON tourneys.name=dinners.name;

Output  name   | size | birthdate
---------+------+------------
Dolly   |  8.5 | 1946-01-19
Etta    |    9 | 1938-01-25
Irma    |    7 | 1941-02-18
Barbara |  7.5 | 1948-12-25
Gladys  |    8 | 1944-05-28
(5 rows)

Beachten Sie, dass diese Datensätze in dieser Ausgabe fehlen, da die Tabelle "+ Turniere " keinen Eintrag für Lesley und die Tabelle " Abendessen +" keinen Eintrag für Bettye enthält.

Es ist jedoch möglich, alle Datensätze aus einer der Tabellen mit einer outer + JOIN + - Klausel zurückzugeben. Äußere "+ JOIN " -Klauseln werden entweder als " LEFT JOIN ", " RIGHT JOIN " oder " FULL JOIN +" geschrieben.

Eine + LEFT JOIN + - Klausel gibt alle Datensätze aus der “linken” Tabelle und nur die übereinstimmenden Datensätze aus der rechten Tabelle zurück. Im Kontext von Outer-Joins ist die linke Tabelle diejenige, auf die durch die Klausel "+ FROM " verwiesen wird, und die rechte Tabelle ist jede andere Tabelle, auf die nach der Anweisung " JOIN +" verwiesen wird.

Führen Sie die vorherige Abfrage erneut aus, verwenden Sie diesmal jedoch eine Klausel + LEFT JOIN +:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
LEFT JOIN dinners ON tourneys.name=dinners.name;

Dieser Befehl gibt jeden Datensatz aus der linken Tabelle zurück (in diesem Fall "+ Turniere "), auch wenn die rechte Tabelle keinen entsprechenden Datensatz enthält. Jedes Mal, wenn es keinen passenden Datensatz aus der rechten Tabelle gibt, wird er als leerer Wert oder " NULL +" zurückgegeben, abhängig von Ihrem RDBMS:

Output  name   | size | birthdate
---------+------+------------
Dolly   |  8.5 | 1946-01-19
Etta    |    9 | 1938-01-25
Irma    |    7 | 1941-02-18
Barbara |  7.5 | 1948-12-25
Gladys  |    8 | 1944-05-28
Bettye  |    9 |
(6 rows)

Führen Sie nun die Abfrage erneut aus, diesmal mit einer Klausel + RIGHT JOIN +:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
RIGHT JOIN dinners ON tourneys.name=dinners.name;

Dies gibt alle Datensätze vom rechten Tisch zurück (+ Abendessen +). Da das Geburtsdatum von Lesley in der rechten Tabelle aufgezeichnet ist, in der linken Tabelle jedoch keine entsprechende Zeile für sie vorhanden ist, werden die Spalten "+ name " und " size +" als leere Werte in dieser Zeile zurückgegeben:

Output  name   | size | birthdate
---------+------+------------
Dolly   |  8.5 | 1946-01-19
Etta    |    9 | 1938-01-25
Irma    |    7 | 1941-02-18
Barbara |  7.5 | 1948-12-25
Gladys  |    8 | 1944-05-28
        |      | 1946-05-02
(6 rows)

Beachten Sie, dass Links- und Rechts-Joins als "+ LEFT OUTER JOIN " oder " RIGHT OUTER JOIN " geschrieben werden können, obwohl der " OUTER " - Teil der Klausel impliziert ist. Ebenso führt die Angabe von " INNER JOIN" zum gleichen Ergebnis wie das Schreiben von "+ JOIN".

Für einige RDBMS-Distributionen, einschließlich PostgreSQL, steht eine vierte Join-Klausel mit dem Namen "+ FULL JOIN " zur Verfügung. Ein ` FULL JOIN +` gibt alle Datensätze aus jeder Tabelle zurück, einschließlich aller Nullwerte:

SELECT tourneys.name, tourneys.size, dinners.birthdate
FROM tourneys
FULL JOIN dinners ON tourneys.name=dinners.name;

Output  name   | size | birthdate
---------+------+------------
Dolly   |  8.5 | 1946-01-19
Etta    |    9 | 1938-01-25
Irma    |    7 | 1941-02-18
Barbara |  7.5 | 1948-12-25
Gladys  |    8 | 1944-05-28
Bettye  |    9 |
        |      | 1946-05-02
(7 rows)

Alternativ zur Verwendung von "+ FULL JOIN " zum Abfragen aller Datensätze aus mehreren Tabellen können Sie die Klausel " UNION +" verwenden.

Der Operator "+ UNION " unterscheidet sich geringfügig von einer Klausel " JOIN ": Anstatt die Ergebnisse mehrerer Tabellen als eindeutige Spalten mit einer einzigen " SELECT " - Anweisung zu drucken, kombiniert " UNION " die Ergebnisse zweier " SELECT +" - Anweisungen in eine einzige Spalte.

Führen Sie zur Veranschaulichung die folgende Abfrage aus:

SELECT name FROM tourneys UNION SELECT name FROM dinners;

Diese Abfrage entfernt alle doppelten Einträge. Dies ist das Standardverhalten des Operators "+ UNION":

Output  name
---------
Irma
Etta
Bettye
Gladys
Barbara
Lesley
Dolly
(7 rows)

Um alle Einträge (einschließlich Duplikate) zurückzugeben, verwenden Sie den Operator + UNION ALL +:

SELECT name FROM tourneys UNION ALL SELECT name FROM dinners;

Output  name
---------
Dolly
Etta
Irma
Barbara
Gladys
Bettye
Dolly
Etta
Irma
Barbara
Gladys
Lesley
(12 rows)

Die Namen und die Anzahl der Spalten in der Ergebnistabelle geben den Namen und die Anzahl der Spalten wieder, die von der ersten "+ SELECT " - Anweisung abgefragt wurden. Beachten Sie, dass bei Verwendung von " UNION " zum Abfragen mehrerer Spalten aus mehr als einer Tabelle jede " SELECT " - Anweisung die gleiche Anzahl von Spalten abfragen muss, die entsprechenden Spalten ähnliche Datentypen haben müssen und die Spalten in jedem " SELECT " Anweisung muss in der gleichen Reihenfolge sein. Das folgende Beispiel zeigt, was passieren kann, wenn Sie eine " UNION" -Klausel für zwei "+ SELECT" -Anweisungen verwenden, die eine unterschiedliche Anzahl von Spalten abfragen:

SELECT name FROM dinners UNION SELECT name, wins FROM tourneys;

OutputERROR:  each UNION query must have the same number of columns
LINE 1: SELECT name FROM dinners UNION SELECT name, wins FROM tourne...

Eine andere Möglichkeit, mehrere Tabellen abzufragen, ist die Verwendung von subqueries. Unterabfragen (auch als inner oder nested queries bezeichnet) sind Abfragen, die in einer anderen Abfrage enthalten sind. Dies ist hilfreich, wenn Sie versuchen, die Ergebnisse einer Abfrage nach dem Ergebnis einer separaten Aggregatfunktion zu filtern.

Um diese Idee zu veranschaulichen, sagen Sie, Sie möchten wissen, welche Ihrer Freunde mehr Spiele als Barbara gewonnen haben. Anstatt zu erfragen, wie viele Spiele Barbara gewonnen hat, und dann eine weitere Abfrage auszuführen, um festzustellen, wer mehr Spiele gewonnen hat, können Sie beide mit einer einzigen Abfrage berechnen:

SELECT name, wins FROM tourneys
WHERE wins > (
SELECT wins FROM tourneys WHERE name = 'Barbara'
);

Output  name  | wins
--------+------
Dolly  |    7
Etta   |    4
Irma   |    9
Gladys |   13
(4 rows)

Die Unterabfrage in dieser Anweisung wurde nur einmal ausgeführt. Es musste nur der Wert aus der Spalte "+ wins " in derselben Zeile wie " Barbara " in der Spalte " name +" gefunden werden, und die von der Unterabfrage und der äußeren Abfrage zurückgegebenen Daten waren unabhängig voneinander. Es gibt jedoch Fälle, in denen die äußere Abfrage zuerst jede Zeile in einer Tabelle lesen und diese Werte mit den von der Unterabfrage zurückgegebenen Daten vergleichen muss, um die gewünschten Daten zurückzugeben. In diesem Fall wird die Unterabfrage als korrelierte Unterabfrage bezeichnet.

Die folgende Anweisung ist ein Beispiel für eine korrelierte Unterabfrage. Diese Abfrage versucht herauszufinden, welche Ihrer Freunde mehr Spiele gewonnen haben als der Durchschnitt für diejenigen mit derselben Schuhgröße:

SELECT name, size FROM tourneys AS t
WHERE wins > (
SELECT AVG(wins) FROM tourneys WHERE size = t.size
);

Damit die Abfrage abgeschlossen werden kann, müssen zuerst die Spalten "+ names" und "+ size of" aus der äußeren Abfrage erfasst werden. Anschließend wird jede Zeile aus dieser Ergebnismenge mit den Ergebnissen der inneren Abfrage verglichen, die die durchschnittliche Anzahl der Siege für Personen mit identischen Schuhgrößen ermittelt. Da Sie nur zwei Freunde haben, die dieselbe Schuhgröße haben, kann die Ergebnismenge nur eine Zeile enthalten:

Output name | size
------+------
Etta |    9
(1 row)

Wie bereits erwähnt, können Unterabfragen verwendet werden, um Ergebnisse aus mehreren Tabellen abzufragen. Um dies mit einem letzten Beispiel zu veranschaulichen, sagen Sie, Sie wollten ein Überraschungsdinner für den besten Bowler der Gruppe abhalten. Mit der folgenden Abfrage können Sie herausfinden, welcher Ihrer Freunde die beste Bowling-Bilanz aufweist, und ihr Lieblingsgericht zurückgeben:

SELECT name, entree, side, dessert
FROM dinners
WHERE name = (SELECT name FROM tourneys
WHERE wins = (SELECT MAX(wins) FROM tourneys));

Output  name  | entree | side  |  dessert
--------+--------+-------+-----------
Gladys | steak  | fries | ice cream
(1 row)

Beachten Sie, dass diese Anweisung nicht nur eine Unterabfrage enthält, sondern auch eine Unterabfrage innerhalb dieser Unterabfrage.

Fazit

Das Ausgeben von Abfragen ist eine der am häufigsten ausgeführten Aufgaben im Bereich der Datenbankverwaltung. Es gibt eine Reihe von Datenbankverwaltungstools wie phpMyAdmin oder pgAdmin, mit denen Sie Abfragen durchführen und die Ergebnisse anzeigen können. Die Ausgabe von "+ SELECT +" - Anweisungen über die Befehlszeile ist jedoch nach wie vor ein weit verbreiteter Arbeitsablauf, der Ihnen auch eine bessere Kontrolle bieten kann.

Wenn Sie neu in der Arbeit mit SQL sind, empfehlen wir Ihnen, unser SQL Cheat Sheet als zu verwenden Referenz und zur Überprüfung der offiziellen PostgreSQL-Dokumentation. Wenn Sie mehr über SQL und relationale Datenbanken erfahren möchten, sind möglicherweise die folgenden Lernprogramme für Sie von Interesse:

TOC