Обработка ошибок mysql php

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

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

Ошибка соединения с базой данных

Сразу приведём пример обработки ошибки с соединением с базой данных:

<?php 
   $host = 'localhost'; // адрес сервера
   $db_name = 'database'; // имя базы данных
   $user = 'user'; // имя пользователя
   $password = 'password'; // пароль

   // создание подключения к базе   
      $connection = mysqli_connect($host, $user, $password, $db_name);

   // проверка правильности подключения
      if(!$connection){ // при соединении с базой данных возникла ошибка
         echo 'Ошибка соединения: ' . mysqli_connect_error() . '<br>';
         echo 'Код ошибки: ' . mysqli_connect_errno();
      }else{ // соединение было установлено успешно
         // здесь можно делать запрос к базе, 
         // потому что соединение успешно установлено
      }
?>

В этом примере можно заметить функцию mysqli_connect_error. Она выводит текстовое описание ошибки подключения (на английском языке). В отличии от неё функция mysqli_connect_errno выводит числовой код ошибки, к примеру «1045».

Ошибка запроса к базе

Теперь попробуем доработать пример из предыдущего параграфа и добавить запрос к базе данных. Не будем вдаваться в детали, что будет записано в тексте SQL запроса, просто предположим, что он может завершиться ошибкой. К примеру, из-за неожиданного отключения сервера с базой данных от сети. В примере добавим проверку на наличие ошибок при выполнении запроса:

<?php 
   $host = 'localhost'; // адрес сервера
   $db_name = 'database'; // имя базы данных
   $user = 'user'; // имя пользователя
   $password = 'password'; // пароль

   // создание подключения к базе   
      $connection = mysqli_connect($host, $user, $password, $db_name);

      if(!$connection){ // проверка правильности подключения
         echo 'Ошибка соединения: ' . mysqli_connect_error() . '<br>';
         echo 'Код ошибки: ' . mysqli_connect_errno();
      }else{ // подключение успешно установлено

         // текст SQL запроса, который будет передан базе
            $query = 'SELECT * FROM `USERS`';

         // выполняем запрос к базе данных
            $result = mysqli_query($connection, $query);

            if(!$result){ // запрос завершился ошибкой
               echo 'Ошибка запроса: ' . mysqli_error($connection) . '<br>';
               echo 'Код ошибки: ' . mysqli_errno($connection);
            }else{ // запрос успешно выполнился
               while($row = $result->fetch_assoc()){
                  // обрабатываем полученные данные
               }
            }
         // закрываем соединение с базой
            mysqli_close($connection);
      }
?>

В этом примере есть две функции, которые работают с ошибками базы. Функция mysqli_error возвращает описание ошибки запроса (на английском языке), а функция mysqli_errno возвращает числовой код ошибки, к примеру, «1193».

Обратите внимание, что все функции обработки ошибок в этой статье (mysqli_connect_error, mysqli_connect_errno, mysqli_error, mysqli_errno) возвращают информацию только о последней ошибке. Но ошибок может быть несколько.

Была ли эта статья полезна?

Есть вопрос?

Закажите недорогой хостинг

Заказать

всего от 290 руб

Error message: Unknown system variable 'a'

Библиотека mysqli — своеобразный мостик между процедурным и объектно-ориентированным стилем программирования. Поэтому она поддерживает два подхода обработки ошибок: процедурный и через исключения.

Первый, процедурный подход — вы проверяете результат выполнения каждой функции и если возвращается false, получаете сообщение при помощи функции mysqli_error()

$db = mysqli_connect("localhost", "user", "...", "test");
if (mysqli_connect_errno()) {
  echo "Ошибка установки соединения" . mysqli_connect_error();
  exit();
}
$sql = "INSERT INTO users (login, email, password, datetime) VALUES (?, ?, ?, ?)";
$stmt = mysqli_prepare($db, $sql);
if(!$stmt) {
  echo "Ошибка подготовки запроса: " . mysqli_error($db);
  exit();
}
if(!mysqli_stmt_bind_param($stmt, 'ssss', $login, $email, $password, $datetime)) {
  echo "Ошибка связывания параметров: " . mysqli_error($db);
  exit();
}
if(!mysqli_stmt_execute($stmt)) {
  echo "Ошибка выполнения запроса: " . mysqli_error($db);
  exit();
}
mysqli_stmt_close($stmt);
mysqli_close($db);

