Не равно в sql: != (не равно) (Transact-SQL) — SQL Server

Содержание

Операторы сравнения MySQL — Oracle PL/SQL •MySQL •MariaDB •SQL Server •SQLite

В этом учебном пособии описаны все операторы сравнения, используемые для проверки равенства и неравенства, а также более продвинутые операторы.

Описание

Операторы сравнения используются в предложении WHERE, чтобы определить, какие записи выбрать. Вот список операторов сравнения, которые вы можете использовать в MySQL:

Операторы сравнения	Описание
=	Равно
	Равно (безопасное сравнение значения NULL)
, !=	Не равно
>	Больше, чем
>=	Больше или равно
	Меньше, чем
	Меньше или равно
IN ( )	Соответствует значению в списке
NOT	Отрицает условие
BETWEEN	В пределах диапазона (включительно)
IS NULL	Значение NULL
IS NOT NULL	Значение, не NULL
LIKE	Соответствие шаблону % и _
EXISTS	Условие выполняется, если подзапрос возвращает хотя бы одну строку

Рассмотрим примеры операторов сравнения, которые вы можете использовать в MySQL.

Пример оператора равенства

В MySQL вы можете использовать оператор = для проверки равенства в запросе. Оператор может проверять только равенство со значениями, которые не являются NULL.
Например:

SELECT *
FROM contacts
WHERE last_name = ‘Bernard’;

SELECT *

FROM contacts

WHERE last_name = ‘Bernard’;

В этом примере оператора SELECT, возвращает все строки из таблицы contacts, где last_name равно Bernard.

Пример оператора равенства (безопасный с нулевыми значениями)

Поскольку оператор = только сравнивает значения, отличные от NULL, использовать значения NULL небезопасно. Чтобы преодолеть это ограничение, MySQL добавил оператор, чтобы вы могли проверить равенство как со значениями NULL, так и с не NULL значениями.

Чтобы лучше объяснить разницу между оператором = и оператором , мы будем включать некоторые примеры как с запросами, так и с данными.

Предполагая, что у нас в MySQL есть таблица, называемая contacts, которая заполнена следующими данными:

contact_id	last_name	site1	site2
1	Arnold	alexa.com
2	Gypsie
3	Boyson	bing.com	bing.com
4	Juan	google.ru	google.com

Мы могли бы использовать оператор = в следующем запросе:

SELECT *
FROM contacts
WHERE site1 = site2;

SELECT *

FROM contacts

WHERE site1 = site2;

Получим следующий результат:

contact_id	last_name	site1	site2
3	Boyson	bing.com	bing.com

В вышеприведенном примере оператор SELECT возвращает все строки из таблицы contacts, где site1 равен site2. Он не возвращает вторую запись, в которой значения site1 и site2 имеют значения NULL.

Теперь давайте посмотрим, что произойдет, когда мы перепишем наш запрос с помощью оператора , который безопасен для использования со значениями NULL:

SELECT *
FROM contacts
WHERE site1 <=> site2;

SELECT *

FROM contacts

WHERE site1 <=> site2;

Поскольку мы используем оператор , мы получим следующий результат:

contact_id	last_name	site1	site2
2	Gypsie
3	Boyson	bing.com	bing.com

Теперь наш запрос возвращает все строки из таблицы contacts, где site1 равен site2, включая те записи, где site1 и site2 имеют значения NULL.

Пример оператора неравенства

В MySQL вы можете использовать операторы или !=. Для проверки неравенства в запросе.

Например, мы могли бы проверить неравенство с помощью оператора следующим образом:

SELECT *
FROM contacts
WHERE last_name <> ‘Bernard’;

SELECT *

FROM contacts

WHERE last_name <> ‘Bernard’;

В этом примере оператор SELECT вернет все строки из таблицы contacts, где last_name не равно Bernard.

Или вы также можете написать этот запрос с помощью оператора != следующим образом:

SELECT *
FROM contacts
WHERE last_name != ‘Bernard’;

SELECT *

FROM contacts

WHERE last_name != ‘Bernard’;

Оба этих запроса возвратят одинаковые результаты.

Пример оператора >

Вы можете использовать оператор > в MySQL для проверки выражения «более чем».

SELECT *
FROM contacts
WHERE contact_id > 20;

SELECT *

FROM contacts

WHERE contact_id > 20;

