Gli operatori di confronto sono una parte importante della maggior parte dei linguaggi di programmazione.
Gli operatori di confronto vengono utilizzati per confrontare due espressioni. Il risultato è true o falso . Potrebbe anche essere sconosciuto. Questo potrebbe anche essere rappresentato da 1 , 0 o NULL , a seconda della lingua. Questi sono generalmente conosciuti come "espressioni booleane".
Se utilizzati con i database, gli operatori di confronto possono essere utilizzati all'interno delle query SQL per filtrare i dati in base a determinati criteri.
Operatori di confronto comuni
La maggior parte dei linguaggi di programmazione supporta i seguenti operatori di confronto in una forma o nell'altra:
| OPERATORE | SIGNIFICATO |
|---|---|
= | Uguale a |
> | Maggiore di |
< | Meno di |
>= | Maggiore o uguale a |
<= | Inferiore o uguale a |
<> | Non uguale a |
SQL utilizza la stessa sintassi elencata nella tabella precedente.
Alcuni linguaggi utilizzano una sintassi diversa per evitare confusione con gli operatori di assegnazione. Ad esempio, Python e JavaScript usano == invece di = . ColdFusion d'altra parte, usa eq .
Diversi tipi di dati
Alcune lingue hanno un operatore speciale per specificare che entrambi i valori devono essere dello stesso tipo di dati.
Ad esempio, JavaScript include anche === operatore che specifica che entrambi i valori sono uguali e che devono essere dello stesso tipo di dati. Ma se il tipo di dati è irrilevante, usa == invece.
Esempi
Maggiore dell'operatore
Ecco un esempio di utilizzo dell'operatore Maggiore di in una query T-SQL.
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;Risultato:
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
In questo esempio ho utilizzato l'operatore Maggiore di (> ) per selezionare solo i paesi con una popolazione superiore a 100000000.
Uguale all'operatore
Ecco un altro esempio, in cui utilizzo l'operatore di uguale (= ) per restituire dati esattamente uguali a un determinato valore.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Risultato:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
In questo caso restituisco solo quelle città il cui prefisso nazionale è uguale a AFG .
Ciò dimostra che gli operatori di confronto non si limitano ai tipi di dati numerici.
Date
Puoi anche utilizzare gli operatori di confronto sulle date, ad esempio:
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';Risultato:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | +------------+----------------+--------------+
Come puoi vedere, gli unici risultati restituiti sono quelli maggiori di (dopo) la data specificata.
Maggiore o uguale a Operatore
Posso utilizzare l'operatore Maggiore di o Uguale a per includere la data specificata nei risultati.
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';Risultato:
+------------+----------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+----------------+--------------| | 5 | Devin Townsend | 1993-01-01 | | 8 | Maroon 5 | 1994-01-01 | | 9 | The Script | 2001-01-01 | | 14 | Karnivool | 1997-01-01 | | 15 | Birds of Tokyo | 2004-01-01 | | 16 | Bodyjar | 1990-01-01 | +------------+----------------+--------------+
In questo caso, viene restituita una riga in più (l'ultima riga).
Meno di Operatore
Ecco cosa succede se cambio la mia query per utilizzare un operatore Minore di.
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';Risultato:
+------------+------------------------+--------------+ | ArtistId | ArtistName | ActiveFrom | |------------+------------------------+--------------| | 1 | Iron Maiden | 1975-12-25 | | 2 | AC/DC | 1973-01-11 | | 3 | Allan Holdsworth | 1969-01-01 | | 4 | Buddy Rich | 1919-01-01 | | 6 | Jim Reeves | 1948-01-01 | | 7 | Tom Jones | 1963-01-01 | | 10 | Lit | 1988-06-26 | | 11 | Black Sabbath | 1968-01-01 | | 12 | Michael Learns to Rock | 1988-03-15 | | 13 | Carabao | 1981-01-01 | +------------+------------------------+--------------+
Ottengo tutte le righe inferiori alla data specificata.
Confronto dei valori NULL
NULLO i valori possono complicare leggermente le cose quando si utilizzano gli operatori di confronto. In poche parole, potresti ottenere un risultato diverso, a seconda di come è configurato il tuo ambiente.
Ad esempio, in SQL Server, se si utilizza l'operatore Uguale (= ) o l'operatore Diverso (<> ) per testare con NULL , il tuo risultato dipenderà dal tuo ANSI_NULLS impostazione (ovvero se è ON o OFF ).
Per testare contro NULL valori, SQL Server fornisce anche IS NULL predicato, che funziona in modo coerente, indipendentemente dal tuo ANSI_NULLS collocamento. Questo include anche il IS NOT NULL variazione per il test rispetto a NULL non NULL valori.
Di seguito è riportato un esempio che dimostra cosa intendo.
ANSI_NULLS ATTIVO
Per prima cosa impostiamo ANSI_NULLS su ON , quindi esegui alcuni test su NULL .
SET ANSI_NULLS ON;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Risultato:
(0 rows affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) (0 rows affected)
ANSI_NULLS OFF
Ora impostiamo ANSI_NULLS su OFF , quindi eseguire gli stessi test.
SET ANSI_NULLS OFF;
SELECT NULL
WHERE NULL = NULL;
SELECT NULL
WHERE 1 = NULL;
SELECT NULL
WHERE NULL IS NULL;
SELECT 'Not NULL'
WHERE 1 IS NOT NULL;
SELECT 'Not NULL'
WHERE 1 <> NULL;Risultato:
+--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) (0 rows affected) +--------------------+ | (No column name) | |--------------------| | NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected) +--------------------+ | (No column name) | |--------------------| | Not NULL | +--------------------+ (1 row affected)