Разумеется это не очень удобно, особенно, в объектно-ориентированном коде, поэтому mysqli позволяет переключиться в режим генерации исключений (их несколько типов, в режиме отладки наиболее удобно использовать MYSQLI_REPORT_ALL). Задать режим можно при помощи функции mysqli_report()

mysqli_report(MYSQLI_REPORT_ALL); 

try {
  $db = mysqli_connect("localhost", "user", "...", "test");

  $sql = "INSERT INTO users (login, email, password, datetime) VALUES (?, ?, ?, ?)";
  $stmt = mysqli_prepare($db, $sql);
  mysqli_stmt_bind_param($stmt, 'ssss', $login, $email, $password, $datetime);
  mysqli_stmt_execute($stmt);
  mysqli_stmt_close($stmt);
  mysqli_close($db);
} catch (Exception $e) {
  echo $e->getMessage();
} 

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

Если выбирать из этих двух, то второй, разумеется. Он на порядок лучше первого:
— в отличие от первого, он будет выдавать ошибки туда же, куда и весь остальной РНР. На машине разработчика это может быть экран, на боевом сайте — лог. Первый плюёт ошибки в браузер ВСЕГДА, чего на боевом сайте не должно быть никогда
— в отличие от первого, он сообщит номер строки и имя файла, где произошла ошибка, что является критически важным для того самого отлова ошибки. Рекомендую попробовать поискать ошибочный запрос в коде на пару тысяч строк по сообщению от первого варианта. Подробнее про то, как правильно обрабатывать ошибки, можно почитать здесь: Обработка ошибок, часть 1

Примечание: на самом деле ни тот, ни другой коды работать не будут, поскольку mysqli_error() тоже требует $link в обязательном порядке.

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

mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);

и после этого любая ошибка mysqli будет порождать исключение.
Но у этого подхода есть два минуса:
1. Такой вариант может понадобиться только в случае, если обращения к mysqli_query разбросаны по всему коду, чего делать нельзя ни в коем случае.
2. В брошенном исключении будет отсутствовать сам запрос, который может быть очень полезен при отладке.

Поэтому идеальным вариантом будет такой:
Во-первых, все обращения к mysqli API в обязательном порядке надо завернуть в какую-либо библиотеку, которая возьмёт на себя выполнение всей грязной и повторяющейся работы. Пример такой библиотеки — SafeMysql
Во-вторых, в этой библиотеке оформить код обращения к mysqli_query такм образом:

$res = $link->query($query);
if (!$res) throw new Exception($link->error() ." [$query]");

В результате мы получим идеальную обработку ошибок:
— этот код уже из коробки будет так же следовать настройкам РНР, и не будет выдавать ошибки на экран на боевом сервере, но при этом программист всегда будет о ней проинформирован.
— этот код будет выдавать трассировку вызовов — бесценную информацию, без которой найти место, где произошла ошибка, будет очень сложно.
— брошенное исключение можно будет поймать в хендлере или блоке try..catch (однако если нет опыта работы с этими двумя вещами, то на первое время лучше оставить исключение как есть. В обработке ошибок есть много нюансов, неизвестных среднему кодеру, и поэтому лучше оставить эту задачу для РНР).

Fatal error: Uncaught PDOException: SQLSTATE[42S02]: Base table or view not found: 1146 Table 'testdb.wrongtable' doesn't exist in /tmp/pdo_test.php:10
Stack trace:
#0 /tmp/pdo_test.php(10): PDO->query('SELECT wrongcol...')
#1 {main}
  thrown in /tmp/pdo_test.php on line 10

Warning: PDO::query(): SQLSTATE[42S02]: Base table or view not found: 1146 Table 'test.wrongtable' doesn't exist in
/tmp/pdo_test.php on line 9

Вступление

