• \0

  Символ 0 (NUL) в ASCII коде.

• \'

  Символ одиночной кавычки (‘'’).

• \"

  Символ двойной кавычки (‘"’).

• \b

  Возврат на один символ.

• \n

  Символ новой строки (перевода строки).

• \r

  Символ перевода каретки.

• \t

  Символ табуляции.

• \z

  Символ (Control-Z) таблицы ASCII(26). Данный символ можно закодировать, чтобы обойти проблему, заключающуюся в том, что под Windows ASCII(26) означает конец файла (проблемы возникают при использовании ASCII(26) в выражении mysql database < filename).

• \\

  Символ обратного слеша.

• \%

  Символ процентов ‘%’. Используется для поиска копий литерала ‘%’ в контекстах, где выражение ‘%’ в противном случае интерпретировалось бы как групповой символ (see Раздел 6.3.2.1, «Функции сравнения строк»).

• \'_'

  Символ подчеркивания ‘_’. Используется для поиска копий литерала ‘_’ в контекстах, где выражение ‘_’ в противном случае интерпретировалось бы как групповой символ (see Раздел 6.3.2.1, «Функции сравнения строк»).

• Одиночная кавычка (апостроф) ‘'’ внутри строки, заключенной в кавычки ‘'’, может быть записана как ''''.

• Двойная кавычка ‘"’ внутри строки, заключенной в двойные кавычки ‘"’, может быть записана как '""'.

• Можно предварить символ кавычки символом экранирования (‘\’).

• Для символа ‘'’ внутри строки, заключенной в двойные кавычки, не требуется специальной обработки; его также не требуется дублировать или предварять обратным слешем. Точно так же не требует специальной обработки двойная кавычка ‘"’ внутри строки, заключенной в одиночные кавычки ‘'’.

• NUL

  ASCII 0. Необходимо представлять в виде '\0' (обратный слеш и символ ASCII ‘0’).

• \

  ASCII 92, обратный слеш. Представляется как '\\'.

• '

  ASCII 39, единичная кавычка. Представляется как '\''.

• "

  ASCII 34, двойная кавычка. Представляется как '\"'.

• Величина года в интервале 00-69 конвертируется в 2000-2069.

• Величина года в интервале 70-99 конвертируется в 1970-1999.

• Столбец не указан явно в команде INSERT или LOAD DATA INFILE.

• Столбец не указан явно в команде UPDATE, и при этом изменяется величина в некотором другом столбце (следует отметить, что команда UPDATE, устанавливающая столбец в то же самое значение, которое было до выполнения команды, не вызовет обновления столбца TIMESTAMP, поскольку в целях повышения производительности MySQL игнорирует подобные обновления при установке столбца в его текущее значение).

• Величина в столбце TIMESTAMP явно установлена в NULL.

• Пусть MySQL автоматически установит значение столбца с типом TIMESTAMP при создании данной строки. Столбец будет установлен в исходное состояние со значением текущих даты и времени.

• При выполнении последующих обновлений других столбцов в данной строке необходимо явно установить столбец TIMESTAMP в его текущее значение.

• Как строка в формате 'YYYY-MM-DD HH:MM:SS' или в формате 'YY-MM-DD HH:MM:SS'. Допускается ``облегченный'' синтаксис - можно использовать любой знак пунктуации в качестве разделительного между частями разделов даты или времени. Например, величины '98-12-31 11:30:45', '98.12.31 11+30+45', '98/12/31 11*30*45' и '98@12@31 11^30^45' являются эквивалентными.

• Как строка в формате 'YYYY-MM-DD' или в формате 'YY-MM-DD'. Здесь также допустим ``облегченный'' синтаксис. Например, величины '98-12-31', '98.12.31', '98/12/31' и '98@12@31' являются эквивалентными.

• Как строка без разделительных знаков в формате 'YYYYMMDDHHMMSS' или в формате 'YYMMDDHHMMSS', при условии, что строка понимается как дата. Например, величины '19970523091528' и '970523091528' можно интерпретировать как '1997-05-23 09:15:28', но величина '971122129015' является недопустимой (значение раздела минут является абсурдным) и преобразуется в '0000-00-00 00:00:00'.

• Как строка без разделительных знаков в формате 'YYYYMMDD' или в формате 'YYMMDD', при условии, что строка интерпретируется как дата. Например, величины '19970523' и '970523' можно интерпретировать как '1997-05-23', но величина '971332' является недопустимой (значения разделов месяца и дня не имеют смысла) и преобразуется в '0000-00-00'.

• Как число в формате YYYYMMDDHHMMSS или в формате YYMMDDHHMMSS, при условии, что число интерпретируется как дата. Например, величины 19830905132800 и 830905132800 интерпретируются как '1983-09-05 13:28:00'.

• Как число в формате YYYYMMDD или в формате YYMMDD, при условии, что число интерпретируется как дата. Например, величины 19830905 и 830905 интерпретируются как '1983-09-05'.

• Как результат выполнения функции, возвращающей величину, приемлемую в контекстах типов данных DATETIME, DATE или TIMESTAMP (например, функции NOW() или CURRENT_DATE().

• Необходимо всегда указывать год, месяц и день даже для типов TIMESTAMP(4) или TIMESTAMP(2). В противном случае задаваемая величина не будет допустимым значением даты и будет храниться как 0.

• При увеличении ширины узкого столбца TIMESTAMP путем использования команды ALTER TABLE будет выводиться ранее ``скрытая'' информация.

• И аналогично, при сужении столбца TIMESTAMP хранимая информация не будет потеряна, если не принимать во внимание, что при выводе информации будет выдаваться меньше.

• Хотя величины TIMESTAMP хранятся с полной точностью, непосредственно может работать с этим исходным хранимым значением величины только функция UNIX_TIMESTAMP(). Остальные функции оперируют форматированными значениями извлеченной величины. Это означает, что нельзя использовать такие функции, как HOUR() или SECOND(), пока соответствующая часть величины TIMESTAMP не будет включена в ее форматированное значение. Например, раздел HH столбца TIMESTAMP не будет выводиться, пока количество выводимых символов не станет по меньшей мере равным 10, так что попытки использовать HOUR() для более коротких величин TIMESTAMP приведут к бессмысленным результатам.

• Если присвоить значение типа DATE объекту DATETIME или TIMESTAMP, то в результирующей величине ``временная'' часть будет установлена в '00:00:00', так как величина DATE не содержит информации о времени.

• Если присвоить значение типа DATE, DATETIME или TIMESTAMP объекту DATE, то ``временная'' часть в результирующей величине будет удалена, так как тип DATE не включает информацию о времени.

• Несмотря на то что все величины DATETIME, DATE и TIMESTAMP могут быть указаны с использованием одного и того же набора форматов, следует помнить, что указанные типы имеют разные интервалы допустимых значений. Например, величины типа TIMESTAMP не могут иметь значения даты более ранние, чем относящиеся к 1970 году или более поздние, чем относящиеся к 2037 году. Это означает, что такая дата, как '1968-01-01', будучи разрешенной для величины типа DATETIME или DATE, недопустима для величины типа TIMESTAMP и будет преобразована в 0 при присвоении этому объекту.

• Упрощенный формат, который допускается для величин, заданных строками, может ввести в заблуждение. Например, такая величина, как '10:11:12', благодаря разделителю ‘:’ могла бы оказаться величиной времени, но, используемая в контексте даты, она будет интерпретирована как год '2010-11-12'. В то же время величина '10:45:15' будет преобразована в '0000-00-00', так как для месяца значение '45' недопустимо.

• Сервер MySQL выполняет только первичную проверку истинности даты: дни 00-31, месяцы 00-12, года 1000-9999. Любая дата вне этого диапазона преобразуется в 0000-00-00. Следует отметить, что, тем не менее, при этом не запрещается хранить неверные даты, такие как 2002-04-31. Это позволяет веб-приложениям сохранять данные форм без дополнительной проверки. Чтобы убедиться в достоверности даты, выполняется проверка в самом приложении.

• Величины года, представленные двумя разрядами, допускают неоднозначное толкование, так как неизвестно столетие. MySQL интерпретирует двухразрядные величины года по следующим правилам:

  • Величины года в интервале 00-69 преобразуются в 2000-2069.

  • Величины года в интервале 70-99 преобразуются в 1970-1999.

Как строка в формате 'D HH:MM:SS.дробная часть' (следует учитывать, что MySQL пока не обеспечивает хранения дробной части величины в столбце рассматриваемого типа). Можно также использовать одно из следующих ``облегченных'' представлений: HH:MM:SS.дробная часть, HH:MM:SS, HH:MM, D HH:MM:SS, D HH:MM, D HH или SS. Здесь D - это дни из интервала значений 0-33.

• Как строка без разделителей в формате 'HHMMSS', при условии, что строка интерпретируется как дата. Например, величина '101112' понимается как '10:11:12', но величина '109712' будет недопустимой (значение раздела минут является абсурдным) и преобразуется в '00:00:00'.

• Как число в формате HHMMSS, при условии, что строка интерпретируется как дата. Например, величина 101112 понимается как '10:11:12'. MySQL понимает и следующие альтернативные форматы: SS, MMSS, HHMMSS, HHMMSS.дробная часть. При этом следует учитывать, что хранения дробной части MySQL пока не обеспечивает.

• Как результат выполнения функции, возвращающей величину, приемлемую в контексте типа данных типа TIME (например, такой функции, как CURRENT_TIME).

• Как четырехзначная строка в интервале значений от '1901' до '2155'.

• Как четырехзначное число в интервале значений от 1901 до 2155.

• Как двухзначная строка в интервале значений от '00' до '99'. Величины в интервалах от '00' до '69' и от '70' до '99' при этом преобразуются в величины YEAR в интервалах от 2000 до 2069 и от 1970 до 1999 соответственно.

• Как двухзначное число в интервале значений от 1 до 99. Величины в интервалах от 1 до 69 и от 70 до 99 при этом преобразуются в величины YEAR в интервалах от 2001 до 2069 и от 1970 до 1999 соответственно. Необходимо принять во внимание, что интервалы для двухзначных чисел и двухзначных строк несколько различаются, так как нельзя указать ``ноль'' непосредственно как число и интерпретировать его как 2000. Необходимо задать его как строку '0' или '00', или же оно будет интерпретировано как 0000.

• Как результат выполнения функции, возвращающей величину, приемлемую в контексте типа данных YEAR (такой как NOW()).

• Столбцы типов BLOB и TEXT могут индексироваться в версии MySQL 3.23.2 и более новых. Более старые версии MySQL не поддерживают индексацию этих столбцов.

• В столбцах типов BLOB и TEXT не производится удаление концевых символов, как это делается для столбцов типа VARCHAR.

• Для столбцов BLOB и TEXT не может быть задан атрибут DEFAULT - значения величин по умолчанию.

Чтобы обеспечить возможность использования команд GROUP BY или ORDER BY в столбце типа BLOB или TEXT, необходимо преобразовать значение столбца в объект с фиксированной длиной. Обычно это делается с помощью функции SUBSTRING. Например:

mysql> SELECT comment FROM tbl_name,SUBSTRING(comment,20) AS substr
    -> ORDER BY substr;

Если этого не сделать, то операция сортировки в столбце будет выполнена только для первых байтов, количество которых задается параметром max_sort_length. Значение по умолчанию величины max_sort_length равно 1024; это значение можно изменить, используя параметр -O сервера mysqld при его запуске. Группировка выражения, включающего в себя величины BLOB или TEXT, возможна при указании позиции столбца или использовании псевдонима:

mysql> SELECT id,SUBSTRING(blob_col,1,100) FROM tbl_name GROUP BY 2;
mysql> SELECT id,SUBSTRING(blob_col,1,100) AS b FROM tbl_name GROUP BY b;

• Максимальный размер объекта типа BLOB или TEXT определяется его типом, но наибольшее значение, которое фактически может быть передано между клиентом и сервером, ограничено величиной доступной памяти и размером буферов связи. Можно изменить размер буфера блока передачи, но сделать это необходимо как на стороне сервера, так и на стороне клиента. See Раздел 5.5.2, «Настройка параметров сервера».

• Если делается всавка некорректного значения в столбец ENUM (т.е. вставка строки, не перечисленной в списке допустимых), то вставляется пустая строка, что является указанием на ошибочное значение. Эта строка отличается от "обычной" пустой строки по тому признаку, что она имеет цифровое значение, равное 0. Об этом чуть ниже.

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

• Значение из списка допустимых величин, определенных при создании таблицы нумеруются, начиная с 1.

• Индекс пустой ошибочной строки - 0. Это означает что вы можете использовать следующий SELECT для того, чтобы найти записи, в которые были вставлены некорректные значения ENUM:

  mysql> SELECT * FROM tbl_name WHERE enum_col=0;
  

• Индекс значения NULL - NULL.

• Если один или оба аргумента - NULL, то и результат сравнения будет NULL. Справедливо для всех операторов кроме <=>.

• Если оба аргумента в операторе сравнения являются строками, то они сравниваются как строки.

• Если оба аргумента - целые числа, то они сравниваются как целые числа.

• Шестнадцатеричные величины, если они не сравниваются с числом, трактуются как строки с двоичными данными.

• Если один из аргументов представляет собой столбец типа TIMESTAMP или DATETIME, а второй аргумент - константа, то константа перед выполнением сравнения преобразуется к типу TIMESTAMP. Это сделано для лучшей совместимости с ODBC.

• Во всех других случаях аргументы сравниваются как действительные числа с плавающей точкой.

• =

  Равно:

  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
  

• <>, !=

  Не равно:

  mysql> SELECT '.01' <> '0.01';
          -> 1
  mysql> SELECT .01 <> '0.01';
          -> 0
  mysql> SELECT 'zapp' <> 'zappp';
          -> 1
  

• <=

  Меньше или равно:

  mysql> SELECT 0.1 <= 2;
          -> 1
  

• <

  Меньше чем:

  mysql> SELECT 2 < 2;
          -> 0
  

• >=

  Больше или равно:

  mysql> SELECT 2 >= 2;
          -> 1
  

• >

  Больше чем:

  mysql> SELECT 2 > 2;
          -> 0
  

• <=>

  NULL-безопасное сравнение (равно):

  mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
          -> 1 1 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
  

  Для того, чтобы MySQL хорошо работал с другими программами, обеспечивается поддержка следующих дополнительных возможностей для функции IS NULL:

  • Можно найти последнюю вставленную строку, используя выражение:

    SELECT * FROM tbl_name WHERE auto_col IS NULL
    

    Это свойство можно блокировать установкой SQL_AUTO_IS_NULL=0. See Раздел 5.5.6, «Синтаксис команды SET».

  • Для данных типа NOT NULL DATE и столбцов DATETIME можно найти особую дату 0000-00-00, используя выражение:

    SELECT * FROM tbl_name WHERE date_column IS NULL
    

    Это необходимо для работы некоторых приложений ODBC (так как ODBC не поддерживает значение даты 0000-00-00).

• expr BETWEEN min AND max

  Если величина выражения expr больше или равна заданному значению min и меньше или равна заданному значению max, то функция BETWEEN возвращает 1, в противном случае - 0. Это эквивалентно выражению (min <= expr AND expr <= max), в котором все аргументы представлены одним и тем же типом данных. В противном случае имеет место быть преобразование типов так, как сказано выше, но применительно ко всем трем аргументами. Внимание: до 4.0.5 аргументы приводились к типу expr.

  mysql> SELECT 1 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
  

• expr NOT BETWEEN min AND max

  То же справедливо и для функции NOT (expr BETWEEN min AND max).

• expr IN (value,...)

  Возвращает 1, если выражение expr равно любой величине из списка IN, иначе - 0. Если все величины - константы, то они оцениваются в соответствии с типом выражения expr и сортируются. Поиск элемента в этом случае производится методом логического поиска. Это означает, что функция IN является очень быстрой, если список значений IN состоит полностью из констант. Если expr является зависимым от регистра строковым выражением, то сравнение строк производится с учетом регистра:

  mysql> SELECT 2 IN (0,3,5,'wefwf');
          -> 0
  mysql> SELECT 'wefwf' IN (0,3,5,'wefwf');
          -> 1
  

  Начиная с 4.1 (в соответствии со стандартом SQL-99), IN возвращает NULL не только если выражение в левой части является NULL, но также если не найдено соответствия в списке и одно из выражений в списке является величиной NULL.

• expr NOT IN (value,...)

  То же справедливо и для функции NOT (expr IN (value,...)).

• ISNULL(expr)

  Если expr равно NULL, то ISNULL() возвращает 1, в противном случае - 0:

  mysql> SELECT ISNULL(1+1);
          -> 0
  mysql> SELECT ISNULL(1/0);
          -> 1
  

  Обратите внимание: при сравнении величин NULL с использованием оператора = всегда будет возвращаться значение FALSE!

• COALESCE(list)

  Возвращает первый в списке элемент со значением, не равным NULL:

  mysql> SELECT COALESCE(NULL,1);
          -> 1
  mysql> SELECT COALESCE(NULL,NULL,NULL);
          -> NULL
  

• INTERVAL(N,N1,N2,N3,...)

  Возвращает 0, если N < N1, и 1, если N < N2, и так далее. Все аргументы трактуются как целые числа. Для корректной работы этой функции необходимо условие 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
  

• 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, поскольку данное выражение вычисляется тем же способом, что и (!1)+1.

• AND, &&

  Логическое И. Дает 1 если все операнды ненулевые и не NULL, 0 если один или более операндов равны 0, или NULL в остальных случаях.

  mysql> SELECT 1 && 1;
          -> 1
  mysql> SELECT 1 && 0;
          -> 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. В 4.0.5 код был переписан так, чтобы оптимизация сохранилась, но результат всегда был таков, как требует того ANSI.

• OR, ||

  Логическое ИЛИ. Возвращает 1, если любой из операндов не 0, NULL если один из операндов NULL, в остальных случаях возвращает 0.

  mysql> SELECT 1 || 1;
          -> 1
  mysql> SELECT 1 || 0;
          -> 1
  mysql> SELECT 0 || 0;
          -> 0
  mysql> SELECT 0 || NULL;
          -> NULL
  mysql> SELECT 1 || NULL;
          -> 1
  

• XOR

  Логический XOR (побитовое сложение по модулю 2) Возвращает NULL если любой из операндов - NULL. Для не-NULL операндов, возвращает 1 если нечетное количество операндов - не 0.

  mysql> SELECT 1 XOR 1;
          -> 0
  mysql> SELECT 1 XOR 0;
          -> 1
  mysql> SELECT 1 XOR NULL;
          -> NULL
  mysql> SELECT 1 XOR 1 XOR 1;
          -> 1
  

  a XOR b математически эквалиентно (a AND (NOT b)) OR ((NOT a) and b).

  XOR был реализован в 4.0.2.

• IFNULL(expr1,expr2)

  Если expr1 не равно NULL, то функция IFNULL() возвращает значение expr1, в противном случае - expr2. В зависимости от контекста функция IFNULL() может возвращать либо числовое, либо строковое значение:

  mysql> SELECT IFNULL(1,0);
          -> 1
  mysql> SELECT IFNULL(NULL,10);
          -> 10
  mysql> SELECT IFNULL(1/0,10);
          -> 10
  mysql> SELECT IFNULL(1/0,'yes');
          -> 'yes'
  

  В 4.0.6 и раньше по умолчанию возвращал для IFNULL(expr1,expr2) более "общее" из двух выражений в порядке STRING, REAL или INTEGER. Разница с более ранними версиями MySQL больше всего заметна тогда, когда вы создаете таблицу, основанную на выражении или MySQL внутренне сохраняет величину, основанную на выражении IFNULL() во временной таблице.

  CREATE TABLE foo SELECT IFNULL(1,"test") as test;
  

  В 4.0.6 тип для столбца "test" - CHAR(4) в то время как на более ранних типом был бы BIGINT.

• NULLIF(expr1,expr2)

  Если выражение expr1 = expr2 истинно, то возвращает NULL, в противном случае - expr1. Эквивалентна оператору CASE WHEN x = y THEN NULL ELSE x END:

  mysql> SELECT NULLIF(1,1);
          -> NULL
  mysql> SELECT NULLIF(1,2);
          -> 1
  

  Отметим, что если аргументы не равны, то величина expr1 вычисляется в MySQL дважды.

• IF(expr1,expr2,expr3)

  Если expr1 равно значению ИСТИНА (expr1 <> 0 и expr1 <> NULL), то функция IF() возвращает expr2, в противном случае - expr3. В зависимости от контекста функция IF() может возвращать либо числовое, либо строковое значение:

  mysql> SELECT IF(1>2,2,3);
          -> 3
  mysql> SELECT IF(1<2,'yes','no');
          -> 'yes'
  mysql> SELECT IF(STRCMP('test','test1'),'no','yes');
          -> 'no'
  

  Если expr2 или expr3 являются NULL тогда результирующим типом IF() будет тип, который не есть NULL. Это нововведение в MySQL 4.0.3.

  expr1 вычисляется как целое число; это означает, что при исследовании чисел с плавающей точкой или строковых величин в этой функции необходимо использовать операцию сравнения:

  mysql> SELECT IF(0.1,1,0);
          -> 0
  mysql> SELECT IF(0.1<>0,1,0);
          -> 1
  

  В первом случае из приведенных выше функция IF(0.1) возвращает 0, так как 0.1 преобразуется в целое число и в результате выполняется функция IF(0). Но это вовсе не то, что должно было бы получиться. Во втором случае исходная величина с плавающей точкой исследуется при помощи оператора сравнения, чтобы определить, является ли она ненулевой, и в качестве аргумента функции используется результат сравнения - целое число. В версии MySQL 3.23 возвращаемый по умолчанию тип функции IF() (это может иметь значение при сохранении его во временной таблице) вычисляется, как показано ниже:

  Выражение	Возвращаемая величина
  expr2 или expr3 возвращает строку	строка
  expr2 or expr3 возвращает величину с плавающей точкой	с плавающей точкой
  expr2 or expr3 возвращает целое число	целое число

  Если expr2 и expr3 являются строками, и обе регистро-независимы, то и результат является регистро-независимым (начиная с 3.23.51).

• CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN result ...] [ELSE result] END, CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] END

  В первом варианте возвращается значение result, если value=compare-value. Во втором - результат для первого указанного условия condition, если оно истинно. Если соответствующая величина результата не определена, то возвращается значение result, указанное после оператора ELSE. Если часть ELSE в выражении отсутствует, возвращается NULL:

  mysql> SELECT CASE 1 WHEN 1 THEN "one"
             WHEN 2 THEN "two" ELSE "more" END;
         -> "one"
  mysql> SELECT CASE WHEN 1>0 THEN "true" ELSE "false" END;
         -> "true"
  mysql> SELECT CASE BINARY "B" WHEN "a" THEN 1 WHEN "b" THEN 2 END;
         -> NULL
  

• expr LIKE pat [ESCAPE 'escape-char']

  Функция производит сравнение с шаблоном, используя операции сравнения простых регулярных выражений в SQL. Возвращает 1 (ИСТИНА) или 0 (ЛОЖЬ). Выражение LIKE предусматривает использование следующих двух шаблонных символов в pat:

  Символ	Описание
  %	Соответствует любому количеству символов, даже нулевых
  _	Соответствует ровно одному символу

  mysql> SELECT 'David!' LIKE 'David_';
          -> 1
  mysql> SELECT 'David!' LIKE '%D%v%';
          -> 1
  mysql> select TRUNCATE(-1.999,1);
          -> -1.9
  

  Начиная с MySQL 3.23.51 все числа округляются к нулю.

  Если D является негативным, то тогда вся часть числа округляется к нулю.

  mysql> select truncate(122,-2);
         -> 100
  

  Если требуется исследовать литералы при помощи шаблонного символа, следует предварить шаблонный символ экранирующим символом. Если экранирующий символ конкретно не указывается, то подразумевается применение символа ‘\’:

  Строка	Описание
  \%	Соответствует одному символу ‘%’
  \_	Соответствует одному символу ‘_’

  mysql> SELECT 'David!' LIKE 'David\_';
          -> 0
  
  mysql> SELECT 'David_' LIKE 'David\_';
          -> 1
  

  Для указания конкретного экранирующего символа используется выражение ESCAPE:

  mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
          -> 1
  

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

  mysql> SELECT 'abc' LIKE 'ABC';
          -> 1
  mysql> SELECT 'abc' LIKE BINARY 'ABC';
          -> 0
  

  В функции LIKE допускаются даже числовые выражения! (Это расширение MySQL по сравнению с ANSI SQL LIKE.)

  mysql> SELECT 10 LIKE '1%';
          -> 1
  

  Примечание: поскольку в MySQL применяются правила экранирования в строках, применяемые в языке C (например, '\n'), необходимо дублировать все символы ‘\’, используемые в строках функции LIKE. Например, для поиска сочетания символов '\n' его необходимо указать как '\\n'. Чтобы выполнить поиск символа ‘\’, он должен быть указан как '\\\\' (обратные слеши удаляются дважды: сначала синтаксическим анализатором, а потом - при выполнении сравнения с шаблоном, таким образом остается только один обратный слеш, который и будет обрабатываться).

• expr NOT LIKE pat [ESCAPE 'escape-char']

  То же, что и NOT (expr LIKE pat [ESCAPE 'escape-char']).

• expr SOUNDS LIKE expr

  Тоже самое что и SOUNDEX(expr)=SOUNDEX(expr) (доступно в версии 4.1 или новее).

• expr REGEXP pat, expr RLIKE pat

  Выполняет сравнение строкового выражения expr с шаблоном pat. Шаблон может представлять собой расширенное регулярное выражение. See Приложение G, Регулярные выражения в MySQL. Возвращает 1, если expr соответствует pat, в противном случае - 0. Функция RLIKE является синонимом для REGEXP, она предусмотрена для совместимости с mSQL. Примечание: поскольку в MySQL используются правила экранирования в строках, применяемые в языке C (например, '\n'), необходимо дублировать все символы ‘\’, используемые в строках функции REGEXP. Что касается версии MySQL 3.23.4, функция REGEXP является независимой от регистра для нормальных строк (т.е. строк не с двоичными данными):

  mysql> SELECT 'Monty!' REGEXP 'm%y%%';
          -> 0
  
  mysql> SELECT 'Monty!' REGEXP '.*';
          -> 1
  
  mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
          -> 1
  
  mysql> SELECT "a" REGEXP "A", "a" REGEXP BINARY "A";
          -> 1 0
  
  mysql> SELECT "a" REGEXP "^[a-d]";
          -> 1
  

  В REGEXP и RLIKE используется текущий набор символов (ISO-8859-1 Latin1 по умолчанию),

• expr NOT REGEXP pat, expr NOT RLIKE pat

  То же, что и NOT (expr REGEXP pat).

• STRCMP(expr1,expr2)

  Функция STRCMP() возвращает: 0, если строки идентичны, -1 - если первый аргумент меньше второго (в соответствии с имеющимся порядком сортировки), и 1 - в остальных случаях:

  mysql> SELECT STRCMP('text', 'text2');
          -> -1
  
  mysql> SELECT STRCMP('text2', 'text');
          -> 1
  
  mysql> SELECT STRCMP('text', 'text');
          -> 0
  

• MATCH (col1,col2,...) AGAINST (expr), MATCH (col1,col2,...) AGAINST (expr IN BOOLEAN MODE)

  Функция MATCH ... AGAINST() используется для полнотекстового поиска и возвращает величину релевантности - степень сходства между текстом в столбцах (col1,col2,...) и запросом expr. Величина релевантности представляет собой положительное число с плавающей точкой. Нулевая релевантность означает отсутствие сходства. Функция MATCH ... AGAINST() работает в версиях MySQL 3.23.23 или более поздних. Расширение IN BOOLEAN MODE было добавлено в версии 4.0.1. Более подробное описание и примеры использования приведены в разделе Раздел 6.8, «Полнотекстовый поиск в MySQL».

• BINARY

  Оператор BINARY преобразует следующую за ним строку в строку с двоичными данными. Это простой способ обеспечить сравнение в столбце с учетом регистра, даже если данный столбец не определен как BINARY или BLOB:

  mysql> SELECT "a" = "A";
          -> 1
  
  mysql> SELECT BINARY "a" = "A";
          -> 0
  

  BINARY string является сокращением для CAST(string AS BINARY). See Раздел 6.3.5, «Функции приведения типов». Оператор BINARY был введен в версии MySQL 3.23.0. Следует учитывать, что при приведении индексированного столбца к типу BINARY MySQL в некоторых случаях не сможет эффективно использовать индексы.

  Для сравнения двоичных данных типа BLOB без учета регистра данные с типом BLOB перед выполнением сравнения всегда можно конвертировать в верхний регистр:

  SELECT 'A' LIKE UPPER(blob_col) FROM table_name;
  

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

• +

  Сложение:

  mysql> SELECT 3+5;
          -> 8
  

• -

  Вычитание:

  mysql> SELECT 3-5;
          -> -2
  

• *

  Умножение:

  mysql> SELECT 3*5;
          -> 15
  
  mysql> SELECT 18014398509481984*18014398509481984.0;
          -> 324518553658426726783156020576256.0
  
  mysql> SELECT 18014398509481984*18014398509481984;
          -> 0
  

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

• /

  Деление:

  mysql> SELECT 3/5;
          -> 0.60
  

  Деление на ноль приводит к результату NULL:

  mysql> SELECT 102/(1-1);
          -> NULL
  

  Деление будет выполняться по правилам BIGINT-арифметики только в случае, если эта операция представлена в контексте, где ее результат преобразуется в INTEGER!

• -

  Унарный минус. Изменяет знак аргумента:

  mysql> SELECT - 2;
          -> -2
  

  Необходимо учитывать, что если этот оператор используется с данными типа BIGINT, возвращаемое значение также будет иметь тип BIGINT! Это означает, что следует избегать использования оператора для целых чисел, которые могут иметь величину -2^63!

• ABS(X)

  Возвращает абсолютное значение величины X:

  mysql> SELECT ABS(2);
          -> 2
  mysql> SELECT ABS(-32);
          -> 32
  

  Эту функцию можно уверенно применять для величин типа BIGINT.

• SIGN(X)

  Возвращает знак аргумента в виде -1, 0 или 1, в зависимости от того, является ли X отрицательным, нулем или положительным:

  mysql> SELECT SIGN(-32);
          -> -1
  
  mysql> SELECT SIGN(0);
          -> 0
  
  mysql> SELECT SIGN(234);
          -> 1
  

• MOD(N,M), %

  Значение по модулю (подобно оператору % в C). Возвращает остаток от деления N на M:

  mysql> SELECT MOD(234, 10);
          -> 4
  
  mysql> SELECT 253 % 7;
          -> 1
  
  mysql> SELECT MOD(29,9);
          -> 2
  

  Эту функцию можно уверенно применять для величин типа BIGINT.

• FLOOR(X)

  Возвращает наибольшее целое число, не превышающее X:

  mysql> SELECT FLOOR(1.23);
          -> 1
  
  mysql> SELECT FLOOR(-1.23);
          -> -2
  

  Следует учитывать, что возвращаемая величина преобразуется в BIGINT!

• CEILING(X)

  Возвращает наименьшее целое число, не меньшее, чем X:

  mysql> SELECT CEILING(1.23);
          -> 2
  
  mysql> SELECT CEILING(-1.23);
          -> -1
  

  Следует учитывать, что возвращаемая величина преобразуется в BIGINT!

• ROUND(X)

  Возвращает аргумент X, округленный до ближайшего целого числа:

  mysql> SELECT ROUND(-1.23);
          -> -1
  
  mysql> SELECT ROUND(-1.58);
          -> -2
  
  mysql> SELECT ROUND(1.58);
          -> 2
  

  Следует учитывать, что поведение функции ROUND() при значении аргумента, равном середине между двумя целыми числами, зависит от конкретной реализации библиотеки C. Округление может выполняться: к ближайшему четному числу, всегда к ближайшему большему, всегда к ближайшему меньшему, всегда быть направленным к нулю. Чтобы округление всегда происходило только в одном направлении, необходимо использовать вместо данной хорошо определенные функции, такие как TRUNCATE() или FLOOR().

• ROUND(X,D)

  Возвращает аргумент X, округленный до числа с D десятичными знаками. Если D равно 0, результат будет представлен без десятичного знака или дробной части:

  mysql> SELECT ROUND(1.298, 1);
          -> 1.3
  
  mysql> SELECT ROUND(1.298, 0);
          -> 1
  

• EXP(X)

  Возвращает значение e (основа натуральных логарифмов), возведенное в степень X:

  mysql> SELECT EXP(2);
          -> 7.389056
  
  mysql> SELECT EXP(-2);
          -> 0.135335
  

• LN(X)

  Возвращает натуральный логарифм числа X:

  mysql> SELECT LN(2);
          -> 0.693147
  mysql> SELECT LN(-2);
          -> NULL
  

  Эта функция появилась в MySQL 4.0.3. Это синоним LOG(X).

• LOG(B, X)

  Если вызывается с одним параметром, возвращает натуральный логарифм числа X:

  mysql> SELECT LOG(2);
          -> 0.693147
  
  mysql> SELECT LOG(-2);
          -> NULL
  

  Если вызывается с двумя параметрами, функция возвращает логарифм числа X по базе B:

  mysql> SELECT LOG(2,65536);
          -> 16.000000
  mysql> SELECT LOG(1,100);
          -> NULL
  

  Опция указания базы логарифма появилась в MySQL 4.0.3. LOG(B,X) эквалиентно LOG(X)/LOG(B).

• LOG2(X)

  Возвращает логарифм числа X по базе 2:

  mysql> SELECT LOG2(65536);
          -> 16.000000
  mysql> SELECT LOG2(-100);
          -> NULL
  

  Функция LOG2() полезна с тем, чтобы узнать, сколько бит число потребует для хранения. Эта функция добавлена в MySQL 4.0.3. В более старых версиях вызывайте вместо нее: LOG(X)/LOG(2)

• LOG10(X)

  Возвращает десятичный логарифм числа X:

  mysql> SELECT LOG10(2);
          -> 0.301030
  
  mysql> SELECT LOG10(100);
          -> 2.000000
  
  mysql> SELECT LOG10(-100);
          -> NULL
  

• POW(X,Y), POWER(X,Y)

  Возвращает значение аргумента X, возведенное в степень Y:

  mysql> SELECT POW(2,2);
          -> 4.000000
  
  mysql> SELECT POW(2,-2);
          -> 0.250000
  

• SQRT(X)

  Возвращает неотрицательный квадратный корень числа X:

  mysql> SELECT SQRT(4);
          -> 2.000000
  
  mysql> SELECT SQRT(20);
          -> 4.472136
  

• PI()

  Возвращает значение числа "пи". По умолчанию представлено 5 десятичных знаков, но в MySQL для представления числа "пи" при внутренних вычислениях используется полная двойная точность.

  mysql> SELECT PI();
          -> 3.141593
  
  mysql> SELECT PI()+0.000000000000000000;
          -> 3.141592653589793116
  

• COS(X)

  Возвращает косинус числа X, где X задается в радианах:

  mysql> SELECT COS(PI());
          -> -1.000000
  

• SIN(X)

  Возвращает синус числа X, где X задается в радианах:

  mysql> SELECT SIN(PI());
          -> 0.000000
  

• TAN(X)

  Возвращает тангенс числа X, где X задается в радианах:

  mysql> SELECT TAN(PI()+1);
          -> 1.557408
  

• ACOS(X)

  Возвращает арккосинус числа X, т.е. величину, косинус которой равен X. Если X не находится в диапазоне от -1 до 1, возвращает NULL:

  mysql> SELECT ACOS(1);
          -> 0.000000
  
  mysql> SELECT ACOS(1.0001);
          -> NULL
  
  mysql> SELECT ACOS(0);
          -> 1.570796
  

• ASIN(X)

  Возвращает арксинус числа X, т.е. величину, синус которой равен X. Если X не находится в диапазоне от -1 до 1, возвращает NULL:

  mysql> SELECT ASIN(0.2);
          -> 0.201358
  
  mysql> SELECT ASIN('foo');
          -> 0.000000
  

• ATAN(X)

  Возвращает арктангенс числа X, т.е. величину, тангенс которой равен X:

  mysql> SELECT ATAN(2);
          -> 1.107149
  
  mysql> SELECT ATAN(-2);
          -> -1.107149
  

• ATAN(Y,X), ATAN2(Y,X)

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

  mysql> SELECT ATAN(-2,2);
          -> -0.785398
  
  mysql> SELECT ATAN2(PI(),0);
          -> 1.570796
  

• COT(X)

  Возвращает котангенс числа X:

  mysql> SELECT COT(12);
          -> -1.57267341
  
  mysql> SELECT COT(0);
          -> NULL
  

• RAND(), RAND(N)

  Возвращает случайную величину с плавающей точкой в диапазоне от 0 до 1,0. Если целочисленный аргумент N указан, то он используется как начальное значение этой величины:

  mysql> SELECT RAND();
          -> 0.9233482386203
  
  mysql> SELECT RAND(20);
          -> 0.15888261251047
  
  mysql> SELECT RAND(20);
          -> 0.15888261251047
  
  mysql> SELECT RAND();
          -> 0.63553050033332
  
  mysql> SELECT RAND();
          -> 0.70100469486881
  

  В выражениях вида ORDER BY не следует использовать столбец с величинами RAND(), поскольку применение оператора ORDER BY приведет к многократным вычислениям в этом столбце. В версии MySQL 3.23 можно, однако, выполнить следующий оператор: SELECT * FROM table_name ORDER BY RAND(): он полезен для получения случайного экземпляра из множества SELECT * FROM table1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000. Следует учитывать, что оператор RAND() в выражении WHERE при выполнении выражения WHERE будет вычисляться каждый раз заново. Оператор RAND() не следует воспринимать как полноценный генератор случайных чисел: это просто быстрый способ динамической генерации случайных чисел, переносимых между платформами для одной и той же версии MySQL.

• LEAST(X,Y,...)

  Если задано два или более аргументов, возвращает наименьший (с минимальным значением) аргумент. Сравнение аргументов происходит по следующим правилам:

  • Если возвращаемая величина используется в целочисленном контексте (INTEGER), или все аргументы являются целочисленными, то они сравниваются как целые числа.

  • Если возвращаемая величина используется в контексте действительных чисел (REAL) или все аргументы являются действительными числами, то они сравниваются как числа типа REAL.

  • Если один из аргументов является зависимой от регистра строкой, то данные аргументы сравниваются с учетом регистра.

  • В остальных случаях аргументы сравниваются как строки, независимые от регистра.

  mysql> SELECT LEAST(2,0);
          -> 0
  
  mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
          -> 3.0
  
  mysql> SELECT LEAST("B","A","C");
          -> "A"
  

  В версиях MySQL до 3.22.5 можно использовать MIN() вместо LEAST.

• GREATEST(X,Y,...)

  Возвращает наибольший (с максимальным значением) аргумент. Сравнение аргументов происходит по тем же правилам, что и для 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 можно использовать MAX() вместо GREATEST.

• DEGREES(X)

  Возвращает аргумент X, преобразованный из радианов в градусы:

  mysql> SELECT DEGREES(PI());
          -> 180.000000
  

• RADIANS(X)

  Возвращает аргумент X, преобразованный из градусов в радианы:

  mysql> SELECT RADIANS(90);
          -> 1.570796
  

• TRUNCATE(X,D)

  Возвращает число X, усеченное до D десятичных знаков. Если D равно 0, результат будет представлен без десятичного знака или дробной части:

  mysql> SELECT TRUNCATE(1.223,1);
          -> 1.2
  mysql> SELECT TRUNCATE(1.999,1);
          -> 1.9
  mysql> SELECT TRUNCATE(1.999,0);
          -> 1
  mysql> SELECT TRUNCATE(-1.999,1);
          -> -1.9
  

  Начиная с MySQL 3.23.51 все числа округляются к нулю.

  Если D - негативное, то тогда вся часть числа обнуляется:

  mysql> SELECT TRUNCATE(122,-2);
         -> 100
  

  Следует учитывать, что обычно в компьютерах десятичные числа хранятся не так, как целые, а как числа двойной точности с плавающим десятичным знаком (DOUBLE). Поэтому иногда результат может вводить в заблуждение, как в следующем примере:

  mysql> SELECT TRUNCATE(10.28*100,0);
          -> 1027
  

  Это происходит потому, что в действительности 10,28 хранится как нечто вроде 10,2799999999999999.

• |

  Побитовое ИЛИ

  mysql> SELECT 29 | 15;
          -> 31
  

  Результат является беззнаковым 64-битовым целым числом.

• &

  Побитовое И

  mysql> SELECT 29 & 15;
          -> 13
  

  Результат является беззнаковым 64-битовым целым числом.

• ^

  Побитовый XOR (побитовое сложение по модулю 2)

  mysql> SELECT 1 ^ 1;
          -> 0
  mysql> SELECT 1 ^ 0;
          -> 1
  mysql> SELECT 11 ^ 3;
          -> 8
  

  Результат - беззнаковое 64-битное целое число.

  XOR был реализован в MySQL 4.0.2.

• <<

  Сдвиг числа двойной длины (BIGINT) влево:

  mysql> SELECT 1 << 2;
          -> 4
  

  Результат является беззнаковым 64-битовым целым числом.

• >>

  Сдвиг числа двойной длины (BIGINT) вправо:

  mysql> SELECT 4 >> 2;
          -> 1
  

  Результат является беззнаковым 64-битовым целым числом.

• ~

  Инвертировать все биты:

  mysql> SELECT 5 & ~1;
          -> 4
  

  Результат является беззнаковым 64-битовым целым числом.

• BIT_COUNT(N)

  Возвращает число битов, указанное в аргументе N:

  mysql> SELECT BIT_COUNT(29);
          -> 4
  

• DATABASE()

  Возвращает имя текущей базы данных:

  mysql> SELECT DATABASE();
          -> 'test'
  

  Если в данное время нет активной базы данных, то функция DATABASE() возвращает пустую строку.

• USER(), SYSTEM_USER(), SESSION_USER()

  Возвращает имя текущего активного пользователя MySQL:

  mysql> SELECT USER();
          -> 'davida@localhost'
  

  В версии MySQL 3.22.11 или более поздней данная функция включает в себя имя хоста клиента, а также имя пользователя. Можно извлечь часть, касающуюся только имени пользователя, приведенным ниже способом (проверяется, включает ли данная величина имя хоста):

  mysql> SELECT SUBSTRING_INDEX(USER(),"@",1);
          -> 'davida'
  

• CURRENT_USER()

  Возвращает текущее имя пользователя, под которым пользователь аутентифицировался в текущей сессии:

  mysql> SELECT USER();
          -> 'davida@localhost'
  mysql> SELECT * FROM mysql.user;
          -> ERROR 1044: Access denied for user: '@localhost' to database 'mysql'
  mysql> SELECT CURRENT_USER();
          -> '@localhost'
  

• PASSWORD(str), OLD_PASSWORD(str)

  Создает строку "пароля" из простого текста в аргументе str. Именно эта функция используется в целях шифрования паролей MySQL для хранения в столбце Password в таблице привилегий user:

  mysql> SELECT PASSWORD('badpwd');
          -> '7f84554057dd964b'
  

  Шифрование, которое выполняет функция PASSWORD(), необратимо. Способ шифрования пароля, который используется функцией PASSWORD(), отличается от применяемого для шифрования паролей в Unix.

  Функция PASSWORD() используется в системе аутентификации в сервер MySQL, вам не следует использовать ее для ваших собственных приложений. С этой целью, лучше используйте функции MD5() и SHA1().

• ENCRYPT(str[,salt])

  Шифрует аргумент str, используя вызов системной функции кодирования crypt() из Unix. Аргумент salt должен быть строкой из двух символов (в версии MySQL 3.22.16 аргумент salt может содержать более двух символов):

  mysql> SELECT ENCRYPT("hello");
          -> 'VxuFAJXVARROc'
  

  Если функция crypt() в данной операционной системе недоступна, функция ENCRYPT() всегда возвращает NULL. Функция ENCRYPT() игнорирует все символы в аргументе str, за исключением первых восьми, по крайней мере в некоторых операционных системах - это определяется тем, как реализован системный вызов базовой функции crypt().

• ENCODE(str,pass_str)

  Шифрует str, используя аргумент pass_str как пароль. Для расшифровки результата следует использовать функцию DECODE(). Результат представляет собой двоичную строку той же длины, что и string. Для хранения результата в столбце следует использовать столбец типа BLOB.

• DECODE(crypt_str,pass_str)

  Расшифровывает зашифрованную строку crypt_str, используя аргумент pass_str как пароль. Аргумент crypt_str должен быть строкой, возвращаемой функцией ENCODE().

• MD5(string)

  Вычисляет 128-битовую контрольную сумму MD5 для аргумента string. Возвращаемая величина представляет собой 32-разрядное шестнадцатеричное число, которое может быть использовано, например, в качестве хеш-ключа:

  mysql> SELECT MD5("testing");
          -> 'ae2b1fca515949e5d54fb22b8ed95575'
  

  Это "RSA Data Security, Inc. MD5 Message-Digest Algorithm".

• SHA1(string), SHA(string)

  Вычисляет 160-битовую контрольную сумму SHA1 для аргумента string, как описано в RFC 3174 (Secure Hash Algorithm). Возвращаемая величина представляет собой 40-разрядное шестнадцатеричное число или NULL (в том случае, если входной аргумент был равен NULL). Одно из возможных применений для этой функции - в качестве хеш-ключа. Можно ее использовать и как криптографически безопасную функцию для сохранения паролей.

  mysql> SELECT SHA1("abc");
          -> 'a9993e364706816aba3e25717850c26c9cd0d89d'
  

  Функция SHA1() была добавлена в версии 4.0.2, и может рассматриваться как более защищенный криптографически эквивалент функции MD5(). SHA() является синонимом для функции SHA1().

• AES_ENCRYPT(string,key_string), AES_DECRYPT(string,key_string)

  Эти функции позволяют шифровать/дешифровать данные, используя официальный алгоритм AES (Advanced Encryption Standard) (предыдущее название - Rijndael). В нем применяется кодирование с 128-битовым ключом, однако при помощи патча к исходному коду длину ключа можно увеличить до 256 битов. В MySQL выбран 128-битовый ключ, поскольку он работает намного быстрее и обычно обеспечивает вполне достаточную защищенность. Входные аргументы могут быть любой длины. Если один из аргументов равен NULL, то результат этой функции также будет иметь значение NULL.

  Так как AES является алгоритмом блочного уровня, то для декодирования используется дополнение строк нечетной длины, так, чтобы длина результирующей строки могла вычисляться как выражение 16*(trunc(длина_строки/16)+1).

  Если AES_DECRYPT() обнаруживает некорректные данные или некорректное заполнение строки (имеет в виду padding - прим. пер.), функция вернет NULL. Однако AES_DECRYPT() вполне может вернуть не-NULL величину, или, возможно, просто мусор, если входные данных или ключ - некорректны.

  AES_DECRYPT() имеет также модификацию, возвращающую величину со значением, не равным NULL, даже при неправильном ключе. Функции AES можно использовать для хранения данных в зашифрованном виде путем модификации запросов:

  INSERT INTO t VALUES (1,AES_ENCRYPT("text","password"));
  

  Можно добиться еще более высокого уровня защищенности за счет исключения передачи ключа через соединение для каждого запроса - для этого ключ на время соединения должен сохраняться в переменной на сервере:

  SELECT @password:="my password";
  INSERT INTO t VALUES (1,AES_ENCRYPT("text",@password));
  

  Функции AES_ENCRYPT() и AES_DECRYPT() были добавлены в версию 4.0.2 и могут рассматриваться как наиболее криптографически защищенные шифрующие функции, в настоящее время доступные в MySQL.

• DES_ENCRYPT(string_to_encrypt [, (key_number | key_string) ] )

  Шифрует строку с заданным ключом, используя алгоритм тройного DES. Следует учитывать, что эта функция работает только тогда, когда конфигурация MySQL поддерживает SSL. See Раздел 4.3.9, «Использование безопасных соединений». Ключ для использования при шифровании выбирается следующим образом:

  Аргумент	Описание
  Только один аргумент	Используется первый ключ из des-key-file
  Номер ключа	Используется заданный ключ (0-9) из des-key-file
  Строка	Для шифрования string_to_encrypt может использоваться ключ, заданный в key_string

  Функция возвращает двоичную строку, в которой первый символ будет CHAR(128 | key_number). Число 128 добавлено для упрощения распознавания зашифрованного ключа. При использовании строкового ключа key_number будет равен 127. При ошибке эта функция возвращает NULL. Длина строки в результате будет равна new_length=org_length + (8-(org_length % 8))+1. Выражение des-key-file имеет следующий форматt:

  key_number des_key_string
  key_number des_key_string
  

  Каждый элемент key_number должен быть числом от 0 до 9. Строки в данном файле могут располагаться в произвольном порядке. Выражение des_key_string представляет собой строку, которая будет использована при шифровании сообщения. Между числом и ключом должен быть по крайней мере один пробел. Первый ключ используется по умолчанию, если не задан какой-либо аргумент ключа в функции DES_ENCRYPT(). Существует возможность послать MySQL запрос на чтение новых значений ключей из файла ключей при помощи команды FLUSH DES_KEY_FILE. Эта операция требует наличия привилегии Reload_priv. Одно из преимуществ наличия набора ключей по умолчанию состоит в том, что приложения могут проверять существование зашифрованных величин в столбцах без предоставления конечному пользователю права расшифровки этих величин.

  mysql> SELECT customer_address FROM customer_table WHERE
          crypted_credit_card = DES_ENCRYPT("credit_card_number");
  

• DES_DECRYPT(string_to_decrypt [, key_string])

  Дешифрует строку, зашифрованную с помощью функции DES_ENCRYPT(). Следует учитывать, что эта функция работает только тогда, когда конфигурация MySQL поддерживает SSL. See Раздел 4.3.9, «Использование безопасных соединений». Если аргумент key_string не задан, то функция DES_DECRYPT() проверяет первый байт зашифрованной строки для определения номера ключа алгоритма DES, использованного для шифрования исходной строки, Затем читает ключ из des-key-file для расшифровки сообщения. Чтобы выполнить это, пользователь должен обладать привилегией SUPER. При указании значения аргумента в key_string эта строка используется как ключ для дешифровки сообщения. Если строка string_to_decrypt не выглядит как зашифрованная, то MySQL вернет заданную строку string_to_decrypt. При ошибке эта функция возвращает NULL.

• LAST_INSERT_ID([expr])

  Возвращает последнюю автоматически сгенерированную величину, которая была внесена в столбец AUTO_INCREMENT. See Раздел 8.4.3.31, «mysql_insert_id()».

  mysql> SELECT LAST_INSERT_ID();
          -> 195
  

  Значение последнего сгенерированного ID сохраняется на сервере для данного конкретного соединения и не будет изменено другим клиентом. Оно не будет изменено даже при обновлении другого столбца AUTO_INCREMENT конкретной величиной (то есть, которая не равна NULL и не равна 0). При внесении большого количества строк с помощью одной команды INSERT функция LAST_INSERT_ID() возвращает значение для первой внесенной строки. Причина этого заключается в том, что можно легко воспроизвести точно такую же команду INSERT на другом сервере.

  Если задано значение аргумента expr в функции LAST_INSERT_ID(), то величина аргумента возвращается функцией и устанавливается в качестве следующего значения, которое будет возвращено функцией LAST_INSERT_ID(). Это можно использовать для моделирования последовательностей:

  Вначале создается таблица:

  mysql> CREATE TABLE sequence (id INT NOT NULL);
  mysql> INSERT INTO sequence VALUES (0);
  

  Затем данную таблицу можно использовать для генерации чисел последовательности как показано ниже:

  mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
  

  Можно генерировать последовательности без вызова LAST_INSERT_ID(): полезность применения данной функции состоит в том, что данное значение ID поддерживается на сервере как последняя автоматически сгенерированная величина (защищенная от других пользователей), и вы можете извлекать новый ID так же, как и любое другое нормальное значение AUTO_INCREMENT в MySQL. Например, функция LAST_INSERT_ID() (без аргумента) возвратит новое значение ID. Функцию C API mysql_insert_id() также можно использовать для получения этой величины. Следует учитывать, что, поскольку функция mysql_insert_id() обновляется только после команд INSERT и UPDATE, то нельзя использовать эту функцию C API для извлечения значения ID для LAST_INSERT_ID(expr) после выполнения других команд SQL, таких как SELECT или SET.

• FORMAT(X,D)

  Форматирует число X в формат вида '#,###,###.##' с округлением до D десятичных знаков. Если D равно 0, результат будет представлен без десятичной точки или дробной части:

  mysql> SELECT FORMAT(12332.123456, 4);
          -> '12,332.1235'
  
  mysql> SELECT FORMAT(12332.1,4);
          -> '12,332.1000'
  
  mysql> SELECT FORMAT(12332.2,0);
          -> '12,332'
  

• VERSION()

  Возвращает строку с номером версии сервера MySQL:

  mysql> SELECT VERSION();
          -> '3.23.13-log'
  

  Следует учитывать, что если данная версия заканчивается с -log, то это означает, что включено ведение журналов.

• CONNECTION_ID()

  Возвращает идентификатор (thread_id) для данного соединения. Каждое соединение имеет свой собственный уникальный идентификатор:

  mysql> SELECT CONNECTION_ID();
          -> 1
  

• GET_LOCK(str,timeout)

  Пытается осуществить блокировку по имени, которое заданно в строке str, с временем ожидания в секундах, указанном в аргументе timeout. Возвращает 1, если блокировка осуществлена успешно, 0 - если закончилось время ожидания для данной попытки, или NULL, если возникла ошибка (такая как отсутствие свободной памяти или уничтожение потока командой mysqladmin kill).

  Блокировка снимается при выполнении команды RELEASE_LOCK(), запуске новой команды GET_LOCK() или при завершении данного потока. Эту функцию можно использовать для осуществления блокировок уровня приложения или для моделирования блокировки записи. Функция блокирует запросы других клиентов на блокировку с тем же именем; клиенты, которые используют согласованные имена блокировок, могут применять эту функцию для выполнения совместного упредительного блокирования:

  mysql> SELECT GET_LOCK("lock1",10);
          -> 1
  mysql> SELECT IS_FREE_LOCK("lock2");
          -> 1
  mysql> SELECT GET_LOCK("lock2",10);
          -> 1
  mysql> SELECT RELEASE_LOCK("lock2");
          -> 1
  mysql> SELECT RELEASE_LOCK("lock1");
          -> NULL
  

  Обратите внимание: повторный вызов функции RELEASE_LOCK() возвращает NULL, поскольку блокировка lock1 была автоматически выполнена вторым вызовом функции GET_LOCK().

• RELEASE_LOCK(str)

  Снимает блокировку, указанную в строке str, полученной от функции GET_LOCK(). Возвращает 1 если блокировка была снята, 0 - если такая блокировка уже поставлена в другом соединении (в этом случае блокировка не снимается) и NULL, если блокировки с указанным именем не существует. Последнее может произойти в случае, когда вызов функции GET_LOCK() не привел к успешному результату или данная блокировка уже снята. Функцию RELEASE_LOCK() удобно использовать совместно с командой DO. See Раздел 6.4.10, «Синтаксис оператора DO».

• IS_FREE_LOCK(str)

  Проверяет, свободна ли блокировка по имени str (т.е. не установлена). Возвращает 1 если блокировка свободна (никто не поставил таковую). Возвращает 0 если блокировка установлена и NULL в случае ошибки (например, при неправильных аргументах).

• BENCHMARK(count,expr)

  Функция BENCHMARK() повторяет выполнение выражения expr заданное количество раз, указанное в аргументе count. Она может использоваться для определения того, насколько быстро MySQL обрабатывает данное выражение. Значение результата всегда равно 0. Функция предназначена для использования в клиенте mysql, который сообщает о времени выполнения запроса:

  mysql> SELECT BENCHMARK(1000000,ENCODE("hello","goodbye"));
  +----------------------------------------------+
  | BENCHMARK(1000000,ENCODE("hello","goodbye")) |
  +----------------------------------------------+
  |                                            0 |
  +----------------------------------------------+
  1 row in set (4.74 sec)
  

  Указанное в отчете время представляет собой время, подсчитанное на стороне клиента, а не время, затраченное центральным процессором (CPU time) на сервере. Может оказаться целесообразным выполнить BENCHMARK() несколько раз, чтобы выяснить, насколько интенсивно загружен серверный компьютер.

• INET_NTOA(expr)

  По заданному числовому адресу сети (4 или 8 байтов) возвращает представление указанного адреса в виде разделенных точками четырех октетов в виде строки:

  mysql> SELECT INET_NTOA(3520061480);
          -> "209.207.224.40"
  

• INET_ATON(expr)

  По заданному представлению сетевого адреса в виде строки, содержащей разделенные точками четыре октета, функция возвращает целое число, представляющее собой числовое значение данного адреса. Адреса могут быть длиной 4 или 8 байтов:

  mysql> SELECT INET_ATON("209.207.224.40");
          -> 3520061480
  

  Результирующее число всегда генерируется в соответствии с порядком расположения октетов в сетевом адресе, например вышеприведенное число вычисляется как 209*256^3 + 207*256^2 + 224*256 +40.

• MASTER_POS_WAIT(log_name, log_pos)

  Блокируется, пока подчиненный сервер не достигнет определенной точки положения в журнале репликации головного сервера (т.е. не прочитает и не выполнит все операции до указанной позиции).

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

  Если timeout (новшество в 4.0.10) указан, то ожидание прекратится по прошествии timeout секунд. Таймаут должен быть больше 0. 0 или негативный таймаут означает тоже самое что и отсутствие таймаута.

  Возвращаемая величина представляет собой число событий в журнале, которые функция должна была ``переждать'', пока сервер дойдет до указанной точки, NULL в случае ошибки или -1 в случае, если истек таймаут.

• FOUND_ROWS()

  Возвращает количество строк, которые возвратила бы последняя команда SELECT SQL_CALC_FOUND_ROWS ... при отсутствии ограничения оператором LIMIT.

  mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name WHERE id > 100 LIMIT 10;
  mysql> SELECT FOUND_ROWS();
  

  Второй вызов команды SELECT возвратит количество строк, которые возвратила бы первая команда SELECT, если бы она была написана без выражения LIMIT. Отметим, что, хотя при использовании команды SELECT SQL_CALC_FOUND_ROWS ..., MySQL должен пересчитать все строки в наборе результатов, этот способ все равно быстрее, чем без LIMIT, так как не требуется посылать результат клиенту.

  Функция SQL_CALC_FOUND_ROWS появилась в MySQL 4.0.0.