I SQL er en operator et specialtegn eller et nøgleord, der angiver en handling, der udføres på et eller flere udtryk.
SQL-operatorer er en integreret del af SQL, og de sætter os i stand til at skrive forespørgsler, der returnerer relevante resultater.
I denne artikel præsenterer jeg 12 af de mest brugte SQL-operatorer, når jeg skriver SQL-forespørgsler.
The Equals (= ) Operatør
Equals-operatoren (= ) er nok den mest brugte operator i SQL. Den sammenligner ligheden mellem to udtryk. Selvom du ikke er mere end vagt fortrolig med SQL, kender du sikkert denne operator.
Forestil dig, at vi har en database for et kæledyrshotel, og vi vil gerne have information om alle kæledyr ved navn Fluffy.
I så fald kunne vi gøre dette:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Vores forespørgsel bruger Equals-operatoren (= ) for at sammenligne ligheden mellem værdien af PetName kolonne og strengen Fluffy .
I vores tilfælde kan vi se, at dyrehotellet i øjeblikket har to kæledyr kaldet Fluffy.
Jo større end (> ) Operatør
Operatoren Greater Than (> ) sammenligner to udtryk og returnerer TRUE hvis venstre operand har en højere værdi end højre operand; ellers er resultatet FALSK .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
I dette tilfælde er det at sammenligne værdien af DOB kolonne og datoen 2020-01-01 for at se, om DOB kolonnen er større.
Det mindre end (< ) Operatør
Mindre end-operatoren (< ) gør det modsatte. Den sammenligner to udtryk og returnerer TRUE hvis venstre operand har en lavere værdi end højre operand; ellers er resultatet FALSK .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Jo større end eller lig med (>= ) Operatør
Operatoren større end eller lig med (>= ) sammenligner to udtryk og returnerer TRUE hvis venstre operand har en værdi større end eller lig med højre operand; ellers returnerer den FALSK .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Bemærk, at den returnerede 2020-09-17 og alle datoer større end det. Hvis vi havde brugt Greater Than-operatoren (> ), kun de to første rækker ville være blevet returneret.
Det mindre end eller lig med (<= ) Operatør
Operatoren Mindre end eller lig med (<= ) sammenligner to udtryk og returnerer TRUE hvis venstre operand har en værdi lavere end eller lig med højre operand; ellers er resultatet FALSK .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Bemærk, at den returnerede 2020-09-17 og alle datoer mindre end det. Hvis vi havde brugt Less Than-operatoren (< ), kun de første tre rækker ville være blevet returneret.
AND Operatør
AND operatoren kombinerer to booleske udtryk og returnerer TRUE når begge udtryk er TRUE .
Her er et eksempel.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Resultat:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
I dette tilfælde får vi kun detaljer om kæledyrene, hvor deres navn er Fluffy og deres fødselsdato er mellem de to datoer.
ELLER Operatør
ELLER operatoren kombinerer to booleske udtryk og returnerer TRUE når en af betingelserne er TRUE .
Her er et eksempel.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Dette er dybest set det modsatte af AND operatør. Hvis vi havde brugt AND , ingen rækker ville være blevet returneret, fordi vi ikke kan have to forskellige værdier i én kolonne på samme tid.
MELLEM Operatør
BETWEEN operatør giver os mulighed for at angive et interval, der skal testes. For eksempel kan vi bruge det til at returnere kæledyr, der er født mellem to datoer.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
NOT Operatør
NOT operator negerer et boolsk input (det vender værdien af ethvert boolsk udtryk). Returnerer derfor TRUE når udtrykket er FALSK .
Her er, hvad der sker, når vi tilføjer
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Denne gang fik vi alle de andre kæledyr – de kæledyr, der ikke var født mellem disse datoer.
I MariaDB, IKKE er begrænset til at negere IN , MELLEM , og FINDER klausuler. De fleste andre DBMS'er tillader NOT for at afvise ethvert udtryk.
IN Operatør
IN operatoren bestemmer, om en specificeret værdi matcher en værdi i en underforespørgsel eller en liste.
Her er et eksempel.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Vi kunne opnå det samme resultat ved at bruge to ELLER operatører:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Men IN operatør er en mere kortfattet måde at gøre det på. IN operator er især fordelagtig, når du har en lang liste af værdier, som du kan sammenligne med.
IN operator udfører næsten altid hurtigere end flere ELLER operatører, især på større datasæt.
En anden fordel ved IN operator, er, at den kan indeholde en anden SELECT liste. Dette er kendt som en underforespørgsel . En underforespørgsel er en forespørgsel, der er indlejret i en anden forespørgsel (eller endda en anden underforespørgsel).
Her er et eksempel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Dette eksempel viser os, hvor mange kæledyrstyper der er på vores kæledyrshotel.
Vi kunne bruge NOT operatør til at vende dette rundt og se, hvor mange kæledyrstyper der ikke er på vores dyrehotel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Så vores database indeholder en kæledyrstype Kanin , men vi har i øjeblikket ingen kaniner som kæledyr.
+ og || Strengsammenkædningsoperatorer
+ og || strengsammenkædningsoperatorer giver dig mulighed for at sammenkæde strenge. Strengsammenkædning er operationen med at forbinde tegnstrenge ende-til-ende.
Grunden til, at jeg har angivet to operatører, der gør det samme, er fordi + operatoren er understøttet i SQL Server, og || operator er understøttet i DB2, Oracle, PostgreSQL, SQLite.
Her er et eksempel, der fungerer i SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Resultat:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
I dette tilfælde har ejere deres fornavn og efternavn gemt i forskellige kolonner. I vores SELECT liste, henter vi først dem individuelt, men vi henter dem også igen ved at bruge en sammenkædningsoperator til at forbinde dem.
Der er dog et par problemer med vores resultater.
- Der er ingen mellemrum mellem for- og efternavne.
- Der er intet kolonnenavn.
Heldigvis er dette nemt at rette.
Vi kan bruge den samme sammenkædningsoperation til at inkludere mellemrum mellem fornavn og efternavn.
Og vi kan bruge et kolonnealias til det sammenkædede resultat for at give et kolonnenavn i resultatsættet.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Resultat:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Hvis du bruger DB2, Oracle, PostgreSQL, SQLite, skal du bytte + for || og det burde fungere fint.
Hvis du bruger MySQL eller MariaDB, skal du bruge CONCAT() funktion til at sammenkæde strenge.
LIKE Operatør
LIKE operatør giver dig mulighed for at lave mønstertilpasning. Det bestemmer, om en specifik tegnstreng matcher et specificeret mønster. Et mønster kan indeholde almindelige tegn og jokertegn.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Resultat:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
I dette eksempel brugte jeg LIKE operator sammen med % wildcard-operatør for at returnere ejere, hvis e-mailadresser ender på .com .
Bonusoperatør! % Wildcard-operatør
% wildcard-operator matcher enhver streng med nul eller flere tegn. Det kan bruges som enten et præfiks eller et suffiks, og det kan også bruges i midten af en streng.
Det plejer at være mere almindeligt brugt som et suffiks, og det har begrænset brug i midten af mønstre, selvom der er nogle gyldige use-cases for at bruge det i midten af et mønster, såsom følgende:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Resultat:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
I dette tilfælde kendte vi ikke barts e-mailadresse, men vi vidste, at det startede med [email protected] og endte med .com . Derfor var vi i stand til at bruge LIKE i forbindelse med % wildcard-operatør for at udfylde resten.
Husk på, at denne teknik kan returnere en masse irrelevante rækker, afhængigt af dataene, og hvordan du konstruerer din SQL-sætning.
Vær også opmærksom på, at forespørgsler, der indeholder LIKE klausulen kan køre meget langsommere end andre forespørgsler, og du bør nok undgå at bruge LIKE klausul, medmindre du virkelig har brug for det. Ved hjælp af % operator som præfiks kan være særlig langsom.
Dermed ikke sagt, at du slet ikke skal bruge det. LIKE operatør er en integreret del af SQL, og du vil støde på mange scenarier, hvor det vil være den eneste mulighed (eller i det mindste den bedste mulighed).
Flere SQL-operatører
Se min fulde liste over SQL-operatører for en hel masse andre operatører, der ikke er inkluderet her.