Интерфейс mysqli является улучшением (это означает расширение MySQL Improvement) интерфейса mysql , которое устарело в версии 5.5 и удалено в версии 7.0. Расширение mysqli, или, как его иногда называют, улучшенное расширение MySQL, было разработано для использования новых функций, обнаруженных в версиях MySQL версии 4.1.3 и новее. Расширение mysqli включено в версии PHP 5 и более поздних версий.

замечания

MySQLi connect

Объектно-ориентированный стиль

Подключение к серверу

$conn = new mysqli("localhost","my_user","my_password");

Установите базу данных по умолчанию: $conn->select_db("my_db");

Подключение к базе данных

$conn = new mysqli("localhost","my_user","my_password","my_db");

Процедурный стиль

Подключение к серверу

$conn = mysqli_connect("localhost","my_user","my_password");

Задайте базу данных по умолчанию: mysqli_select_db($conn, "my_db");

Подключение к базе данных

$conn = mysqli_connect("localhost","my_user","my_password","my_db");

Проверить подключение к базе данных

Объектно-ориентированный стиль

if ($conn->connect_errno > 0) {
    trigger_error($db->connect_error);
} // else: successfully connected

Процедурный стиль

if (!$conn) {
   trigger_error(mysqli_connect_error());
} // else: successfully connected

Функция query принимает действительную строку SQL и выполняет ее непосредственно против соединения с базой данных $conn

Объектно-ориентированный стиль

$result = $conn->query("SELECT * FROM `people`");

Процедурный стиль

$result = mysqli_query($conn, "SELECT * FROM `people`");

ВНИМАНИЕ

Общей проблемой здесь является то, что люди просто выполняют запрос и ожидают его работы (т. Е. Возвращают объект mysqli_stmt ). Поскольку эта функция принимает только строку, вы сначала создаете запрос. Если в SQL вообще имеются ошибки, компилятор MySQL завершится неудачно, и в этот момент эта функция вернет false .

$result = $conn->query('SELECT * FROM non_existent_table'); // This query will fail
$row = $result->fetch_assoc();

Вышеприведенный код генерирует ошибку E_FATAL потому что $result является false , а не объектом.

PHP Неустранимая ошибка: вызов функции-члена fetch_assoc () для не-объекта

Процедурная ошибка похожа, но не фатальная, потому что мы просто нарушаем ожидания функции.

$row = mysqli_fetch_assoc($result); // same query as previous

Вы получите следующее сообщение от PHP

mysqli_fetch_array () ожидает, что параметр 1 будет mysqli_result, boolean given

Вы можете избежать этого, выполнив сначала тест

if($result) $row = mysqli_fetch_assoc($result);

Цикл через результаты MySQLi

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

• mysqli_fetch_assoc — Ассоциативный массив с именами столбцов в виде ключей
• mysqli_fetch_object — объект stdClass с именами столбцов в качестве переменных
• mysqli_fetch_array — ассоциативный и числовой массив (могут использовать аргументы для получения того или другого)
• mysqli_fetch_row — числовой массив

Объектно-ориентированный стиль

while($row = $result->fetch_assoc()) {
    var_dump($row);
}

Процедурный стиль

while($row = mysqli_fetch_assoc($result)) {
    var_dump($row);
}

Чтобы получить точную информацию из результатов, мы можем использовать:

while ($row = $result->fetch_assoc()) {
    echo 'Name and surname: '.$row['name'].' '.$row['surname'].'<br>';
    echo 'Age: '.$row['age'].'<br>'; // Prints info from 'age' column
}

Закрыть соединение

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

Объектно-ориентированный стиль

$conn->close();

Процедурный стиль

mysqli_close($conn);

Примечание . Соединение с сервером будет закрыто, как только выполнение скрипта закончится, если оно не будет закрыто ранее, явно вызвав функцию закрытия соединения.

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

Подготовленные утверждения в MySQLi

Пожалуйста, прочитайте раздел «Предотвращение SQL-инъекции с параметризованными запросами» для полного обсуждения того, почему подготовленные операторы помогают защитить ваши SQL- запросы от атак SQL Injection

Здесь переменная $conn — это объект MySQLi. См. Пример подключения MySQLi для получения более подробной информации.

