Как работать с PDO? Полное руководство. Ускоряем запросы в БД с помощью PDO и итераторов Перевод Отключение расчета доставки

У меня проблемы с параметрами в разделе ORDER BY моего SQL. Он не выдает никаких предупреждений, но ничего не выводит.

$order = "columnName"; $direction = "ASC"; $stmt = $db->prepare("SELECT field from table WHERE column = :my_param ORDER BY:order:direction"); $stmt->bindParam(":my_param", $is_live, PDO::PARAM_STR); $stmt->bindParam(":order", $order, PDO::PARAM_STR); $stmt->bindParam(":direction", $direction, PDO::PARAM_STR); $stmt->execute();

The:my_param работает, но не:order или:direction . Является ли это внутренним бегством? Могу ли я вставить его непосредственно в SQL? Вот так:

$order = "columnName"; $direction = "ASC"; $stmt = $db->prepare("SELECT * from table WHERE column = :my_param ORDER BY $order $direction");

Существует PDO::PARAM_COLUMN_NAME константа PDO::PARAM_COLUMN_NAME или какой-либо эквивалент?

Благодаря!

Здесь возникает вопрос, что широко любимые подготовленные заявления – это не серебряная пуля, хе-хе 🙂

Да, вы застряли, вставив его непосредственно в SQL с некоторыми предосторожностями, конечно. Каждый оператор / идентификатор должен быть жестко закодирован в вашем скрипте, например:

$orders=array("name","price","qty"); $key=array_search($_GET["sort"],$orders); $order=$orders[$key]; $query="SELECT * from table WHERE is_live = :is_live ORDER BY $order"; - $orders=array("name","price","qty"); $key=array_search($_GET["sort"],$orders); $order=$orders[$key]; $query="SELECT * from table WHERE is_live = :is_live ORDER BY $order";

То же самое для направления.

Обратите внимание, что bindParam не ускользает, так как не требуется никакого экранирования. он имеет обязательную силу.

Я не думаю, что вы можете:

Использовать заполнители в порядке order by
Связывать имена столбцов: вы можете связывать только значения – или переменные и вводить их значение в подготовленный оператор.

Возможно использование подготовленных операторов в предложении ORDER BY , к сожалению, вам нужно передать порядок столбца с именем и требуется установить PDO_PARAM_INT с типом.

В MySQL вы можете получить порядок столбцов с этим запросом:

SELECT column_name, ordinal_position FROM information_schema.columns WHERE table_name = "table" and table_schema = "database"

$order = 2; $stmt = $db->prepare("SELECT field from table WHERE column = :param ORDER BY:order DESC"); $stmt->bindParam(":param", $is_live, PDO::PARAM_STR); $stmt->bindParam(":order", $order, PDO::PARAM_INT); $stmt->execute();

Я не думаю, что вы можете получить ASC / DESC как часть подготовленного оператора, но столбец вы можете.

Order by case:order when "colFoo" then colFoo when "colBar" then colBar else colDefault end $direction

Поскольку ASC / DESC – это всего лишь два возможных значения, вы можете легко проверить и выбрать между ними как жестко установленные значения.

Вы также можете использовать функции ELT (FIELD (,) ,) для этого, но тогда упорядочение всегда будет выполняться как строка, даже если это числовой столбец.

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

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

Это возможно . Вы можете использовать число вместо имени поля в предложении "order by". Это число, начинающееся с 1 и имеющее порядок имен полей в запросе. И вы можете конкатенировать строку для ASC или DESC. Например «Выберите col1, col2, col3 из tab1 order на?» + StrDesc + «limit 10,5». strDesc = "ASC" / "DESC".

Если я не ошибаюсь, Паскаль прав.
Единственное связывание, возможное в PDO, – это привязка значений, как вы это делали с параметром ": my_param".
Однако в этом нет вреда:

$stmt = $db->prepare("SELECT field from table WHERE column = :my_param ORDER BY ".$order ." ".$direction); $stmt->bindParam(":my_param", $is_live, PDO::PARAM_STR); $stmt->execute();

Единственное, что следует обратить внимание, это правильное преодоление $order и $direction , но поскольку вы устанавливаете их вручную и не устанавливаете их через пользовательский ввод, я думаю, что вы все настроены.

Создайте условие if-else.
Если (ascCondion), то привяжите значения, но жесткий код ORDER BY columnName ASC
еще
Свяжите значения, но жесткий код ORDER BY COlumnName DESC

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

Пример правильного соединения:

