In SQL is een operator een speciaal teken of trefwoord dat een actie specificeert die wordt uitgevoerd op een of meer expressies.
SQL-operators zijn een integraal onderdeel van SQL en stellen ons in staat om query's te schrijven die relevante resultaten opleveren.
In dit artikel presenteer ik 12 van de meest gebruikte SQL-operators bij het schrijven van SQL-query's.
De gelijken (= ) Operator
De operator is gelijk aan (= ) is waarschijnlijk de meest gebruikte operator in SQL. Het vergelijkt de gelijkheid van twee uitdrukkingen. Zelfs als je niet meer dan vaag bekend bent met SQL, ken je deze operator waarschijnlijk wel.
Stel je voor dat we een database hebben voor een huisdierenhotel en dat we informatie willen hebben over alle huisdieren met de naam Fluffy.
In dat geval zouden we dit kunnen doen:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultaat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Onze zoekopdracht maakt gebruik van de Equals-operator (= ) om de gelijkheid van de waarde van de PetName . te vergelijken kolom en de tekenreeks Fluffy .
In ons geval kunnen we zien dat het dierenhotel momenteel twee huisdieren heeft, genaamd Fluffy.
Het Groter Dan (> ) Operator
De operator groter dan (> ) vergelijkt twee uitdrukkingen en retourneert TRUE als de linker operand een hogere waarde heeft dan de rechter operand; anders is het resultaat FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
In dit geval vergelijkt het de waarde van de DOB kolom en de datum 2020-01-01 om te zien of de DOB kolom is groter.
De minder dan (< ) Operator
De operator Klein dan (< ) doet het tegenovergestelde. Het vergelijkt twee uitdrukkingen en retourneert TRUE als de linker operand een waarde heeft die lager is dan de rechter operand; anders is het resultaat FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Groter dan of gelijk aan (>= ) Operator
De operator groter dan of gelijk aan (>= ) vergelijkt twee uitdrukkingen en retourneert TRUE als de linker operand een waarde heeft die groter is dan of gelijk is aan de rechter operand; anders retourneert het FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Merk op dat het 2020-09-17 returned heeft geretourneerd en alle data groter dan dat. Als we de operator Groter dan hadden gebruikt (> ), zouden alleen de eerste twee rijen zijn geretourneerd.
Minder dan of gelijk aan (<= ) Operator
De operator Kleiner dan of gelijk aan (<= ) vergelijkt twee uitdrukkingen en retourneert TRUE als de linker operand een waarde heeft die lager is dan of gelijk is aan de rechter operand; anders is het resultaat FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Merk op dat het 2020-09-17 returned heeft geretourneerd en alle data minder dan dat. Als we de operator Kleiner dan hadden gebruikt (< ), zouden alleen de eerste drie rijen zijn geretourneerd.
De AND Operator
De AND operator combineert twee Booleaanse expressies en retourneert TRUE wanneer beide uitdrukkingen TRUE zijn .
Hier is een voorbeeld.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Resultaat:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
In dit geval krijgen we alleen details van de huisdieren met de naam Fluffy en hun geboortedatum ligt tussen de twee data.
De OR Operator
De OR operator combineert twee Booleaanse expressies en retourneert TRUE wanneer een van de voorwaarden TRUE . is .
Hier is een voorbeeld.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Resultaat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Dit is eigenlijk het tegenovergestelde van de AND exploitant. Als we AND . hadden gebruikt , zouden er geen rijen zijn geretourneerd, omdat we niet tegelijkertijd twee verschillende waarden in één kolom kunnen hebben.
De BETWEEN Operator
De BETWEEN operator stelt ons in staat om een bereik op te geven om te testen. We kunnen het bijvoorbeeld gebruiken om huisdieren terug te sturen die tussen twee datums zijn geboren.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
De NOT Operator
De NOT operator negeert een Booleaanse invoer (het keert de waarde van elke Booleaanse uitdrukking om). Retourneert daarom TRUE wanneer de uitdrukking FALSE . is .
Dit is wat er gebeurt als we de NOT . toevoegen operator naar ons vorige voorbeeld.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Deze keer hebben we alle andere huisdieren - de huisdieren die niet waren geboren tussen die data.
In MariaDB, NOT is beperkt tot het negeren van de IN , BETWEEN , en EXISTS clausules. De meeste andere DBMS'en staan NOT toe om elke uitdrukking te ontkennen.
De IN Operator
De IN operator bepaalt of een opgegeven waarde overeenkomt met een waarde in een subquery of een lijst.
Hier is een voorbeeld.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Resultaat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
We zouden hetzelfde resultaat kunnen bereiken door twee OR . te gebruiken operators:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Echter, de IN operator is een beknoptere manier om dit te doen. De IN operator is vooral handig als u een lange lijst met waarden hebt waarmee u kunt vergelijken.
De IN operator voert bijna altijd sneller uit dan meerdere OR operators, vooral bij grotere datasets.
Een ander voordeel van de IN operator, is dat het een andere SELECT . kan bevatten lijst. Dit staat bekend als een subquery . Een subquery is een query die is genest in een andere query (of zelfs een andere subquery).
Hier is een voorbeeld.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultaat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Dit voorbeeld laat ons zien hoeveel soorten huisdieren er in ons dierenhotel zijn.
We zouden de NOT . kunnen gebruiken operator om dit om te draaien en te zien hoeveel soorten huisdieren niet zijn in ons dierenhotel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Resultaat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Onze database bevat dus een huisdiertype Rabbit , maar we hebben momenteel geen konijnen als huisdier.
De + en || Tekenreeksaaneenschakelingsoperators
De + en || tekenreeksaaneenschakelingsoperatoren stellen u in staat om tekenreeksen samen te voegen. Aaneenschakeling van tekenreeksen is het samenvoegen van tekenreeksen van begin tot eind.
De reden dat ik twee operators heb genoemd die hetzelfde doen, is omdat de + operator wordt ondersteund in SQL Server, en de || operator wordt ondersteund in DB2, Oracle, PostgreSQL, SQLite.
Hier is een voorbeeld dat werkt in SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Resultaat:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
In dit geval hebben eigenaren hun voornaam en achternaam in verschillende kolommen opgeslagen. In onze SELECT lijst, halen we die eerst afzonderlijk op, maar we halen ze ook weer op, met behulp van een concatenatie-operator om ze samen te voegen.
Er zijn echter een aantal problemen met onze resultaten.
- Er is geen spatie tussen de voor- en achternaam.
- Er is geen kolomnaam.
Gelukkig is dit eenvoudig op te lossen.
We kunnen dezelfde aaneenschakeling gebruiken om spatie tussen de voornaam en achternaam op te nemen.
En we kunnen een kolomalias gebruiken voor het aaneengeschakelde resultaat om een kolomnaam in de resultatenset op te geven.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Resultaat:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Als u DB2, Oracle, PostgreSQL, SQLite gebruikt, verwissel dan de + voor || en het zou goed moeten werken.
Als u MySQL of MariaDB gebruikt, moet u de CONCAT() gebruiken functie om strings samen te voegen.
De LIKE Operator
De LIKE operator stelt u in staat om patroonafstemming uit te voeren. Het bepaalt of een specifieke tekenreeks overeenkomt met een bepaald patroon. Een patroon kan gewone tekens en jokertekens bevatten.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Resultaat:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
In dit voorbeeld heb ik de LIKE . gebruikt operator in combinatie met de % wildcard-operator om eigenaren te retourneren wiens e-mailadres eindigt op .com .
Bonusoperator! De % Wildcard-operator
De % jokertekenoperator komt overeen met elke tekenreeks van nul of meer tekens. Het kan worden gebruikt als voorvoegsel of achtervoegsel, en het kan ook in het midden van een tekenreeks worden gebruikt.
Het wordt meestal als achtervoegsel gebruikt en wordt in beperkte mate gebruikt in het midden van patronen, hoewel er enkele geldige gebruiksscenario's zijn om het in het midden van een patroon te gebruiken, zoals de volgende:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Resultaat:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
In dit geval wisten we het e-mailadres van Bart niet, maar we wisten dat het begon met [email protected] en eindigde op .com . Daarom konden we LIKE . gebruiken in combinatie met de % wildcard-operator om de rest in te vullen.
Houd er rekening mee dat deze techniek veel irrelevante rijen kan retourneren, afhankelijk van de gegevens en hoe u uw SQL-instructie opstelt.
Houd er ook rekening mee dat zoekopdrachten die de LIKE . bevatten clausule kan veel langzamer worden uitgevoerd dan andere zoekopdrachten, en u moet waarschijnlijk het gebruik van de LIKE . vermijden clausule tenzij je het echt nodig hebt. De % . gebruiken operator als voorvoegsel kan bijzonder traag zijn.
Dat wil niet zeggen dat je het helemaal niet moet gebruiken. De LIKE operator is een integraal onderdeel van SQL en u zult veel scenario's tegenkomen waarin dit de enige optie is (of op zijn minst de beste optie).
Meer SQL-operators
Bekijk mijn volledige lijst met SQL-operators voor een hele reeks andere operators die hier niet zijn opgenomen.