Для обоих примеров предположим, что $sql

$sql = "SELECT column_1 
    FROM table 
    WHERE column_2 = ? 
        AND column_3 > ?";

? представляет значения, которые мы предоставим позже. Обратите внимание, что нам не нужны котировки для заполнителей, независимо от типа. Мы также можем предоставить только заполнители в частях данных запроса, то есть SET , VALUES и WHERE . Вы не можете использовать заполнители в частях SELECT или FROM .

Объектно-ориентированный стиль

if ($stmt = $conn->prepare($sql)) {
  $stmt->bind_param("si", $column_2_value, $column_3_value);
  $stmt->execute();

  $stmt->bind_result($column_1);
  $stmt->fetch();
  //Now use variable $column_1 one as if it were any other PHP variable
  $stmt->close();
}

Процедурный стиль

if ($stmt = mysqli_prepare($conn, $sql)) {
  mysqli_stmt_bind_param($stmt, "si", $column_2_value, $column_3_value);
  mysqli_stmt_execute($stmt);
  // Fetch data here
  mysqli_stmt_close($stmt);
}

Первый параметр $stmt->bind_param или второй параметр mysqli_stmt_bind_param определяется типом данных соответствующего параметра в SQL-запросе:

параметр	Тип данных связанного параметра
i	целое число
d	двойной
s	строка
b	капля

Ваш список параметров должен быть в порядке, указанном в вашем запросе. В этом примере si означает, что первый параметр ( column_2 = ? ) Является строкой, а второй параметр ( column_3 > ? ) Является целым числом.

Сведения о получении данных см. В разделе Как получить данные из подготовленного оператора

Исключение строк

Экранирование строк — это более старый ( и менее безопасный ) способ обеспечения безопасности данных для вставки в запрос. Он работает с использованием функции MySQL mysql_real_escape_string () для обработки и дезинфекции данных (другими словами, PHP не выполняет экранирование). API MySQLi обеспечивает прямой доступ к этой функции

$escaped = $conn->real_escape_string($_GET['var']);
// OR
$escaped = mysqli_real_escape_string($conn, $_GET['var']);

На данный момент у вас есть строка, которую MySQL считает безопасной для использования в прямом запросе

$sql = 'SELECT * FROM users WHERE username = "' . $escaped . '"';
$result = $conn->query($sql);

Так почему же это не так безопасно, как подготовленные заявления ? Есть способы обмануть MySQL для создания строки, которую он считает безопасным. Рассмотрим следующий пример

$id = mysqli_real_escape_string("1 OR 1=1");    
$sql = 'SELECT * FROM table WHERE id = ' . $id;

1 OR 1=1 не представляет данные, которые MySQL выйдет, но это все еще представляет SQL-инъекцию. Существуют и другие примеры, которые представляют собой места, где они возвращают небезопасные данные. Проблема заключается в том, что функция ускорения MySQL предназначена для обеспечения соответствия данных синтаксису SQL . Он НЕ предназначен для обеспечения того, чтобы MySQL не мог путать пользовательские данные для инструкций SQL .

Идентификатор ввода MySQLi

Получите последний идентификатор, сгенерированный запросом INSERT в таблице с столбцом AUTO_INCREMENT .

Объектно-ориентированный стиль

$id = $conn->insert_id;

Процедурный стиль

$id = mysqli_insert_id($conn);

Возвращает ноль, если ранее не было запроса на соединение, или если запрос не обновил значение AUTO_INCREMENT.

Вставить идентификатор при обновлении строк

Обычно оператор UPDATE не возвращает идентификатор вставки, поскольку идентификатор AUTO_INCREMENT возвращается только в том случае, когда новая строка была сохранена (или вставлена). Один из способов сделать обновления для нового идентификатора — использовать INSERT ... ON DUPLICATE KEY UPDATE для обновления.

Настройка для следующих примеров:

CREATE TABLE iodku (
    id INT AUTO_INCREMENT NOT NULL,
    name VARCHAR(99) NOT NULL,
    misc INT NOT NULL,
    PRIMARY KEY(id),
    UNIQUE(name)
) ENGINE=InnoDB;