$host = "127.0.0.1" ;
$db = "test" ;
$user = "root" ;
$pass = "" ;
$charset = "utf8" ;

$dsn = "mysql:host= $host ;dbname= $db ;charset= $charset " ;
$opt = [
PDO :: ATTR_ERRMODE => PDO :: ERRMODE_EXCEPTION ,
PDO :: ATTR_DEFAULT_FETCH_MODE => PDO :: FETCH_ASSOC ,
PDO :: ATTR_EMULATE_PREPARES => false ,
];
$pdo = new PDO ($dsn , $user , $pass , $opt );

Что здесь происходит?

В $dsn задается тип БД, с которым будем работать (mysql), хост, имя базы данных и чарсет.
- затем идут имя пользователя и пароль
- после которого задается массив опций, про который ни в одном из руководств не пишут.

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

Плюс очень удобно задать FETCH_MODE по умолчанию, чтобы не писать его в КАЖДОМ запросе, как это очень любят делать прилежные хомячки.
Также здесь можно задавать режим pconnect-а, эмуляции подготовленных выражений и много других страшных слов.

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

Для выполнения запросов можно пользоваться двумя методами.
Если в запрос не передаются никакие переменные, то можно воспользоваться функцией query(). Она выполнит запрос и вернёт специальный объект - PDO statement. Очень грубо можно его сравнить с mysql resource, который возвращала mysql_query(). Получить данные из этого объекта можно как традиционным образом, через while, так и через foreach(). Также можно попросить вернуть полученные данные в особом формате, о чем ниже.
$stmt = $pdo -> query ("SELECT name FROM users" );
while ($row = $stmt -> fetch ())
{
}

Если же в запрос передаётся хотя бы одна переменная, то этот запрос в обязательном порядке должен выполняться только через подготовленные выражения . Что это такое? Это обычный SQL запрос, в котором вместо переменной ставится специальный маркер - плейсхолдер. PDO поддерживает позиционные плейсхолдеры (?), для которых важен порядок передаваемых переменных, и именованные (:name), для которых порядок не важен. Примеры:
$sql = ;
$sql = ;
Чтобы выполнить такой запрос, сначала его надо подготовить с помощью функции prepare(). Она также возвращает PDO statement, но ещё без данных. Чтобы их получить, надо исполнить этот запрос, предварительно передав в него переменные. Передать можно двумя способами:
Чаще всего можно просто выполнить метод execute(), передав ему массив с переменными:
$stmt = $pdo -> prepare ("SELECT name FROM users WHERE email = ?" );
$stmt -> execute (array($email ));

$stmt = $pdo -> prepare ("SELECT name FROM users WHERE email = :email" );
$stmt -> execute (array("email" => $email ));
Как видно, в случае именованных плейсхолдеров в execute() должен передаваться массив, в котором ключи должны совпадать с именами плейсхолдеров.

Иногда, очень редко, может потребоваться второй способ, когда переменные сначала привязывают к запросу по одной, с помощью bindValue() / bindParam(), а потом только исполняют. В этом случае в execute() ничего не передается. Пример можно посмотреть в мануале
Используя этот метод, всегда следует предпочесть bindValue()? поскольку поведение bindParam() не очевидно для новичков и будет приводить к проблемам.

После этого можно использовать PDO statement теми же способами, что и выше. Например, через foreach:
$stmt = $pdo -> prepare ("SELECT name FROM users WHERE email = ?" );
$stmt ->
foreach ($stmt as $row )
{
echo $row [ "name" ] . "\n" ;
}

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

Также prepare() / execute() могут использоваться для многократного выполнения единожды подготовленного запроса с разными наборами данных. На практике это бывает нужно чрезвычайно редко, и особого прироста в скорости не приносит. Но на случай, если понадобится делать много однотипных запросов, то можно писать так:

$data = array(
1 => 1000,
5 => 300,
9 => 200,
);

$stmt = $pdo -> prepare ("UPDATE users SET bonus = bonus + ? WHERE id = ?" );
foreach ($data as $id => $bonus )
{
$stmt -> execute ([ $bonus , $id ]);
}

Здесь мы один раз подготавливаем запрос, а затем много раз выполняем.

