I SQL är en operator ett specialtecken eller nyckelord som anger en åtgärd som utförs på ett eller flera uttryck.
SQL-operatorer är en integrerad del av SQL, och de gör det möjligt för oss att skriva frågor som ger relevanta resultat.
I den här artikeln presenterar jag 12 av de vanligaste SQL-operatorerna när jag skriver SQL-frågor.
The Equals (= ) Operatör
Operatorn Equals (= ) är förmodligen den mest använda operatorn i SQL. Den jämför likheten mellan två uttryck. Även om du inte är mer än vagt bekant med SQL, kommer du förmodligen att känna till den här operatorn.
Föreställ dig att vi har en databas för ett djurhotell och vi vill få information om alla husdjur som heter Fluffy.
I så fall kan vi göra så här:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Vår fråga använder operatorn Equals (= ) för att jämföra likheten mellan värdet på PetName kolumn och strängen Fluffy .
I vårt fall kan vi se att djurhotellet för närvarande har två husdjur som heter Fluffy.
Desto större än (> ) Operatör
Operatorn Större än (> ) jämför två uttryck och returnerar TRUE om den vänstra operanden har ett värde högre än den högra operanden; annars blir resultatet FALSE .
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 det här fallet är det att jämföra värdet på DOB kolumnen och datumet 2020-01-01 för att se om DOB kolumnen är större.
Det mindre än (< ) Operatör
Operatorn Less Than (< ) gör tvärtom. Den jämför två uttryck och returnerar TRUE om den vänstra operanden har ett lägre värde än den högra operanden; annars blir resultatet FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Ju större än eller lika med (>= ) Operatör
Operatorn större än eller lika med (>= ) jämför två uttryck och returnerar TRUE om den vänstra operanden har ett värde större än eller lika med den högra operanden; annars returnerar den FALSE .
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 | +-----------+------------+
Observera att den returnerade 2020-09-17 och alla datum större än så. Om vi hade använt Greater Than-operatorn (> ), endast de två första raderna skulle ha returnerats.
Ju mindre än eller lika med (<= ) Operatör
Operatorn Mindre än eller lika med (<= ) jämför två uttryck och returnerar TRUE om den vänstra operanden har ett värde som är lägre än eller lika med den högra operanden; annars blir resultatet FALSE .
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 | +-----------+------------+
Observera att den returnerade 2020-09-17 och alla datum mindre än så. Om vi hade använt operatorn Less Than (< ), endast de tre första raderna skulle ha returnerats.
AND Operatör
OCH operatorn kombinerar två booleska uttryck och returnerar TRUE när båda uttrycken är TRUE .
Här är ett exempel.
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 det här fallet får vi bara information om husdjuren där deras namn är Fluffy och deras födelsedatum ligger mellan de två datumen.
ELLER Operatör
ELLER operatorn kombinerar två booleska uttryck och returnerar TRUE när något av villkoren är TRUE .
Här är ett exempel.
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 | +---------+-----------+------------+
Detta är i princip motsatsen till AND operatör. Om vi hade använt AND , inga rader skulle ha returnerats, eftersom vi inte kan ha två olika värden i en kolumn samtidigt.
MELLAN Operatör
BETWEEN operatör tillåter oss att ange ett intervall att testa. Till exempel kan vi använda den för att lämna tillbaka husdjur som är födda mellan två datum.
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 operatorn negerar en boolesk indata (den vänder värdet på valfritt booleskt uttryck). Returnerar därför TRUE när uttrycket är FALSE .
Det här är vad som händer när vi lägger till NOT operatör till vårt tidigare exempel.
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 | +-----------+------------+
Den här gången fick vi alla andra husdjur – husdjuren som inte var född mellan dessa datum.
I MariaDB, NOT är begränsad till att negera IN , MELLAN och FINNS klausuler. De flesta andra DBMS tillåter NOT för att förneka alla uttryck.
IN Operatör
IN operatorn bestämmer om ett angivet värde matchar något värde i en underfråga eller en lista.
Här är ett exempel.
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 skulle kunna uppnå samma resultat genom att använda två ELLER operatörer:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Men IN operatör är ett mer kortfattat sätt att göra det på. IN operatören är särskilt fördelaktig när du har en lång lista med värden att jämföra med.
IN operatorn körs nästan alltid snabbare än flera ELLER operatörer, särskilt på större datamängder.
En annan fördel med IN operatorn, är att den kan innehålla en annan SELECT lista. Detta är känt som en underfråga . En underfråga är en fråga som är kapslad i en annan fråga (eller till och med en annan underfråga).
Här är ett exempel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Det här exemplet visar hur många husdjurstyper som finns på vårt djurhotell.
Vi skulle kunna använda NOT operatören att vända på detta och se hur många husdjurstyper som inte är i vårt djurhotell.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Så vår databas innehåller en husdjurstyp av Kanin , men vi har för närvarande inga kaniner som husdjur.
+ och || Strängsammansättningsoperatorer
+ och || strängsammansättningsoperatorer låter dig sammanfoga strängar. Strängsammansättning är operationen att sammanfoga teckensträngar ände till ände.
Anledningen till att jag har listat två operatorer som gör samma sak är att + operatorn stöds i SQL Server, och || operatorn stöds i DB2, Oracle, PostgreSQL, SQLite.
Här är ett exempel som fungerar 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 det här fallet har ägare sitt förnamn och efternamn lagrade i olika kolumner. I vår SELECT listan hämtar vi först dem individuellt, men vi hämtar dem också igen, genom att använda en sammanlänkningsoperator för att sammanfoga dem.
Det finns dock ett par problem med våra resultat.
- Det finns inget mellanslag mellan för- och efternamn.
- Det finns inget kolumnnamn.
Lyckligtvis är detta lätt att fixa.
Vi kan använda samma sammanlänkningsoperation för att inkludera mellanslag mellan förnamn och efternamn.
Och vi kan använda ett kolumnalias till det sammanlänkade resultatet för att tillhandahålla ett kolumnnamn i resultatuppsättningen.
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 | +-------------+------------+---------------+
Om du använder DB2, Oracle, PostgreSQL, SQLite, byt ut + för || och det borde fungera bra.
Om du använder MySQL eller MariaDB måste du använda CONCAT() funktion för att sammanfoga strängar.
LIKE Operatör
LIKE operatorn låter dig göra mönstermatchning. Det avgör om en specifik teckensträng matchar ett specificerat mönster. Ett mönster kan innehålla vanliga tecken och jokertecken.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Resultat:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
I det här exemplet använde jag LIKE operatorn i kombination med % jokerteckenoperatör för att returnera ägare vars e-postadresser slutar på .com .
Bonusoperatör! % Jokertecken-operatör
% jokerteckenoperator matchar en sträng med noll eller fler tecken. Det kan användas som antingen ett prefix eller ett suffix, och det kan också användas i mitten av en sträng.
Det tenderar att användas oftare som ett suffix, och det har begränsad användning i mitten av mönster, även om det finns några giltiga användningsfall för att använda det i mitten av ett mönster, till exempel följande:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Resultat:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
I det här fallet kände vi inte till barts e-postadress, men vi visste att det började med [email protected] och slutade med .com . Därför kunde vi använda LIKE i kombination med % jokerteckenoperatör för att fylla i resten.
Tänk på att den här tekniken kan returnera många irrelevanta rader, beroende på data och hur du konstruerar din SQL-sats.
Tänk också på att frågor som innehåller LIKE klausulen kan köras mycket långsammare än andra frågor, och du bör förmodligen undvika att använda LIKE klausul om du inte verkligen behöver det. Med hjälp av % operator som prefix kan vara särskilt långsam.
Därmed inte sagt att du inte ska använda det alls. LIKE operatör är en integrerad del av SQL, och du kommer att stöta på många scenarier där det kommer att vara det enda alternativet (eller åtminstone det bästa alternativet).
Fler SQL-operatörer
Se min fullständiga lista över SQL-operatorer för en hel massa andra operatorer som inte ingår här.