INSERT INTO iodku (name, misc)
    VALUES
    ('Leslie', 123),
    ('Sally', 456);
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0
+----+--------+------+
| id | name   | misc |
+----+--------+------+
|  1 | Leslie |  123 |
|  2 | Sally  |  456 |
+----+--------+------+

Случай IODKU, выполняющий «обновление» и LAST_INSERT_ID() извлекает соответствующий id :

$sql = "INSERT INTO iodku (name, misc)
    VALUES
    ('Sally', 3333)            -- should update
    ON DUPLICATE KEY UPDATE    -- `name` will trigger "duplicate key"
    id = LAST_INSERT_ID(id),
    misc = VALUES(misc)";
$conn->query($sql);
$id = $conn->insert_id;        -- picking up existing value (2)

Случай, когда IODKU выполняет «вставку», и LAST_INSERT_ID() извлекает новый id :

$sql = "INSERT INTO iodku (name, misc)
    VALUES
    ('Dana', 789)            -- Should insert
    ON DUPLICATE KEY UPDATE
    id = LAST_INSERT_ID(id),
    misc = VALUES(misc);
$conn->query($sql);
$id = $conn->insert_id;      -- picking up new value (3)

Результирующее содержимое таблицы:

SELECT * FROM iodku;
+----+--------+------+
| id | name   | misc |
+----+--------+------+
|  1 | Leslie |  123 |
|  2 | Sally  | 3333 |  -- IODKU changed this
|  3 | Dana   |  789 |  -- IODKU added this
+----+--------+------+

Отладка SQL в MySQLi

Таким образом, ваш запрос не удался (см. MySQLi connect для того, как мы создали $conn )

$result = $conn->query('SELECT * FROM non_existent_table'); // This query will fail

Как мы узнаем, что произошло? $result является false так что это не поможет. К счастью, connect $conn может рассказать нам, что MySQL рассказал нам об ошибке

trigger_error($conn->error);

или процедурный

trigger_error(mysqli_error($conn));

Вы должны получить ошибку, аналогичную

Таблица «my_db.non_existent_table» не существует

Как получить данные из подготовленного заявления

Подготовленные заявления

См. Подготовленные операторы в MySQLi для подготовки и выполнения запроса.

Связывание результатов

Объектно-ориентированный стиль

$stmt->bind_result($forename);

Процедурный стиль

mysqli_stmt_bind_result($stmt, $forename);

Проблема с использованием bind_result заключается в том, что он требует, чтобы оператор указывал столбцы, которые будут использоваться. Это означает, что для выполнения вышеперечисленного запрос должен выглядеть так, как этот SELECT forename FROM users . Чтобы включить больше столбцов, просто добавьте их в качестве параметров в функцию bind_result (и убедитесь, что вы добавили их в SQL-запрос).

В обоих случаях мы присваиваем forename столбец в $forename переменной. Эти функции принимают столько аргументов, сколько столбцы, которые вы хотите назначить. Назначение выполняется только один раз, поскольку функция связывается по ссылке.

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

Объектно-ориентированный стиль

while ($stmt->fetch())
    echo "$forename<br />";

Процедурный стиль

while (mysqli_stmt_fetch($stmt))
    echo "$forename<br />";

Недостатком этого является то, что вы должны сразу назначить множество переменных. Это затрудняет отслеживание больших запросов. Если у вас установлен MySQL Native Driver ( mysqlnd ) , все, что вам нужно сделать, это использовать get_result .

Объектно-ориентированный стиль

$result = $stmt->get_result();

Процедурный стиль

$result = mysqli_stmt_get_result($stmt);

С этим гораздо легче работать, потому что теперь мы получаем объект mysqli_result . Это тот же объект, что и mysqli_query . Это означает, что вы можете использовать регулярный цикл результатов для получения ваших данных.

---

Что делать, если я не могу установить mysqlnd ?

Если это так, то @Sophivorus вы покрыли этот удивительный ответ .

Эта функция может выполнять задачу get_result без ее установки на сервере. Он просто перебирает результаты и строит ассоциативный массив