Мы уже выше познакомились с методом fetch(), который служит для последовательного получения строк из БД. Этот метод является аналогом функции mysq_fetch_array() и ей подобных, но действует по-другому: вместо множества функций здесь используется одна, но ее поведение задается переданным параметром. В подробностях об этих параметрах будет написано позже, а в качестве краткой рекомендации посоветую применять fetch() в режиме FETCH_LAZY :
$stmt = $pdo -> prepare ("SELECT name FROM users WHERE email = ?" );
$stmt -> execute ([ $_GET [ "email" ]]);
while ($row = $stmt -> fetch (PDO :: FETCH_LAZY ))
{
echo $row [ 0 ] . "\n" ;
echo $row [ "name" ] . "\n" ;
echo $row -> name . "\n" ;
}
В этом режиме не тратится лишняя память, и к тому же к колонкам можно обращаться любым из трех способов - через индекс, имя, или свойство.

Также у PDO statement есть функция-хелпер для получения значения единственной колонки. Очень удобно, если мы запрашиваем только одно поле - в этом случае значительно сокращается количество писанины:
$stmt = $pdo -> prepare ("SELECT name FROM table WHERE id=?" );
$stmt -> execute (array($id ));
$name = $stmt -> fetchColumn ();

Но самой интересной функцией, с самым большим функционалом, является fetchAll(). Именно она делает PDO высокоуровневой библиотекой для работы с БД, а не просто низкоуровневым драйвером.

FetchAll() возвращает массив, который состоит из всех строк, которые вернул запрос. Из чего можно сделать два вывода:
1. Эту функцию не стоит применять тогда, когда запрос возвращает много данных. В таком случае лучше использовать традиционный цикл с fetch()
2. Поскольку в современных РНР приложениях данные никогда не выводятся сразу по получении, а передаются для этого в шаблон, fetchAll() становится просто незаменимой, позволяя не писать циклы вручную, и тем самым сократить количество кода.

Получение простого массива.
Вызванная без параметров, эта функция возвращает обычный индексированный массив, в котором лежат строки из бд, в формате, который задан в FETCH_MODE по умолчанию. Константы PDO::FETCH_NUM, PDO::FETCH_ASSOC, PDO::FETCH_OBJ могут менять формат на лету.

Получение колонки.
Иногда бывает нужно получить простой одномерный массив, запросив единственное поле из кучи строк. Для этого используется режим PDO::FETCH_COLUMN
$data = $pdo -> query ("SELECT name FROM users" )-> fetchAll (PDO :: FETCH_COLUMN );
array (
0 => "John" ,
1 => "Mike" ,
2 => "Mary" ,
3 => "Kathy" ,
)

Получение пар ключ-значение.
Также востребованный формат, когда желательно получить ту же колонку, но индексированную не числами, а одним из полей. За это отвечает константа PDO::FETCH_KEY_PAIR.
$data = $pdo -> query ("SELECT id, name FROM users" )-> fetchAll (PDO :: FETCH_KEY_PAIR );
array (
104 => "John" ,
110 => "Mike" ,
120 => "Mary" ,
121 => "Kathy" ,
)

Получение всех строк, индексированных полем.
Также часто бывает нужно получить все строки из БД, но также индексированные не числами, а уникальным полем. Это делает константа PDO::FETCH_UNIQUE
$data = $pdo -> query ("SELECT * FROM users" )-> fetchAll (PDO :: FETCH_UNIQUE );
array (
104 => array (
"name" => "John" ,
"car" => "Toyota" ,
),
110 => array (
"name" => "Mike" ,
"car" => "Ford" ,
),
120 => array (
"name" => "Mary" ,
"car" => "Mazda" ,
),
121 => array (
"name" => "Kathy" ,
"car" => "Mazda" ,
),
)
Следует помнить, что первой в колонкой надо обязательно выбирать уникальное поле.

Всего различных режимов получения данных в PDO больше полутора десятков. Плюс ещё их можно комбинировать! Но это уже тема для отдельной статьи.

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

$name = "% $name %" ;
$stm = $pdo -> prepare ("SELECT * FROM table WHERE name LIKE ?" );
$stm -> execute (array($name ));
$data = $stm -> fetchAll ();

Ну, вы поняли. Тут тоже всё плохо. PDO не предоставляет вообще никаких средств для работы с идентификаторами, и их надо форматировать по-старинке, вручную (или посмотреть, все-таки, в сторону SafeMysql , в которой этот, как и многие другие вопросы, решены просто и элегантно).
Следует помнить, что правила форматирования идентификаторов отличаются для разных БД.

В mysql для ручного форматирования идентификатора необходимо выполнить два действия:
- заключить его в обратные одинарные кавычки (backticks, "`").
- проискейпить эти символы внутри идентификатора внутри путём удвоения.

$field = "`" . str_replace ("`" , "``" , $_GET [ "field" ]). "`" ;
$sql = $field " ;

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

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