В этом примере оператор SELECT будет возвращать все строки из таблицы contacts, где contact_id больше 20. В набор результатов не будет включен contact_id, равный 20.

Пример оператора >=

В MySQL вы можете использовать оператор >= для проверки выражения, «больше или равно».

SELECT *
FROM contacts
WHERE contact_id >= 20;

SELECT *

FROM contacts

WHERE contact_id >= 20;

В этом примере оператор SELECT вернет все строки из таблицы contacts, где contact_id больше или равен 20. В этом случае contact_id равный 20, будет включен в результирующий набор.

Пример оператора

Вы можете использовать оператор

SELECT *
FROM contacts
WHERE contact_id < 150;

SELECT *

FROM contacts

WHERE contact_id < 150;

В этом примере оператор SELECT вернет все строки из таблицы contacts, где contact_id меньше 150. contact_id равный 150, не будет включен в результирующий набор.

Пример оператора

В MySQL вы можете использовать оператор

SELECT *
FROM contacts
WHERE contact_id <= 150;

SELECT *

FROM contacts

WHERE contact_id <= 150;

В этом примере оператор SELECT вернет все строки из таблицы contacts, где contact_id меньше или равно 150. В этом случае product_id, равный 150, будет включен в результирующий набор.

PostgreSQL : Документация: 14: 9.2. Функции и операторы сравнения : Компания Postgres Professional

Набор операторов сравнения включает обычные операторы, перечисленные в Таблице 9.1.

Таблица 9.1. Операторы сравнения

Оператор	Описание
`тип_данных` `<` `тип_данных` → `boolean`	Меньше
`тип_данных` `>` `тип_данных` → `boolean`	Больше
`тип_данных` `<=` `тип_данных` → `boolean`	Меньше или равно
`тип_данных` `>=` `тип_данных` → `boolean`	Больше или равно
`тип_данных` `=` `тип_данных` → `boolean`	Равно
`тип_данных` `<>` `тип_данных` → `boolean`	Не равно
`тип_данных` `!=` `тип_данных` → `boolean`	Не равно

Примечание

В стандарте SQL для условия «не равно» принята запись <>. Синонимичная ей запись != преобразуется в <> на самой ранней стадии разбора запроса. Как следствие, реализовать операторы != и <> так, чтобы они работали по-разному, невозможно.

Эти операторы сравнения имеются для всех встроенных типов данных, значения которых сортируются естественным образом, включая числовые, строковые типы, а также типы даты/времени. Кроме того, сравниваться могут массивы, составные типы и диапазоны, если типы данных их компонентов являются сравниваемыми.

Обычно можно сравнивать также значения связанных типов данных; например, возможно сравнение integer > bigint. Некоторые подобные операции реализуются непосредственно «межтиповыми» операторами сравнения, но если такого оператора нет, анализатор запроса попытается привести частные типы к более общим и применить подходящий для них оператор сравнения.

Как показано выше, все операторы сравнения являются бинарными и возвращают значения типа boolean. Таким образом, выражения вида 1 < 2 < 3 недопустимы (так как не существует оператора <, который бы сравнивал булево значение с 3). Для проверки нахождения значения в интервале, воспользуйтесь предикатом BETWEEN, описанным ниже.

Существует также несколько предикатов сравнения; они приведены в Таблице 9.2. Они работают подобно операторам, но имеют особый синтаксис, установленный стандартом SQL.

Таблица 9.2. Предикаты сравнения