function get_result(mysqli_stmt $statement)
{
    $result = array();
    $statement->store_result();
    for ($i = 0; $i < $statement->num_rows; $i++)
    {
        $metadata = $statement->result_metadata();
        $params = array();
        while ($field = $metadata->fetch_field())
        {
            $params[] = &$result[$i][$field->name];
        }
        call_user_func_array(array($statement, 'bind_result'), $params);
        $statement->fetch();
    }
    return $result;
}

Затем мы можем использовать эту функцию для получения таких результатов, как если бы мы использовали mysqli_fetch_assoc()

<?php
$query = $mysqli->prepare("SELECT * FROM users WHERE forename LIKE ?");
$condition = "J%";
$query->bind_param("s", $condition);
$query->execute();
$result = get_result($query);

while ($row = array_shift($result)) {
    echo $row["id"] . ' - ' . $row["forename"] . ' ' . $row["surname"] . '<br>';
}

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

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

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

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

• Объявление обработчика
• Примеры обработки ошибок MySQL
• Пример обработчика MySQL в хранимых процедурах
  • Приоритет обработчиков MySQL
  • Использование проименованных условий ошибки

Чтобы объявить обработчик мы используем оператор DECLARE HANDLER:

DECLARE action HANDLER FOR condition_value statement;

Если значение условия совпадает со значением condition_value, MySQL выполнит оператор statement и продолжит или завершит текущий блок кода, исходя из значения action.

action может принимать следующие значения:

• CONTINUE: исполнение блокированного кода (BEGIN … END) продолжается;
• EXIT: выполнение блокированного кода, в котором был объявлен обработчик, завершается.

condition_value задает конкретное условие или класс условия, которые активируют обработчик.

condition_value может принимать одно из следующих значений:

• код ошибки MySQL;
• стандартное значение SQLSTATE. Или это может быть условие SQLWARNING, NOTFOUND или SQLEXCEPTION, которое является сокращением для класса значений SQLSTATE. Условие NOTFOUND используется для курсора или оператора SELECT INTO variable_list;
• название условия, связанного либо с кодом ошибки MySQL, либо со значением SQLSTATE.

В качестве statement может использоваться простой оператор или составной оператор, вшитый с помощью ключевых слов BEGIN и END.

Давайте рассмотрим несколько примеров объявления обработчиков.

Обработчик, приведенный ниже, означает: когда происходит ошибка, устанавливается значение переменной has_error 1 и выполнение продолжается:

DECLARE CONTINUE HANDLER FOR SQLEXCEPTION SET has_error = 1;

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

Если вы объявляете его внутри блока BEGIN END хранимой процедуры, он немедленно завершает хранимую процедуру:

DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
ROLLBACK;
SELECT 'An error has occurred, operation rollbacked and the stored procedure was terminated';
END;

Если строк для вывода больше нет, для вариантов cursor или оператора SELECT INTO, значение переменной no_row_found устанавливается равным 1 и продолжается исполнение:

DECLARE CONTINUE HANDLER FOR NOT FOUND SET no_row_found = 1;

При возникновении ошибки дублирования ключа, выдается ошибка MySQL 1062. Следующий обработчик выдает сообщение об ошибке и продолжает выполнение:

DECLARE CONTINUE HANDLER FOR 1062
SELECT 'Error, duplicate key occurred';

Во-первых, для демонстрации мы создаем новую таблицу с именем article_tags:

CREATE TABLE article_tags(
    article_id INT,
    tag_id     INT,
    PRIMARY KEY(article_id,tag_id)
);

В таблице article_tags хранятся связи между статьями и тегами. К каждой статье может относиться несколько тегов и наоборот.

Для простоты, мы не будем создавать таблицы articles и tags, а также внешние ключи в таблице article_tags.

Во-вторых, мы создаем хранимую процедуру, которая вставляет пару идентификаторов статьи и тега в таблицу article_tags:

DELIMITER $$
 
CREATE PROCEDURE insert_article_tags(IN article_id INT, IN tag_id INT)
BEGIN
 
    DECLARE CONTINUE HANDLER FOR 1062
    SELECT CONCAT('duplicate keys (',article_id,',',tag_id,') found') AS msg;
 
    -- insert a new record into article_tags
    INSERT INTO article_tags(article_id,tag_id)
    VALUES(article_id,tag_id);
 
    -- return tag count for the article
    SELECT COUNT(*) FROM article_tags;