Любой код для вставки, который можно увидеть в многочисленных туториалах, навевает тоску и желание убиться апстену. Многокилометровые построения с повторением одних и тех же имен - в идексах $_POST-а, в именах переменных, в именах полей в запросе, в именах плейсхолдеров в запросе, в именах плейсходеров и именах переменных при привязке.
Глядя на этот код, хочется кого-нибудь убить, или, по крайней мере, сделать его немного короче.

Это можно сделать, если принять соглашение, по которому имена полей в форме будут соответствовать именам полей в таблице. Тогда эти имена можно будет перечислить только один раз (в целях защиты от подмены, о которой говорилось выше), и использовать небольшую функцию-хелпер для сборки запроса, которая, в силу особенностей mysql, годится как для INSERT, так и UPDATE запросов:

Соответственно, для вставки код будет

$allowed = array("name" , "surname" , "email" ); // allowed fields
$sql = "INSERT INTO users SET " . pdoSet ($allowed , $values );
$stm = $dbh -> prepare ($sql );
$stm -> execute ($values );

А для апдейта - такой:

$allowed = array("name" , "surname" , "email" , "password" ); // allowed fields
$_POST [ "password" ] = MD5 ($_POST [ "login" ]. $_POST [ "password" ]);
$sql = "UPDATE users SET " . pdoSet ($allowed , $values ). " WHERE id = :id" ;
$stm = $dbh -> prepare ($sql );
$values [ "id" ] = $_POST [ "id" ];
$stm -> execute ($values );

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

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

$dirs = array("ASC" , "DESC" );
$key = array_search ($_GET [ "dir" ], $dirs ));
$dir = $orders [ $key ];
$sql = "SELECT * FROM `table` ORDER BY $field $dir " ;

Когда вы просматриваете километры кода, у вас вполне может возникнуть вопрос: "Почему все сделано так, как сделано?" Лично я особенно замечаю вещи, которые могут и должны быть улучшены, когда дело касается тяжелых запросов в БД.

Разработка без фреймворка

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

$pdo = new \PDO($config["db"]["dsn"], $config["db"]["username"], $config["db"]["password"]); $sql = "SELECT * FROM `gen_contact` ORDER BY `contact_modified` DESC"; $stmt = $pdo->prepare($sql); $stmt->execute(); $data = $stmt->fetchAll(\PDO::FETCH_OBJ); echo "Getting the contacts that changed the last 3 months" . PHP_EOL; foreach ($data as $row) { $dt = new \DateTime("2015-04-01 00:00:00"); if ($dt->format("Y-m-d") . "00:00:00" < $row->contact_modified) { echo sprintf("%s (%s)| modified %s", $row->contact_name, $row->contact_email, $row->contact_modified) . PHP_EOL; } }

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

Код не дает возможность повторного использования. Когда будет надо задействовать похожий функционал, вам придется дублировать существующий код.
Даже если вы для выборки используете $stmt->fetchAll(\PDO::FETCH_OBJ); у вас остается проблема, т.к. на выходе получится массив объектов. При большой выборке это пожрет море памяти.
Фильтрация делается с помощью функции. Это означает, в том случае, если потребуются другие условия фильтрования, вам нужно будет модифицировать текущую логику, что далеко не прибавит удобства для сопровождения и расширения функционала.

Итераторы

Большинство современных фреймворков для получения данных применяет итераторы, потому что они быстры и пригодны для повторного использования. А еще они позволяют задействовать другие итераторы для фильтрации и изменения возвращаемых результатов. Но и без фреймворка вы можете использовать их, т.к. итераторы стали частью PHP еще с версии 5.0.0 Beta 2 .

Итак, давайте представим, что вы продолжаете использовать PDO для получения данных. У нас есть для варианта:

Использовать PDOStatement::fetchAll() для получения всех данных за один проход.
Использовать PDOSTatement::fetch() для получения одной строки за одну итерацию.

Даже если первый вариант вам кажется очень заманчивым, я предпочитаю и советую использовать вариант за номером два. Он позволяет мне создать один итератор для извлечения данных не ограничиваясь условиями запроса (что делает его пригодным к повторному использованию для любых извлечений).

Почему "ВКонтакте" лагает: инструкция по устранению неполадок

Как ускорить установку игр в "торренте"

Приложение друг во круг. Друг вокруг вход

TWRP Recovery - как установить, как делать резервные копии на android, восстанавливать систему, устанавливать прошивки, патчи и ядра Установка прошивки через team win recovery