PHP PDO: как делает переподготовку работы влияния заявления

MySQL (например, большинство СУБД) будут кэшировать планы выполнения для подготовленных утверждений, поэтому, если пользователь A создает план для:

SELECT * FROM some_table WHERE a_col=:v1 AND b_col=:v2

(где v1 и v2 - связывание vars), затем отправляет Значения, которые должны быть интерполированы СУБД, то пользователь B отправляет тот же запрос (но с разными значениями интерполяции) СУБД не приходится регулировать план. I.e. Это СУБД, который находит соответствующий план - а не PDO.

Однако это означает, что каждая операция в базе данных требуется как минимум 2 круглых поездок (1st, чтобы представить запрос, второй для представления BIND vars), в отличие от одной открытой поездки для запроса с буквальными значениями, то это вводит Дополнительные сети сети. Существует также небольшая стоимость участия в разграничении (и поддержании) кэш запроса / плана.

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

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

Попробуйте измерить его самостоятельно (HINT: вы, возможно, захотите установить медленный порог запроса на 0 и напишите какой-то код для преобразования буквальных значений обратно в анонимные представления для запросов, записанных в журналы).

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

После этого я придумал код с кэшированными подготовленными операторами:

function DB($query)
{
    static $db = null;
    static $result = array();

    if (is_null($db) === true)
    {
        $db = new PDO('sqlite:' . $query, null, null, array(PDO::ATTR_ERRMODE => PDO::ERRMODE_WARNING));
    }

    else if (is_a($db, 'PDO') === true)
    {
        $hash = md5($query);

        if (empty($result[$hash]) === true)
        {
            $result[$hash] = $db->prepare($query);
        }

        if (is_a($result[$hash], 'PDOStatement') === true)
        {
            if ($result[$hash]->execute(array_slice(func_get_args(), 1)) === true)
            {
                if (stripos($query, 'INSERT') === 0)
                {
                    return $db->lastInsertId();
                }

                else if (stripos($query, 'SELECT') === 0)
                {
                    return $result[$hash]->fetchAll(PDO::FETCH_ASSOC);
                }

                else if ((stripos($query, 'UPDATE') === 0) || (stripos($query, 'DELETE') === 0))
                {
                    return $result[$hash]->rowCount();
                }

                else if (stripos($query, 'REPLACE') === 0)
                {
                }

                return true;
            }
        }

        return false;
    }
}

Так как мне не нужно беспокоиться о коллизиях в запросах, я в итоге использовал md5() вместо sha1().

Для моих знаний PDO не повторно использует уже подготовленные заявления, так как он не анализирует запрос само по себе, поэтому он не знает, если это тот же запрос.

Если вы хотите создать кэш подготовленных запросов, самый простой способ IMHO будет для MD5-HASH CHERE STRING RING и генерируют таблицу поиска.

OTOH: Сколько запросов вы выполняете (в минуту)? Если меньше нескольких сотен, вы только усложняете код, усиление производительности будет незначительным.