Dieser Artikel enthält Beispiele für grundlegende SQL-Abfragen, mit denen Anfänger Daten aus ihren Datenbanken abrufen können.
Einfaches SELECT Abfrage
Hier ist ein Beispiel für die möglicherweise am häufigsten verwendete Abfrage in SQL:
SELECT *
FROM Pets;Ergebnis:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Diese Abfrage wählt alle Zeilen und alle Spalten der Pets aus Tisch. Das liegt daran, dass das Sternchen (* ) Wildcard wählt alle Spalten aus.
Spaltennamen auswählen
Aus Leistungsgründen ist es normalerweise am besten, nicht alle Spalten auszuwählen, es sei denn, Sie benötigen sie wirklich. Normalerweise ist es besser, nur die benötigten Spalten auszuwählen.
Hier ist ein Beispiel.
SELECT PetId, PetName
FROM Pets;Ergebnis:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Ergebnisse filtern
Sie können ein WHERE hinzufügen -Klausel, um die Ergebnisse nur auf die Zeilen zu filtern, die Sie benötigen.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Ergebnis:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Hier ist ein weiteres Beispiel für das Filtern der Ergebnisse. Dieses Mal verwenden wir den Größer-als-Operator (> ), um es nach Datum zu filtern.
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Ergebnis:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Sie können den Größer-als-Operator gegen andere Operatoren austauschen, z. B. den Größer-als-gleich-Operator (>= ), Kleiner-als-Operator (< ) oder Kleiner-gleich-Operator (<= ).
Sie können auch den BETWEEN verwenden Operator, um die Ergebnisse auf einen bestimmten Bereich zu filtern (z. B. zwischen zwei Daten).
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Ergebnis:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Sortieren Sie die Ergebnisse
Sie können einen ORDER BY hinzufügen -Klausel, um die von der Abfrage zurückgegebenen Zeilen zu sortieren.
Aufsteigende Reihenfolge
Verwenden Sie den ASC Schlüsselwort, um die Ergebnisse in aufsteigender Reihenfolge zu sortieren. Dies ist der Standardwert, Sie können dieses Schlüsselwort also auch weglassen, wenn Sie die Ergebnisse in aufsteigender Reihenfolge wünschen.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Oder:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Ergebnis:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Absteigende Reihenfolge
Verwenden Sie den DESC Stichwort, um die Ergebnisse in absteigender Reihenfolge zu sortieren.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Ergebnis:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Nach mehreren Spalten sortieren
Sie können nach mehreren Spalten sortieren, indem Sie jede Spalte durch ein Komma getrennt auflisten.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Ergebnis:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+ (8 rows affected) +---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 6 | Fluffy | | 1 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+ (8 rows affected)
Wir können sehen, dass die beiden Fluffys in jedem Ergebnis eine andere Reihenfolge haben (wir können dies anhand ihrer PetId erkennen Werte). Das liegt daran, dass der PetName Spalte wurde zuerst sortiert, dann die PetId alle Duplikate aus der ersten Sortierung sortiert.
Nach ausgeblendeten Spalten sortieren
Sie können nach Spalten sortieren, die nicht im SELECT enthalten sind Liste.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Ergebnis:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
In diesem Fall können wir aus diesen Ergebnissen schließen, dass Tweet ist das jüngste Haustier und Meow ist die älteste. Das liegt daran, dass wir nach ihrem Geburtsdatum sortiert haben (DOB ) Spalte in absteigender Reihenfolge.
Nur zur Sicherheit hier nochmal mit dem DOB Spalte, die in SELECT enthalten ist Liste.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Ergebnis:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 5 | Tweet | 2020-11-28 | | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 4 | Wag | 2020-03-15 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 7 | Bark | NULL | | 8 | Meow | NULL | +---------+-----------+------------+
Tatsächlich können wir jetzt sehen, dass Meow und Bark NULL haben Werte im DOB Säule. Daher wissen wir nicht, ob sie tatsächlich älter oder jünger sind.
Aber das zeigt, dass NULL Werte werden als niedrigstmögliche Werte behandelt. Achten Sie auf NULL Werte beim Ausführen von Abfragen.
Musterabgleich
Sie können den LIKE verwenden Operator, um den Musterabgleich zu verwenden.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Ergebnis:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
In diesem Beispiel suchen wir nach allen Haustieren, deren Namen mit dem Buchstaben F beginnen . Das Prozentzeichen (% ) ist ein Platzhalterzeichen, das mit einer beliebigen Zeichenfolge aus null oder mehr Zeichen übereinstimmt. Es kann entweder als Präfix oder Suffix verwendet werden, und es kann auch in der Mitte einer Zeichenfolge verwendet werden.
Hier ist ein weiteres Beispiel.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Ergebnis:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Aus einer Liste auswählen
Der IN -Operator bestimmt, ob ein angegebener Wert mit einem beliebigen Wert in einer Unterabfrage oder einer Liste übereinstimmt.
Hier ist ein Beispiel.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Ergebnis:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Unterabfragen
Sie können den IN verwenden -Operator beim Ausführen einer Unterabfrage (eine in einer anderen Abfrage verschachtelte Abfrage).
Hier ist ein Beispiel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Ergebnis:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Dies gab Spalten aus einer Tabelle zurück (PetTypes ), aber nur, wenn es mindestens eine entsprechende Zeile in einer anderen Tabelle gab (Pets ), die mit PetTypeId übereinstimmten Spalte.
Um dies weiter zu demonstrieren, werden die relevanten Inhalte dieser beiden Tabellen unten gezeigt.
Die PetTypes Tabelle:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Die Pets Tabelle:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Wir können sehen, dass die PetTypes Die Tabelle enthält den Haustiertyp Rabbit , aber keines der Haustiere in Pets Tabelle wurde dieser Typ zugewiesen (d. h. es gibt keinen Wert von 4 in der Pets.PetTypeId Spalte).
Siehe 12 häufig verwendete SQL-Operatoren und diese Liste von SQL-Operatoren für weitere Informationen über Operatoren in SQL.
Beitreten
Es ist fraglich, ob SQL-Joins als „einfache SQL-Abfragen“ betrachtet werden, aber ich füge hier trotzdem einen Join hinzu.
Um diesen Artikel abzurunden, hier ein Beispiel für einen Inner Join.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Ergebnis:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
In diesem Fall haben wir einen INNER JOIN verwendet um alle Tiernamen mit ihren jeweiligen Tierarten zurückzugeben. Wir haben den ON verwendet -Klausel, um das Prädikat anzugeben, das für jedes Paar verbundener Zeilen ausgewertet werden soll. In diesem Fall die p.PetTypeId Spalte ist ein Fremdschlüssel der pt.PetTypeId Spalte, die der Primärschlüssel für die PetTypes ist Tabelle.
In diesem Beispiel habe ich auch Aliase für die Tabellen verwendet, was dazu beigetragen hat, den Code schön und prägnant zu halten.
Weitere Beispiele für Joins finden Sie in meinem Tutorial zu SQL-Joins.