Предикат Описание Пример(ы)
`тип_данных` `BETWEEN` `тип_данных` `AND` `тип_данных` → `boolean` Между (включая границы интервала). `2 BETWEEN 1 AND 3` → `t` `2 BETWEEN 3 AND 1` → `f`
`тип_данных` `NOT BETWEEN` `тип_данных` `AND` `тип_данных` → `boolean` Не между (обратное к `BETWEEN`). `2 NOT BETWEEN 1 AND 3` → `f`
`тип_данных` `BETWEEN SYMMETRIC` `тип_данных` `AND` `тип_данных` → `boolean` Между, после сортировки граничных значений. `2 BETWEEN SYMMETRIC 3 AND 1` → `t`
`тип_данных` `NOT BETWEEN SYMMETRIC` `тип_данных` `AND` `тип_данных` → `boolean` Не между, после сортировки граничных значений. `2 NOT BETWEEN SYMMETRIC 3 AND 1` → `f`
`тип_данных` `IS DISTINCT FROM` `тип_данных` → `boolean` Не равно, при этом NULL воспринимается как обычное значение. `1 IS DISTINCT FROM NULL` → `t` (а не `NULL`) `NULL IS DISTINCT FROM NULL` → `f` (а не `NULL`)
`тип_данных` `IS NOT DISTINCT FROM` `тип_данных` → `boolean` Равно, при этом NULL воспринимается как обычное значение. `1 IS NOT DISTINCT FROM NULL` → `f` (а не `NULL`) `NULL IS NOT DISTINCT FROM NULL` → `t` (а не `NULL`)
`тип_данных` `IS NULL` → `boolean` Проверяет, является ли значение эквивалентным NULL. `1.5 IS NULL` → `f`
`тип_данных` `IS NOT NULL` → `boolean` Проверяет, отличается ли значение от NULL. `'null' IS NOT NULL` → `t`
`тип_данных` `ISNULL` → `boolean` Проверяет, является ли значение эквивалентным NULL (нестандартный синтаксис).
`тип_данных` `NOTNULL` → `boolean` Проверяет, отличается ли значение от NULL (нестандартный синтаксис).
`boolean` `IS TRUE` → `boolean` Проверяет, является ли результат логического выражения значением true. `true IS TRUE` → `t` `NULL::boolean IS TRUE` → `f` (а не `NULL`)
`boolean` `IS NOT TRUE` → `boolean` Проверяет, является ли результат логического выражения значением false или неизвестным. `true IS NOT TRUE` → `f` `NULL::boolean IS NOT TRUE` → `t` (а не `NULL`)
`boolean` `IS FALSE` → `boolean` Проверяет, является ли результат логического выражения значением false. `true IS FALSE` → `f` `NULL::boolean IS FALSE` → `f` (а не `NULL`)
`boolean` `IS NOT FALSE` → `boolean` Проверяет, является ли результат логического выражения значением true или неизвестным. `true IS NOT FALSE` → `t` `NULL::boolean IS NOT FALSE` → `t` (а не `NULL`)
`boolean` `IS UNKNOWN` → `boolean` Проверяет, является ли результат логического выражения неизвестным значением. `true IS UNKNOWN` → `f` `NULL::boolean IS UNKNOWN` → `t` (а не `NULL`)
`boolean` `IS NOT UNKNOWN` → `boolean` Проверяет, является ли результат логического выражения значением true или false. `true IS NOT UNKNOWN` → `t` `NULL::boolean IS NOT UNKNOWN` → `f` (а не `NULL`)

Предикат

Описание

Пример(ы)

тип_данных BETWEEN тип_данных AND тип_данных → boolean

Между (включая границы интервала).

2 BETWEEN 1 AND 3 → t

2 BETWEEN 3 AND 1 → f

тип_данных NOT BETWEEN тип_данных AND тип_данных → boolean

Не между (обратное к BETWEEN).

2 NOT BETWEEN 1 AND 3 → f

тип_данных BETWEEN SYMMETRIC тип_данных AND тип_данных → boolean

Между, после сортировки граничных значений.

2 BETWEEN SYMMETRIC 3 AND 1 → t

тип_данных NOT BETWEEN SYMMETRIC тип_данных AND тип_данных → boolean

Не между, после сортировки граничных значений.

2 NOT BETWEEN SYMMETRIC 3 AND 1 → f

тип_данных IS DISTINCT FROM тип_данных → boolean

Не равно, при этом NULL воспринимается как обычное значение.

1 IS DISTINCT FROM NULL → t (а не NULL)

NULL IS DISTINCT FROM NULL → f (а не NULL)

тип_данных IS NOT DISTINCT FROM тип_данных → boolean

Равно, при этом NULL воспринимается как обычное значение.

1 IS NOT DISTINCT FROM NULL → f (а не NULL)

NULL IS NOT DISTINCT FROM NULL → t (а не NULL)

тип_данных IS NULL → boolean

Проверяет, является ли значение эквивалентным NULL.

1.5 IS NULL → f

тип_данных IS NOT NULL → boolean

Проверяет, отличается ли значение от NULL.

'null' IS NOT NULL → t

тип_данных ISNULL → boolean

Проверяет, является ли значение эквивалентным NULL (нестандартный синтаксис).