END

В-третьих, для статьи 1 мы добавляем идентификаторы тега 1, 2 и 3, с помощью вызова хранимой процедуры insert_article_tags:

CALL insert_article_tags(1,1);
CALL insert_article_tags(1,2);
CALL insert_article_tags(1,3);

Четвертое. Давайте попробуем вставить дубликат ключа, чтобы увидеть, действительно ли вызывается обработчик:

CALL insert_article_tags(1,3);

Мы получили сообщение об ошибке. Однако, поскольку мы объявили тип обработчика CONTINUE, хранимая процедура продолжает исполняться.

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

Если мы в объявлении обработчика изменим команду CONTINUE на EXIT, мы получим только сообщение об ошибке:

DELIMITER $$
 
CREATE PROCEDURE insert_article_tags_2(IN article_id INT, IN tag_id INT)
BEGIN
 
    DECLARE EXIT HANDLER FOR SQLEXCEPTION 
    SELECT 'SQLException invoked';
 
    DECLARE EXIT HANDLER FOR 1062 
        SELECT 'MySQL error code 1062 invoked';
 
    DECLARE EXIT HANDLER FOR SQLSTATE '23000'
    SELECT 'SQLSTATE 23000 invoked';
 
    -- insert a new record into article_tags
    INSERT INTO article_tags(article_id,tag_id)
       VALUES(article_id,tag_id);
 
    -- return tag count for the article
    SELECT COUNT(*) FROM article_tags;
END

Теперь, мы можем попробовать добавить дубликат ключа, чтобы увидеть результат:

CALL insert_article_tags_2(1,3);

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

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

Обозначения SQLSTATE для многих кодов ошибок MySQL менее специфичны. SQLEXCPETION или SQLWARNING представляют собой сокращения класса значений SQLSTATES, поэтому они имеют общий характер.

На основании правил приоритета обработчиков обработчик кода ошибки MySQL, обработчик SQLSTATE и обработчик SQLEXCEPTION имеют приоритеты один, два и три соответственно.

Предположим, что в хранимой процедуре insert_article_tags_3 мы объявляем три обработчика:

DELIMITER $$
 
CREATE PROCEDURE insert_article_tags_3(IN article_id INT, IN tag_id INT)
BEGIN
 
    DECLARE EXIT HANDLER FOR 1062 SELECT 'Duplicate keys error encountered';
    DECLARE EXIT HANDLER FOR SQLEXCEPTION SELECT 'SQLException encountered';
    DECLARE EXIT HANDLER FOR SQLSTATE '23000' SELECT 'SQLSTATE 23000';
 
    -- insert a new record into article_tags
    INSERT INTO article_tags(article_id,tag_id)
    VALUES(article_id,tag_id);
 
    -- return tag count for the article
    SELECT COUNT(*) FROM article_tags;
END

Теперь мы пробуем добавить в таблицу article_tags дубликат ключа через вызов хранимой процедуры:

CALL insert_article_tags_3(1,3);

Как видите, вызывается обработчик кода ошибки MySQL:

Начинаем с объявления обработчика ошибки:

DECLARE EXIT HANDLER FOR 1051 SELECT 'Please create table abc first';
SELECT * FROM abc;

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

К счастью, MySQL предоставляет нам оператор DECLARE CONDITION, который объявляет проименованное условие ошибки, связанное с условием.

Синтаксис оператора DECLARE CONDITION выглядит следующим образом:

DECLARE condition_name CONDITION FOR condition_value;

condition_value может представлять собой код ошибки MySQL, например 1015, или значение SQLSTATE. condition_value представляется с помощью condition_name.

После объявления вы можете обращаться к condition_name вместо condition_value.

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

DECLARE table_not_found CONDITION for 1051;
DECLARE EXIT HANDLER FOR  table_not_found SELECT 'Please create table abc first';
SELECT * FROM abc;

