Operatory porównania są ważną częścią większości języków programowania.
Operatory porównania służą do porównywania dwóch wyrażeń. Wynik jest albo true lub false . Może też być nieznany. Może to być również reprezentowane przez 1 , 0 lub NULL , w zależności od języka. Są one zwykle znane jako „wyrażenia logiczne”.
W przypadku użycia z bazami danych operatory porównania mogą być używane w zapytaniach SQL do filtrowania danych według określonych kryteriów.
Typowe operatory porównania
Większość języków programowania obsługuje następujące operatory porównania w takiej czy innej formie:
| OPERATOR | ZNACZENIE |
|---|---|
= | Równe |
> | Większe niż |
< | Mniej niż |
>= | Większe lub równe |
<= | Mniejsze lub równe |
<> | Nie równa |
SQL używa tej samej składni, jak wymieniono w powyższej tabeli.
Niektóre języki używają innej składni, aby uniknąć pomyłek z operatorami przypisania. Na przykład Python i JavaScript używają == zamiast = . Z drugiej strony ColdFusion używa eq .
Różne typy danych
Niektóre języki mają specjalny operator określający, że obie wartości muszą być tego samego typu danych.
Na przykład JavaScript zawiera również === operator, który określa, że obie wartości są równe i muszą być tego samego typu danych. Ale jeśli typ danych jest nieistotny, użyj == zamiast.
Przykłady
Większy niż operator
Oto przykład użycia operatora Większe niż w zapytaniu T-SQL.
SELECT Name, Population
FROM country
WHERE Population > 100000000
ORDER BY Population DESC;Wynik:
+--------------------+--------------+ | Name | Population | |--------------------+--------------| | China | 1277558000 | | India | 1013662000 | | United States | 278357000 | | Indonesia | 212107000 | | Brazil | 170115000 | | Pakistan | 156483000 | | Russian Federation | 146934000 | | Bangladesh | 129155000 | | Japan | 126714000 | | Nigeria | 111506000 | +--------------------+--------------+
W tym przykładzie użyłem operatora Większe niż (> ), aby wybrać tylko kraje o liczbie ludności większej niż 100000000.
Równa operatorowi
Oto kolejny przykład, w którym używam operatora równości (= ), aby zwrócić dane, które są dokładnie równe podanej wartości.
SELECT CountryCode, Name
FROM city
WHERE CountryCode = 'AFG'Wynik:
+---------------+----------------+ | CountryCode | Name | |---------------+----------------| | AFG | Kabul | | AFG | Qandahar | | AFG | Herat | | AFG | Mazar-e-Sharif | +---------------+----------------+
W tym przypadku zwracam tylko te miasta, których kod kraju jest równy AFG .
To pokazuje, że operatory porównania nie ograniczają się tylko do liczbowych typów danych.
Daty
Możesz także użyć operatorów porównania w datach, na przykład:
SELECT * FROM Artists
WHERE ActiveFrom > '1990-01-01';Wynik:
+------------+----------------+--------------+ | 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 | +------------+----------------+--------------+
Jak widać, jedyne zwracane wyniki to te większe niż (po) określonej dacie.
Większe niż lub równe operatorowi
Mogę użyć operatora Większe niż lub Równe do, aby uwzględnić określoną datę w wynikach.
SELECT * FROM Artists
WHERE ActiveFrom >= '1990-01-01';Wynik:
+------------+----------------+--------------+ | 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 | +------------+----------------+--------------+
W takim przypadku zwracany jest jeden dodatkowy wiersz (ostatni).
Mniej niż operator
Oto, co się stanie, jeśli zmienię zapytanie tak, aby używało operatora mniej niż.
SELECT * FROM Artists
WHERE ActiveFrom < '1990-01-01';Wynik:
+------------+------------------------+--------------+ | 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 | +------------+------------------------+--------------+
Otrzymuję wszystkie wiersze, które są krótsze niż określona data.
Porównywanie wartości NULL
NULL wartości mogą nieco komplikować sprawy podczas korzystania z operatorów porównania. Krótko mówiąc, możesz uzyskać inny wynik, w zależności od konfiguracji twojego środowiska.
Na przykład w SQL Server, jeśli używasz operatora Equals (= ) lub operator Nie równe (<> ), aby przetestować pod kątem NULL , Twój wynik będzie zależał od Twojego ANSI_NULLS ustawienie (tzn. czy jest ON lub OFF ).
Aby przetestować z NULL wartości, SQL Server zapewnia również IS NULL predykat, który działa konsekwentnie, niezależnie od Twojego ANSI_NULLS ustawienie. Obejmuje to również IS NOT NULL odmiana do testowania pod kątem NULL wartości.
Poniżej znajduje się przykład, który pokazuje, o co mi chodzi.
ANSI_NULLS ON
Najpierw ustawiamy ANSI_NULLS na ON , a następnie uruchom kilka testów przeciwko 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;Wynik:
(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
Teraz ustawiamy ANSI_NULLS na OFF , a następnie uruchom te same testy.
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;Wynik:
+--------------------+ | (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)