тип_данных NOTNULL → boolean

Проверяет, отличается ли значение от NULL (нестандартный синтаксис).

boolean IS TRUE → boolean

Проверяет, является ли результат логического выражения значением true.

true IS TRUE → t

NULL::boolean IS TRUE → f (а не NULL)

boolean IS NOT TRUE → boolean

Проверяет, является ли результат логического выражения значением false или неизвестным.

true IS NOT TRUE → f

NULL::boolean IS NOT TRUE → t (а не NULL)

boolean IS FALSE → boolean

Проверяет, является ли результат логического выражения значением false.

true IS FALSE → f

NULL::boolean IS FALSE → f (а не NULL)

boolean IS NOT FALSE → boolean

Проверяет, является ли результат логического выражения значением true или неизвестным.

true IS NOT FALSE → t

NULL::boolean IS NOT FALSE → t (а не NULL)

boolean IS UNKNOWN → boolean

Проверяет, является ли результат логического выражения неизвестным значением.

true IS UNKNOWN → f

NULL::boolean IS UNKNOWN → t (а не NULL)

boolean IS NOT UNKNOWN → boolean

Проверяет, является ли результат логического выражения значением true или false.

true IS NOT UNKNOWN → t

NULL::boolean IS NOT UNKNOWN → f (а не NULL)

Предикат BETWEEN упрощает проверки интервала:

a BETWEEN x AND y

равнозначно

a >= x AND a <= y

Заметьте, что BETWEEN считает, что границы интервала включаются в интервал. Предикат BETWEEN SYMMETRIC аналогичен BETWEEN, за исключением того, что аргумент слева от AND не обязательно должен быть меньше или равен аргументу справа. Если это не так, аргументы автоматически меняются местами, так что всегда подразумевается непустой интервал.

Различные варианты BETWEEN реализуются посредством обычных операторов сравнения, и поэтому они будут работать с любыми типами данных, которые можно сравнивать.

Примечание

Использование AND в конструкции BETWEEN создаёт неоднозначность с использованием AND в качестве логического оператора. Для её устранения в качестве второго аргумента предложения BETWEEN принимается только ограниченный набор типов выражений. Если вам нужно записать более сложное подвыражение в BETWEEN, заключите это подвыражение в скобки.

Обычные операторы сравнения выдают NULL (что означает «неопределённость»), а не true или false, когда любое из сравниваемых значений NULL. Например, 7 = NULL выдаёт NULL, так же, как и 7 <> NULL. Когда это поведение нежелательно, можно использовать предикаты IS [ NOT ] DISTINCT FROM:

a IS DISTINCT FROM b
a IS NOT DISTINCT FROM b

Для значений не NULL условие IS DISTINCT FROM работает так же, как оператор <>. Однако если оба сравниваемых значения NULL, результат будет false, и только если одно из значений NULL, возвращается true. Аналогично, условие IS NOT DISTINCT FROM равносильно = для значений не NULL, но возвращает true, если оба сравниваемых значения NULL, и false в противном случае. Таким образом, эти предикаты по сути работают с NULL, как с обычным значением, а не с «неопределённостью».

Для проверки, содержит ли значение NULL или нет, используются предикаты:

выражение IS NULL
выражение IS NOT NULL

или равнозначные (но нестандартные) предикаты:

выражение ISNULL
выражение NOTNULL

Заметьте, что проверка выражение = NULL не будет работать, так как NULL считается не «равным» NULL. (Значение NULL представляет неопределённость, и равны ли две неопределённости, тоже не определено. )

Подсказка

Некоторые приложения могут ожидать, что выражение = NULL вернёт true, если результатом выражения является NULL. Такие приложения настоятельно рекомендуется исправить и привести в соответствие со стандартом SQL. Однако в случаях, когда это невозможно, это поведение можно изменить с помощью параметра конфигурации transform_null_equals. Когда этот параметр включён, PostgreSQL преобразует условие x = NULL в x IS NULL.

