In SQL ist ein Operator ein Sonderzeichen oder Schlüsselwort, das eine Aktion angibt, die für einen oder mehrere Ausdrücke ausgeführt wird.
SQL-Operatoren sind ein integraler Bestandteil von SQL und ermöglichen es uns, Abfragen zu schreiben, die relevante Ergebnisse zurückgeben.
In diesem Artikel stelle ich 12 der am häufigsten verwendeten SQL-Operatoren beim Schreiben von SQL-Abfragen vor.
Die Gleichen (= ) Operator
Der Equals-Operator (= ) ist wahrscheinlich der am häufigsten verwendete Operator in SQL. Es vergleicht die Gleichheit zweier Ausdrücke. Selbst wenn Sie mit SQL nicht mehr als vage vertraut sind, werden Sie diesen Operator wahrscheinlich kennen.
Stellen Sie sich vor, wir haben eine Datenbank für ein Haustierhotel und möchten Informationen über alle Haustiere mit dem Namen Fluffy erhalten.
In diesem Fall könnten wir Folgendes tun:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Ergebnis:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Unsere Abfrage verwendet den Equals-Operator (= ), um die Gleichheit des Werts von PetName zu vergleichen Spalte und die Zeichenfolge Fluffy .
In unserem Fall können wir sehen, dass das Haustierhotel derzeit zwei Haustiere namens Fluffy hat.
Größer als (> ) Operator
Der Größer-als-Operator (> ) vergleicht zwei Ausdrücke und gibt TRUE zurück wenn der linke Operand einen höheren Wert hat als der rechte Operand; andernfalls ist das Ergebnis FALSE .
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 | +-----------+------------+
In diesem Fall wird der Wert von DOB verglichen Spalte und das Datum 2020-01-01 um zu sehen, ob das DOB Spalte ist größer.
Kleiner als (< ) Operator
Der Kleiner-als-Operator (< ) bewirkt das Gegenteil. Es vergleicht zwei Ausdrücke und gibt TRUE zurück wenn der linke Operand einen niedrigeren Wert als der rechte Operand hat; andernfalls ist das Ergebnis FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Ergebnis:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Größer als oder gleich (>= ) Operator
Der Größer-als-gleich-Operator (>= ) vergleicht zwei Ausdrücke und gibt TRUE zurück wenn der linke Operand einen Wert hat, der größer oder gleich dem rechten Operanden ist; andernfalls wird FALSE zurückgegeben .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Ergebnis:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Beachten Sie, dass 2020-09-17 zurückgegeben wurde und alle Daten größer als das. Wenn wir den Größer-als-Operator (> ), wären nur die ersten beiden Zeilen zurückgegeben worden.
Kleiner als oder gleich (<= ) Operator
Der Kleiner-als-gleich-Operator (<= ) vergleicht zwei Ausdrücke und gibt TRUE zurück wenn der linke Operand einen Wert hat, der kleiner oder gleich dem rechten Operanden ist; andernfalls ist das Ergebnis FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Ergebnis:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Beachten Sie, dass 2020-09-17 zurückgegeben wurde und alle Daten darunter. Wenn wir den Kleiner-als-Operator (< ), wären nur die ersten drei Zeilen zurückgegeben worden.
Das AND Betreiber
Das AND Operator kombiniert zwei boolesche Ausdrücke und gibt TRUE zurück wenn beide Ausdrücke TRUE sind .
Hier ist ein Beispiel.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Ergebnis:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
In diesem Fall erhalten wir nur Details zu den Haustieren, deren Name Fluffy und ist ihr Geburtsdatum liegt zwischen den beiden Daten.
Das OR Betreiber
Das OR Operator kombiniert zwei boolesche Ausdrücke und gibt TRUE zurück wenn eine der Bedingungen TRUE ist .
Hier ist ein Beispiel.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Ergebnis:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Dies ist im Grunde das Gegenteil von AND Operator. Wenn wir AND verwendet hätten , wären keine Zeilen zurückgegeben worden, da wir nicht zwei verschiedene Werte gleichzeitig in einer Spalte haben können.
Der BETWEEN Betreiber
Der BETWEEN -Operator ermöglicht es uns, einen zu testenden Bereich anzugeben. Beispielsweise können wir damit Haustiere zurückgeben, die zwischen zwei Daten geboren wurden.
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 | +-----------+------------+
Das NOT Betreiber
Das NOT -Operator negiert eine boolesche Eingabe (er kehrt den Wert eines beliebigen booleschen Ausdrucks um). Gibt daher TRUE zurück wenn der Ausdruck FALSE ist .
Folgendes passiert, wenn wir NOT hinzufügen Operator zu unserem vorherigen Beispiel.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Ergebnis:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Dieses Mal haben wir alle anderen Haustiere bekommen – die Haustiere, die keine waren zwischen diesen Daten geboren.
In MariaDB NOT ist auf das Negieren von IN beschränkt , BETWEEN , und EXISTS Klauseln. Die meisten anderen DBMSs erlauben NOT jeden Ausdruck zu negieren.
Der IN Betreiber
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 | +---------+-----------+------------+
Wir könnten dasselbe Ergebnis erzielen, indem wir zwei OR verwenden Operatoren:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Allerdings ist der IN Operator ist eine prägnantere Möglichkeit, dies zu tun. Der IN Der Operator ist besonders nützlich, wenn Sie eine lange Liste von Werten haben, mit denen Sie vergleichen möchten.
Der IN -Operator wird fast immer schneller ausgeführt als mehrere OR Operatoren, insbesondere bei größeren Datensätzen.
Ein weiterer Vorteil des IN Operator, ist, dass er ein weiteres SELECT enthalten kann aufführen. Dies wird als Unterabfrage bezeichnet . Eine Unterabfrage ist eine Abfrage, die in eine andere Abfrage (oder sogar eine andere Unterabfrage) eingebettet ist.
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 | +-------------+-----------+
Dieses Beispiel zeigt uns, wie viele Tierarten es in unserem Tierhotel gibt.
Wir könnten das NOT verwenden Bediener, um dies umzudrehen und zu sehen, wie viele Arten von Haustieren nicht sind in unserem Tierhotel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Ergebnis:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Unsere Datenbank enthält also eine Haustierart von Rabbit , aber wir haben derzeit keine Kaninchen als Haustiere.
Der + und || Zeichenfolgenverkettungsoperatoren
Das + und || Zeichenfolgenverkettungsoperatoren ermöglichen das Verketten von Zeichenfolgen. Die Zeichenfolgenverkettung ist der Vorgang, bei dem Zeichenfolgen von Ende zu Ende verbunden werden.
Der Grund, warum ich zwei Operatoren aufgelistet habe, die dasselbe tun, ist der + Operator wird in SQL Server unterstützt und der || Operator wird in DB2, Oracle, PostgreSQL, SQLite unterstützt.
Hier ist ein Beispiel, das in SQL Server funktioniert.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Ergebnis:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
In diesem Fall haben Besitzer ihren Vor- und Nachnamen in verschiedenen Spalten gespeichert. In unserem SELECT list, rufen wir diese zuerst einzeln ab, aber wir rufen sie auch noch einmal ab, indem wir einen Verkettungsoperator verwenden, um sie miteinander zu verbinden.
Es gibt jedoch ein paar Probleme mit unseren Ergebnissen.
- Zwischen dem Vor- und Nachnamen steht kein Leerzeichen.
- Es gibt keinen Spaltennamen.
Glücklicherweise ist dies leicht zu beheben.
Wir können die gleiche Verkettungsoperation verwenden, um Leerzeichen zwischen dem Vornamen und dem Nachnamen einzufügen.
Und wir können einen Spaltenalias für das verkettete Ergebnis verwenden, um einen Spaltennamen in der Ergebnismenge bereitzustellen.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Ergebnis:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Wenn Sie DB2, Oracle, PostgreSQL, SQLite verwenden, tauschen Sie + aus für || und es sollte gut funktionieren.
Wenn Sie MySQL oder MariaDB verwenden, müssen Sie CONCAT() verwenden Funktion zum Verketten von Strings.
Das LIKE Betreiber
Das LIKE -Operator ermöglicht Ihnen den Musterabgleich. Es bestimmt, ob eine bestimmte Zeichenfolge mit einem bestimmten Muster übereinstimmt. Ein Muster kann reguläre Zeichen und Platzhalterzeichen enthalten.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Ergebnis:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
In diesem Beispiel habe ich den LIKE verwendet Operator in Verbindung mit dem % Wildcard-Operator, um Eigentümer zurückzugeben, deren E-Mail-Adressen auf .com enden .
Bonusbetreiber! Der % Wildcard-Operator
Der % Platzhalteroperator passt auf eine beliebige Zeichenfolge mit null oder mehr Zeichen. Es kann entweder als Präfix oder Suffix verwendet werden, und es kann auch in der Mitte einer Zeichenfolge verwendet werden.
Es wird häufiger als Suffix verwendet und hat eine begrenzte Verwendung in der Mitte von Mustern, obwohl es einige gültige Anwendungsfälle für die Verwendung in der Mitte eines Musters gibt, wie z. B. die folgenden:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Ergebnis:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
In diesem Fall kannten wir die E-Mail-Adresse von Bart nicht, aber wir wussten, dass sie mit [email protected] begann und endete mit .com . Daher konnten wir LIKE verwenden in Verbindung mit dem % Wildcard-Operator, um den Rest auszufüllen.
Denken Sie daran, dass diese Technik viele irrelevante Zeilen zurückgeben kann, abhängig von den Daten und davon, wie Sie Ihre SQL-Anweisung aufbauen.
Beachten Sie auch, dass Abfragen, die den LIKE enthalten -Klausel kann viel langsamer als andere Abfragen ausgeführt werden, und Sie sollten wahrscheinlich die Verwendung von LIKE vermeiden Klausel, es sei denn, Sie brauchen es wirklich. Verwenden Sie den % Operator als Präfix kann besonders langsam sein.
Das heißt nicht, dass Sie es überhaupt nicht verwenden sollten. Das LIKE Operator ist ein integraler Bestandteil von SQL, und Sie werden auf viele Szenarien stoßen, in denen dies die einzige Option (oder zumindest die beste Option) sein wird.
Weitere SQL-Operatoren
Siehe meine vollständige Liste der SQL-Operatoren für eine ganze Reihe anderer Operatoren, die hier nicht enthalten sind.