Этот код, очевидно, более удобен для чтения, нежели предыдущий. Отметим, что объявление условия должно размещаться перед объявлением обработчика или объявлением курсора.

Roughly speaking, errors are a legacy in PHP, while exceptions are the modern way to treat errors. The simplest thing then, is to set up an error-handler, that throws an exception. That way all errors are converted to exceptions, and then you can simply deal with one error-handling scheme. The following code will convert errors to exceptions for you:

function exceptions_error_handler($severity, $message, $filename, $lineno) {
  if (error_reporting() == 0) {
    return;
  }
  if (error_reporting() & $severity) {
    throw new ErrorException($message, 0, $severity, $filename, $lineno);
  }
}
set_error_handler('exceptions_error_handler');
error_reporting(E_ALL ^ E_STRICT);

There are a few cases though, where code is specifically designed to work with errors. For example, the schemaValidate method of DomDocument raises warnings, when validating a document. If you convert errors to exceptions, it will stop validating after the first failure. Some times this is what you want, but when validating a document, you might actually want all failures. In this case, you can temporarily install an error-handler, that collects the errors. Here’s a small snippet, I’ve used for that purpose:

class errorhandler_LoggingCaller {
  protected $errors = array();
  function call($callback, $arguments = array()) {
    set_error_handler(array($this, "onError"));
    $orig_error_reporting = error_reporting(E_ALL);
    try {
      $result = call_user_func_array($callback, $arguments);
    } catch (Exception $ex) {
      restore_error_handler();
      error_reporting($orig_error_reporting);
      throw $ex;
    }
    restore_error_handler();
    error_reporting($orig_error_reporting);
    return $result;
  }
  function onError($severity, $message, $file = null, $line = null) {
    $this->errors[] = $message;
  }
  function getErrors() {
    return $this->errors;
  }
  function hasErrors() {
    return count($this->errors) > 0;
  }
}

And a use case:

$doc = new DomDocument();
$doc->load($xml_filename);
$validation = new errorhandler_LoggingCaller();
$validation->call(
  array($doc, 'schemaValidate'),
  array($xsd_filename));
if ($validation->hasErrors()) {
  var_dump($validation->getErrors());
}

Roughly speaking, errors are a legacy in PHP, while exceptions are the modern way to treat errors. The simplest thing then, is to set up an error-handler, that throws an exception. That way all errors are converted to exceptions, and then you can simply deal with one error-handling scheme. The following code will convert errors to exceptions for you:

function exceptions_error_handler($severity, $message, $filename, $lineno) {
  if (error_reporting() == 0) {
    return;
  }
  if (error_reporting() & $severity) {
    throw new ErrorException($message, 0, $severity, $filename, $lineno);
  }
}
set_error_handler('exceptions_error_handler');
error_reporting(E_ALL ^ E_STRICT);

There are a few cases though, where code is specifically designed to work with errors. For example, the schemaValidate method of DomDocument raises warnings, when validating a document. If you convert errors to exceptions, it will stop validating after the first failure. Some times this is what you want, but when validating a document, you might actually want all failures. In this case, you can temporarily install an error-handler, that collects the errors. Here’s a small snippet, I’ve used for that purpose:

class errorhandler_LoggingCaller {
  protected $errors = array();
  function call($callback, $arguments = array()) {
    set_error_handler(array($this, "onError"));
    $orig_error_reporting = error_reporting(E_ALL);
    try {
      $result = call_user_func_array($callback, $arguments);
    } catch (Exception $ex) {
      restore_error_handler();
      error_reporting($orig_error_reporting);
      throw $ex;
    }
    restore_error_handler();
    error_reporting($orig_error_reporting);
    return $result;
  }
  function onError($severity, $message, $file = null, $line = null) {
    $this->errors[] = $message;
  }
  function getErrors() {
    return $this->errors;
  }
  function hasErrors() {
    return count($this->errors) > 0;
  }
}

And a use case:

$doc = new DomDocument();
$doc->load($xml_filename);
$validation = new errorhandler_LoggingCaller();
$validation->call(
  array($doc, 'schemaValidate'),
  array($xsd_filename));
if ($validation->hasErrors()) {
  var_dump($validation->getErrors());
}