Если выражение возвращает табличную строку, тогда IS NULL будет истинным, когда само выражение — NULL или все поля строки — NULL, а IS NOT NULL будет истинным, когда само выражение не NULL, и все поля строки так же не NULL. Вследствие такого определения, IS NULL и IS NOT NULL не всегда будут возвращать взаимодополняющие результаты для таких выражений; в частности такие выражения со строками, одни поля которых NULL, а другие не NULL, будут ложными одновременно. В некоторых случаях имеет смысл написать строка IS DISTINCT FROM NULL или строка IS NOT DISTINCT FROM NULL, чтобы просто проверить, равно ли NULL всё значение строки, без каких-либо дополнительных проверок полей строки.

Логические значения можно также проверить с помощью предикатов

логическое_выражение IS TRUE
логическое_выражение IS NOT TRUE
логическое_выражение IS FALSE
логическое_выражение IS NOT FALSE
логическое_выражение IS UNKNOWN
логическое_выражение IS NOT UNKNOWN

Они всегда возвращают true или false и никогда NULL, даже если какой-любо операнд — NULL. Они интерпретируют значение NULL как «неопределённость». Заметьте, что IS UNKNOWN и IS NOT UNKNOWN по сути равнозначны IS NULL и IS NOT NULL, соответственно, за исключением того, что выражение может быть только булевого типа.

Также имеется несколько связанных со сравнениями функций; они перечислены в Таблице 9.3.

Таблица 9.3. Функции сравнения

Функция Описание Пример(ы)
`num_nonnulls` ( `VARIADIC` `"any"` ) → `integer` Возвращает число аргументов, отличных от NULL. `num_nonnulls(1, NULL, 2)` → `2`
`num_nulls` ( `VARIADIC` `"any"` ) → `integer` Возвращает число аргументов NULL. `num_nulls(1, NULL, 2)` → `1`

Функция

Описание

Пример(ы)

num_nonnulls ( VARIADIC "any" ) → integer

Возвращает число аргументов, отличных от NULL.

num_nonnulls(1, NULL, 2) → 2

num_nulls ( VARIADIC "any" ) → integer

Возвращает число аргументов NULL.

num_nulls(1, NULL, 2) → 1

Введение в оператор SQL Not Equal с примерами

Оператор сравнения — это зарезервированное слово, используемое в предложении SQL WHERE для сравнения двух элементов. Эти операторы используются для перечисления условий в операторе SQL и в качестве конъюнкций для нескольких условий в операторе. Одним из таких операторов является SQL Not Equal, о котором мы поговорим в этой статье.

В этой статье мы рассмотрим следующие темы.

Оператор SQL Not Equal
Возвращаемое значение SQL не равно
Пример 1
Пример 2
Пример 3
Пример 4

Оператор SQL не равен: !=

Если оба выражения SQL не равны, этот оператор возвращает 1, а если они равны, он возвращает 0, а когда любое из выражений имеет значение NULL, он возвращает NULL. Когда выражения возвращают данные разных типов (например, строку и число), выполняется преобразование типов.

Оператор сравнения SQL Not Equal (!=) используется для сравнения двух выражений. Например, операция сравнения 15 != 17 использует оператор SQL Not Equal (!=) между двумя выражениями 15 и 17.

Примечание: «!=» и «<>» дают одинаковые результаты.

Пример:

SELECT * FROM customers WHERE name <> ‘Joe’

или

SELECT * FROM customers WHERE name != ‘Джо’

Приведенный выше запрос выдаст все результаты, где имя не равно Joe.

Оба запроса дадут одинаковый результат.

Возвращаемое значение SQL не равно

SQL Not Equal — логическое выражение. Он может возвращать либо True (если одно выражение не равно другому), либо False (если выражения равны).

Пример:

1 != 2 ——> Истинно

3 != 3 ——> Ложь

Пример 1: Получить все сведения о клиенте, кроме customer_id 1

Приведенный выше код исключит детали customer_id 1.

Пример 2: Получить список всех клиентов, кроме одного конкретного клиента

В приведенном выше примере будут исключены сведения о покупателе по имени Элка.

Пример 3: указание нескольких условий с помощью SQL Not Operator

Мы можем указать несколько условий для оператора Not, используя предложение WHERE.

Приведенный выше оператор даст следующие результаты.

Пример 4: Оператор SQL Not и предложение SQL Group By

Оператор SQL Not также можно использовать с комбинацией предложения GROUP BY и HAVING следующим образом:

Город, сумма баллов которого равна 3220, исключается из результатов.

Получите опыт работы с новейшими инструментами и методами бизнес-аналитики с помощью программы последипломного образования в области бизнес-анализа. Зарегистрируйтесь сейчас!

