Поиск

Операции

 

Скобки
  • (...). Скобки используются для изменения приоритета операций. Например:

mysql> SELECT 1+2*3;
-> 7
mysql> SELECT (1+2)*3;
-> 9
Операции сравнения
Результатом выполнения операций сравнения являются 1 (TRUE - истина), О (FALSE - ложь) или NULL. Эти операции действительны и для чисел, и для строк. При необходимости строки автоматически конвертируются в числа, а числа в строки.
MySQL выполняет сравнения, используя следующие правила:

  1. Если один или оба аргумента равны NULL, результатом сравнения будет NULL, за исключением NULL-безопасной операции <=>.
  2. Если оба аргумента операции сравнения - строки, они сравниваются как строки.
  3. Если оба аргумента - целые числа, они сравниваются как целые числа.
  4. Шестнадцатеричные значения интерпретируются как бинарные строки, если они не сравниваются с числами.
  5. Если один аргумент - столбец типа TIMESTAMP или datetime, а другой - константа,то константа перед сравнением конвертируется во временную метку. Это сделано для достижения большей совместимости с ODBC.
  6. Во всех других случаях аргументы сравниваются как числа с плавающей точкой(действительные числа).

По умолчанию, сравнения строк нечувствительны к регистру и используют текущий набор символов (ISO-8859-1 Latin, что отлично работает с английским языком).
Следующие примеры иллюстрируют преобразования строк в числа в операциях сравнения:
mysql> SELECT 1 > 'бх';
-> 0 mysql> SELECT 7 > 'бх';
-> 1 mysql> SELECT 0 > 'хб';
-> 0 mysql> SELECT 0 = ;'хб';
-> 1
Отметим, что когда вы сравниваете строковый столбец с числом, MySQL не может использовать индекс по столбцу для быстрого поиска значения. Если строко-вый_столбец~ индексированный строковый столбец, в следующем запросе индекс не может использоваться для поиска:
SELECT * FROM имя_таблицы WHERE строковый_столбец=1;
Причина состоит в том, что существует множество вариантов строки, которые могут быть конвертированы в число 1: Ч', ' 1', ' 1а' и так далее.

  • =.Равенство:
    mysql> SELECT 1 = 0;
    -> 0 mysql> SELECT '0' =0;
    -> 1 mysql> SELECT '0.0' =0;
    -> 1 mysql> SELECT '0.01' =0;
    -> 0 mysql> SELECT'.01' = 0.01;
    -> 1
    • <=>.NULL-безопасное равенство. Эта операция проверяет операнды на предмет равенства, как и =, но возвращает 1 вместо NULL, если оба операнда равны NULL, и 0 вместо NULL, если только один из операндов равен NULL.
    • mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
      -> 1, 1, 0 mysql> SELECT1=1, NULL = NULL, 1 = NULL;
      -> 1, NULL, NULL
    • <>,!=. Неравенство:
    • mysql> SELECT '.01' <> '0.01';
      -> 1
      raysql> SELECT .01О'0.01';
      -> 0
      raysql> SELECT 'zapp' <> 'zappp';
      -> 1
    • <=.Меньшеилиравно:
    • mysql> SELECT0.1 <= 2;
      -> 1
    • <.Меньше:
    • raysql> SELECT 2 < 2; -> 0
    • >=. Больше или равно:
      mysql> SELECT2 >= 2;
      -> 1
    • >. Больше:
    • mysql> SELECT 2 > 2; -> 0
    • IS NULL, IS NOT NULL. Проверяет,равнолизначение NULL:
    • mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
      -> 0, 0, 1 mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
      -> 1, 1, 0
      Чтобы обеспечить возможность работы с программами ODBC, MySQL поддержи­вает дополнительные средства для значений NULL:

      Вы можете искать строку, которая содержит самое последнее значение
      AUTO_INCREMENT, выполнив следующий запрос немедленно после генерирова­
      ния этого значения:

      SELECT * FROM имя_таблицыWHERE столбец_аиЬо IS NULL
      Такое поведение может быть отключено установкой SQL AUTO_IS_NULL=0. См.раздел 6.5.3.1.
      • Для столбцов DATE и DATETIME, которые объявлены как NOT NULL, вы можете
      найти специальную дату
      ' 0000-00-00', применив запрос вроде следующего:
      SELECT * FROM имя_таблицыWHERE столбец_6аЬеIS NULL
      Это необходимо для правильной работы некоторых приложенийODBC, пото­му чтоODBCне допускает значения даты ' 0000-00-00 '.
    • выражение BETWEEN минимум AND максимум
    • Если выражение больше или равно минимум и меньше или равно максимум, то BETWEEN возвратит 1, иначе - 0. Если все аргументы одного типа, то это эквива­лентно выражению {минимум <= выражение AND выражение <= максимум). В про­тивном случае преобразование типов выполняется в соответствии с правилами, описанными в начале раздела, но применяется ко всем трем аргументам. Следуетотметить, что до версииMySQL4.0.5 вместо этого аргументы конвертировались ктипу выражение.
      mysql> SELECT I BETWEEN 2 AND 3;
      -> 0 mysql> SELECT 'b' BETWEEN 'a' AND 'c';
      -> 1 mysql> SELECT 2 BETWEEN 2 AND'3';
      -> 1 mysql> SELECT 2 BETWEEN 2 AND 'x-3';
      -> 0
    • выражение NOT BETWEEN минимумAND максимум
    • Это то же самое, что NOT (выражениеBETWEEN минимумAND максимум).
    • COALESCE{значение,...)
    • Возвращает первое значение в списке, не равное NULL.
      mysql> SELECT COALESCE(NULL,1);
      -> 1 mysql> SELECT COALESCE(NULL, NULL,NULL);
      -> NULL
      COALESCE() появилась вMySQL 3.23.3.
    • GREATEST{значение1,значение2, ...)
      С двумя или более аргументами возвращает наибольший (с наибольшим значени­ем) аргумент. Аргументы сравниваются по тем же правилам, что и в LEAST ().
    • mysql> SELECT GREATEST(2,0) ;
      -> 2 mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
      -> 767.0 mysql> SELECT GREATEST('B', 'A','C);
      -> 'C

      До версии MySQL 3.22.5 вместо GREATEST () нужно было использовать МАХ ().
    • выражение IN {значение,...)
    • Возвращает 1, если выражение равно любому из значений списка IN, в противном случае возвращает 0. Если все значения - константы, они обрабатываются в соот­ветствии с типом выражение и сортируются. Извлечение значения затем выполня­ется с использованием бинарного поиска. Это значит, что IN работает очень быст­ро, если список состоит только из констант. Если же выражение является чувстви­тельным к регистру и строковым, сравнения строк будут зависеть от регистра.
      mysql> SELECT 2 IN (0,3,5,'wefwf);
      -> 0 mysql> SELECT 'wefwf1 IN (0,3,5,'wefwf);
      -> 1
      Количество значений в списке IN ограничивается только значением переменной
      max__allowed_packet.
      Для соответствия стандарту SQL, начиная с MySQL 4.1, IN возвращает NULL не
      только когда выражение в левой части равно NULL, но также если соответствие не
      найдено и один из компонентов списка IN равен NULL.
      Начиная с MySQL 4.1, синтаксис IN () также используется для записи некоторых
      типов подзапросов. См. раздел 6.1.8.3.
    • выражение NOT IN {значение,...)
    • То же самое, что NOT {выражение IN {значение,...)).
    • ISNULL{выражение)
    • Если выражение равно NULL, возвращает 1, иначе - 0.
      mysql> SELECT ISNULL(1+1);
      -> 0
      mysql> SELECT ISNULL(1/0);
      -> 1
      Помните, что сравнение значений NULL с применением операции = всегда возвра­щает "ложь"!
    • INTERVAL{N,N1,N2,N3, . . .)
    • Возвращает 0, если N < Ш,1-если N < N2, и так далее, либо NULL, если N равно NULL. Все аргументы рассматриваются как целые. Для правильной работы этой функции требуется соблюдение условия N1 < N2 < N3 < ... < Nn. Это связано с применением бинарного поиска (очень быстрого).
      mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
      -> 3 mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
      -> 2 mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
      -> 0
    • LEAST{значение1,значение2,...)
    С двумя или более аргументами возвращает минимальный (с минимальным зна­чением) аргумент. Аргументы сравниваются по следующим правилам:

    1. Если возвращаемое значение используется в контексте INTEGER, или все аргументы целые, они сравниваются как целые.
    2. Если возвращаемое значение используется в контексте REAL, или же все аргументы - действительные числа, они сравниваются как действительные числа.
    3. Если любой из аргументов - чувствительная к регистру строка, все они сравниваются как чувствительные к регистру строки.
    4. В других случаях аргументы сравниваются как нечувствительные к регистру строки.

    mysql> SELECT LEAST (2,0);
    ->О
    mysql> SELECT LEAST(34.0,3.0,5.О,767.0);
    -> 3.0
    mysql> SELECT LEAST('B','A','C);
    -> 'A1
    До версии MySQL 3.22.5 вместо LEAST () нужно было использовать MIN (). Следует отметить, что предыдущие правила преобразования в некоторых гранич­ных случаях могут приводить к получению странных результатов:
    mysql> SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED); -> -9223372036854775808
    Это происходит потому, что MySQL читает 9223372036854775808.0 в целом кон­тексте. Целое представление не подходит для этого значения, поэтому оно обра­щается в целое со знаком.

    Логическиеоперации
    В SQL все логические операции возвращают TRUE, FALSE или NULL (UNKNOWN).
    В MySQL это реализовано, как 1 (TRUE), 2 (FALSE) и NULL. В основном это совмес­тимо с тем, что возвращают другие SQL-серверы, хотя некоторые в качестве TRUE мо­гут возвращать любое ненулевое значение.
    • NOT, !. Логическое НЕ. Возвращает 1, если операнд равен 0, и 0 - если операнд ненулевой. NOT NULL возвращает null.
      mysql> SELECT NOT 10;
    • -> 0 mysql> SELECT NOT 0;
      -> 1 mysql> SELECT NOT NULL;
      -> NULL mysql> SELECT ! (1+1);
      -> 0 mysql> SELECT! 1+1;
      -> 1
      В последнем примере возвращается 1, поскольку выражение вычисляется как
      * AND, &&. Логическое И. Возвращает 1, если оба операнда ненулевые и не NULL, если один или более операндов равны 0, то возвращает 0, в противном случае - NULL.

      mysql> SELECTI && 1;
      -> 1 mysql> SELECT 1 && 0;
      -> О mysql> SELECT 1 && NULL;
      -> NULL mysql> SELECT 0 && NULL;
      -> 0
      mysql> SELECT NULL && 0;-> 0
      Следует отметить, что в версиях MySQL, предшествующих 4.0.5, вычисление прекращалось, если встречался NULL, вместо того, чтобы продолжать проверять на возможное наличие 0. Это означает, что в этих версиях SELECT (NULL AND 0) вер­нет NULL вместо 0. Начиная с MySQL 4.0.5, код был перестроен таким образом, чтобы результат выражения всегда соответствовал стандарту SQL, при этом ис­пользуя оптимизацию, когда это возможно.
    • OR, | |. Логическое ИЛИ. Возвращает 1, если любой операнд ненулевой, NULL - ес­
      ли любой операнд NULL, и 0 в остальных случаях.
      mysql> SELECT I | | 1;
      -> 1
      mysql> SELECT I || 0;
      -> 1
      mysql> SELECT 0 || 0;
      -> О
      mysql> SELECT 0 || NULL;
      -> NULL
      mysql> SELECT1 ||NULL;
      -> 1
    • XOR. Логическое ИСКЛЮЧАЮЩЕЕ ИЛИ. Возвращает NULL, если оба операнда NULL. Для операндов, отличных от NULL, возвращает 1, если нечетное число операндов ненулевые, иначе возвращает 0.
    mysql> SELECT I XOR 1;
    -> 0 raysql> SELECT 1 XOR 0;
    -> 1 mysql> SELECT 1 XOR NULL;
    -> NULL mysql> SELECT 1 XOR 1 XOR 1;
    -> 1
    s XOR b математически эквивалентно (a AND (NOT b) ) OR ((NOT a) AND b). Операция XOR появилась в MySQL 4.0.2.
    Операции,чувствительныекрегистру
    • binary. Операция binary приводит строку-аргумент к типу бинарной строки. Это простой способ сделать сравнение столбцов чувствительным к регистру, даже mysql> SELECT 'a1 = 'А';
      -> 1
      mysql> SELECT BINARY 'a' = 'А';
      -> О
      Операция binary появилась в MySQL 3.23.0. Начиная с версии MySQL 4.0.2, BINARY строка является краткой формой CAST {строка AS BINARY). См. раздел 5.7. Следует отметить, что в некоторых контекстах, если вы приводите индексирован­ный столбец к BINARY, MySQL не сможет использовать индекс.
      Если вы хотите сравнивать значения BLOB в нечувствительной к регистру манере, то можно поступить так:
    • В версиях MySQL, предшествующих 4.1.1, используйте функцию UPPER () для перевода символов значения BLOB в верхний регистр перед выполнением сравнения:
      SELECT 'A' LIKE UPPER(столбец_ЫоЬ) FROM имя_таблицы;

    • Если сравниваемое значение представлено в нижнем регистре, преобразуйте зна­чение BLOB С ПОМОЩЬЮ LOWER ().
    • Для MySQL 4.1.1 и выше столбцы BLOB имеют набор символов binary, который неподдерживает концепцию регистра. Для выполнения сравнения, нечувствительного к регистру, пользуйтесь функцией CONVERT (), чтобы преобразовать значения BLOB в набор символов, не зависящий от регистра. Результатом будет небинарная строка, которой можно применить чувствительную к регистру операцию LIKE:
    SELECT 'A' LIKE CONVERT {столбец_ЫоЬ USING latinl) FROM имя_таблицы;
    Чтобы использовать другой набор символов, подставьте его имя в предыдущий запрос вместо latinl.
    CONVERT () может использоваться в более общем виде для сравнения строк, представ­ленных в разных наборах символов.