Заключение

Благодаря этой статье вы получили четкое представление об операторе SQL Not equal, а также привели соответствующие примеры. Оператор равенства повышает производительность SQL-запроса.

Если вы хотите узнать больше об SQL, ознакомьтесь с нашим сертификационным курсом по SQL.

Пройдя этот сертификационный курс по SQL, вы получите все необходимое для работы с базами данных SQL и использования их в своих приложениях. От правильного структурирования вашей базы данных до создания эффективных операторов и предложений SQL и управления вашей базой данных SQL для масштабируемого роста — получите отличное готовое к работе обучение по SQL и множеству его приложений в работе.

Если у вас есть какие-либо вопросы, задавайте их в разделе комментариев, и наши специалисты оперативно ответят на них.

Оператор SQL Not Equal To (!=) для начинающих

В SQL оператор не равно ( != ) сравнивает не равенство двух выражений. То есть он проверяет, равно ли одно выражение 90 103, а не 90 104, равному другому выражению.

Если один или оба операнда NULL , возвращается NULL .

SQL также имеет другой оператор не равно ( <> ), который делает то же самое. Какой из них вы используете, может зависеть от вашей СУБД, от того, какую из них вам удобнее использовать, и, возможно, также от того, есть ли в вашей организации какие-либо соглашения по кодированию, которые диктуют, какую из них следует использовать.

Исходная таблица

Представьте, что наша база данных содержит следующую таблицу. Это таблица, которую мы будем использовать для примеров на этой странице.

 ВЫБЕРИТЕ * ОТ владельцев;

Результат:

 +-----------+-------------+------------+--------- ----------------------+-----+
| Идентификатор владельца   | Имя   | Фамилия   | Телефон          | Электронная почта             |
|-----------+-------------+-------------+---------- ------+-------------------|
| 1         | Гомер       | Коннери    | (308) 555-0100 | [электронная почта защищена] |
| 2         | Барт        | Питт       | (231) 465-3497 | [электронная почта защищена]  |
| 3         | Нэнси       | Симпсон    | (489) 591-0408 | NULL              |
| 4         | Борис       | Трамп      | (349) 611-8908 | NULL              |
| 5         | Вуди       | Иствуд | (308) 555-0112 | [электронная почта защищена] |
| 6         | Берт        | Тайсон      | (309) 565-0112 | [электронная почта защищена]  |
+-----------+-------------+------------+---------- ------+-------------------+

Пример

Если бы мы хотели вернуть список всех владельцев, у которых нет OwnerId из 3 мы могли бы сделать это:

 SELECT *
ОТ владельцев
ГДЕ OwnerId != 3;

Результат:

 +-----------+-------------+------------+--------- ----------------------+-----+
| Идентификатор владельца   | Имя   | Фамилия   | Телефон          | Электронная почта             |
|-----------+-------------+-------------+---------- ------+-------------------|
| 1         | Гомер       | Коннери    | (308) 555-0100 | [электронная почта защищена] |
| 2         | Барт        | Питт       | (231) 465-3497 | [электронная почта защищена]  |
| 4         | Борис       | Трамп      | (349) 611-8908 | NULL              |
| 5         | Вуди       | Иствуд | (308) 555-0112 | [электронная почта защищена] |
| 6         | Берт        | Тайсон      | (309) 565-0112 | [электронная почта защищена]  |
+-----------+-------------+------------+---------- ------+-------------------+

В нашем запросе используется оператор не равно ( != ), чтобы проверить, соответствует ли OwnerId столбец не равен 3 . Запрос возвращает всех владельцев, кроме владельца номер 3.

Строки

При сравнении со строковым значением заключайте строку в кавычки. Например, если бы мы хотели получить информацию обо всех владельцах, чье имя не Гомер, мы могли бы сделать следующее:0003

 ВЫБОР *
ОТ владельцев
ГДЕ Имя != 'Гомер';

Результат:

 +-----------+-------------+------------+---- ---------------------------+-----+
| Идентификатор владельца   | Имя   | Фамилия   | Телефон          | Электронная почта             |
|-----------+-------------+-------------+---------- ------+-------------------|
| 2         | Барт        | Питт       | (231) 465-3497 | [электронная почта защищена]  |
| 3         | Нэнси       | Симпсон    | (489) 591-0408 | NULL              |
| 4         | Борис       | Трамп      | (349) 611-8908 | NULL              |
| 5         | Вуди       | Иствуд | (308) 555-0112 | [электронная почта защищена] |
| 6         | Берт        | Тайсон      | (309) 565-0112 | [электронная почта защищена]  |
+-----------+-------------+------------+---------- ------+-----+

Множественные условия

Если у вас есть несколько условий, вы можете использовать несколько операторов (будь то оба одинаковых оператора или разные).

Вот так:

 SELECT * FROM Владельцы
ГДЕ OwnerId != 1 И OwnerId != 3;

Результат:

 +-----------+--------------+------------+---- ---------------------------+-----+
| Идентификатор владельца   | Имя   | Фамилия   | Телефон          | Электронная почта             |
|-----------+-------------+-------------+---------- ------+-------------------|
| 2         | Барт        | Питт       | (231) 465-3497 | [электронная почта защищена]  |
| 4         | Борис       | Трамп      | (349) 611-8908 | NULL              |
| 5         | Вуди       | Иствуд | (308) 555-0112 | [электронная почта защищена] |
| 6         | Берт        | Тайсон      | (309) 565-0112 | [электронная почта защищена]  |
+-----------+-------------+------------+---------- ------+-----+

Как только вы начнете использовать больше условий, вы должны использовать круглые скобки, чтобы окружить условия, которые вы хотите оценить первый. Если вы этого не сделаете, вы можете обнаружить, что получаете неожиданные результаты из-за того, что условия оцениваются в непредусмотренном вами порядке.

Отрицание условия

Если вы используете оператор NOT для отрицания условия, обеспечиваемого оператором not equal to, вы в конечном итоге получите результаты equals ( = ) оператор:

 ВЫБОР *
ОТ владельцев
ГДЕ НЕ Имя != 'Гомер';

Результат:

 +-----------+-------------+------------+---- ---------------------------+-----+
| Идентификатор владельца   | Имя   | Фамилия   | Телефон          | Электронная почта             |
|-----------+-------------+-------------+---------- ------+-------------------|
| 1         | Гомер       | Коннери    | (308) 555-0100 | [электронная почта защищена] |
+-----------+-------------+------------+---------- ------+-----+

В этом случае лучше просто использовать оператор равенства ( = ), например:

 SELECT *
ОТ владельцев
ГДЕ Имя = 'Гомер';

Конечно, это само по себе можно было бы отменить с помощью оператора NOT , что дало бы нам тот же результат, что и оператор не равно ( != ):

 SELECT *
ОТ владельцев
ГДЕ НЕ Имя = 'Гомер';

Значения NULL

Возможно, вы заметили, что наша исходная таблица-пример содержит пару NULL значения в столбце Электронная почта .

Столбец, содержащий NULL , означает, что он не имеет значения. Это отличается от 0 или false или даже от пустой строки.

Вы не можете использовать оператор не равно для сравнения с NULL . На самом деле это может зависеть от вашей СУБД и ее конфигурации. А пока давайте посмотрим, что произойдет, если я попытаюсь сравнить столбец Email с NULL .

 ВЫБРАТЬ * ОТ владельцев
ГДЕ электронная почта != NULL;

Результат:

 (затронуто 0 строк)

Способ проверки значений, отличных от NULL , заключается в использовании IS NOT NULL .

Следовательно, нам нужно переписать приведенное выше утверждение следующим образом.

 ВЫБЕРИТЕ * ОТ владельцев
ГДЕ Электронная почта НЕ НУЛЕВАЯ;

Результат:

 +-----------+-------------+------------+---- ---------------------------+-----+
| Идентификатор владельца   | Имя   | Фамилия   | Телефон          | Электронная почта             |
|-----------+-------------+-------------+---------- ------+-------------------|
| 1         | Гомер       | Коннери    | (308) 555-0100 | [электронная почта защищена] |
| 2         | Барт        | Питт       | (231) 465-3497 | [электронная почта защищена]  |
| 5         | Вуди       | Иствуд | (308) 555-0112 | [электронная почта защищена] |
| 6         | Берт        | Тайсон      | (309) 565-0112 | [электронная почта защищена]  |
+-----------+-------------+------------+---------- ------+-------------------+

Теперь мы получаем только те строки, которые не являются NULL в столбце Электронная почта .