☰

PHP: PDO быстрый старт, работа с MySQL. Как работать с PDO? Полное руководство Pdo вывод данных из бд

PDO (PHP Data Objects) - расширение PHP, которое реализует взаимодействие с базами данных при помощи объектов. Профит в том, что отсутствует привязка к конкретной системе управления базами данных. PDO поддерживает СУБД: MySQL, PostgreSQL, SQLite, Oracle, Microsoft SQL Server и другие.

Почему стоит использовать PDO

Функции mysql в PHP для работы с БД давно уже устарели, на сегодняшний день желательно использовать mysqli или PDO (PHP Data Objects). Кроме того, mysqli - эта библиотека, которая по большому счёту, не предназначена для использования напрямую в коде. Она может послужить хорошим строительным материалом для создания библиотеки более высокого уровня. При работе с mysqli следует также помнить об обеспечении безопасности вашего приложения, в частности о защите от SQL-инъекций. В случае использования PDO (с его подготовленными запросами), такая защита идёт уже "из коробки", главное правильно применить необходимые методы.

Тестовая база данных с таблицей

// Из консоли Windows mysql> CREATE DATABASE `pdo-test` CHARACTER SET utf8 COLLATE utf8_general_ci; USE pdo-test; CREATE TABLE categories (id INT(11) UNSIGNED NOT NULL AUTO_INCREMENT, PRIMARY KEY(id), name VARCHAR(255) NOT NULL); INSERT INTO `categories` (`name`) VALUES ("Ноутбуки и планшеты"), ("Компьютеры и периферия"), ("Комплектующие для ПК"), ("Смартфоны и смарт-часы"), ("Телевизоры и медиа"), ("Игры и приставки"), ("Аудиотехника"), ("Фото-видеоаппаратура"), ("Офисная техника и мебель"), ("Сетевое оборудование"), ("Крупная бытовая техника"), ("Товары для кухни"), ("Красота и здоровье"), ("Товары для дома"), ("Инструменты"), ("Автотовары");

Установка PDO

// Установка в Linux sudo apt update sudo apt install php7.2-mysql sudo apt-get install pdo-mysql // В php.ini добавить extension=pdo.so extension=pdo_mysql.so // На Windows, как правило драйвер уже установлен, нужно просто проверить включен ли он в php.ini extension=php_pdo_mysql.dll

Проверить доступные драйвера

print_r(PDO::getAvailableDrivers());

Соединение с базой данных

Соединения устанавливаются автоматически при создании объекта PDO от его базового класса.

// Пример #1. Простое подключение $db = new PDO("mysql:host=localhost;dbname=pdo", "root", "password");

При ошибке подключения PHP выдаст ошибку:

Fatal error: Uncaught PDOException: ... // Пример #2. Обработка ошибок подключения try { $dbh = new PDO("mysql:host=localhost;dbname=pdo", "root", "password"); } catch (PDOException $e) { print "Error!: " . $e->getMessage(); die(); }

В этом примере подключения мы используем конструкцию try...catch . Многие спорят о целесообразности её использования. Лично я использую try...catch , она мне не мешает.

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

В PDO два способа выполнения запросов:

  • Прямой - состоит из одного шага;
  • Подготовленный - состоит из двух шагов.

Прямые запросы

  • query() используется для операторов, которые не вносят изменения, например SELECT . Возвращает объект PDOStatemnt , из которого с помощью методов fetch() или fetchAll извлекаются результаты запроса. Можно его сравнить с mysql resource , который возвращала mysql_query() .
  • exec() используется для операторов INSERT, DELETE, UPDATE . Возвращает число обработанных запросом строк.

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

$stmt = $db->query("SELECT * FROM categories"); while ($row = $stmt->fetch()) { echo "

";
 print_r($row);
}

Подготовленные запросы


Если же в запрос передаётся хотя бы одна переменная, то этот запрос в обязательном порядке должен выполняться только через подготовленные выражения. Что это значит? Это обычный SQL запрос, в котором вместо переменной ставится специальный маркер - плейсхолдер. PDO поддерживает позиционные плейсхолдеры (?), для которых важен порядок передаваемых переменных, и именованные (:name), для которых порядок не важен. Примеры:

 $sql = "SELECT name FROM categories WHERE id = ?";
$sql = "SELECT name FROM categories WHERE name = :name";

Чтобы выполнить такой запрос, сначала его надо подготовить с помощью метода prepare() . Она также возвращает PDO statement , но ещё без данных. Чтобы их получить, надо исполнить этот запрос, предварительно передав в него наши переменные. Передать можно двумя способами: Чаще всего можно просто выполнить метод execute() , передав ему массив с переменными:

 $stmt = $pdo->prepare("SELECT `name` FROM categories WHERE `id` = ?");
$stmt->execute([$id]);
$stmt = $pdo->prepare("SELECT `name` FROM categories WHERE `name` = :name");
$stmt->execute(["name" => $name]);

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

 $id = 1;
$stmt = $db->prepare("SELECT * FROM categories WHERE `id` = ?");
$stmt->execute([$id]);
$category = $stmt->fetch(PDO::FETCH_LAZY);
echo "
";
print_r($category);



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




Получение данных. Метод fetch()


Мы уже выше познакомились с методом fetch() , который служит для последовательного получения строк из БД. Этот метод является аналогом функции mysq_fetch_array() и ей подобных, но действует по-другому: вместо множества функций здесь используется одна, но ее поведение задается переданным параметром. В подробностях об этих параметрах будет написано в , а в качестве краткой рекомендации посоветую применять fetch() в режиме FETCH_LAZY

 $id = 1;
$stmt = $db->prepare("SELECT * FROM categories WHERE `id` = ?");
$stmt->execute([$id]);
while ($row = $stmt->fetch(PDO::FETCH_LAZY)) {
 echo "Category name: ".$row->name;
}

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


Получение данных. Метод fetchColumn()


Также у PDO statement есть метод для получения значения единственной колонки. Очень удобно, если мы запрашиваем только одно поле - в этом случае значительно сокращается количество кода:

 $id = 1;
$stmt = $db->prepare("SELECT `name` FROM categories WHERE `id` = ?");
$stmt->execute([$id]);
$name = $stmt->fetchColumn();
echo "Category name: ".$name;

Получение данных. Метод fetchAll()

 $data = $db->query("SELECT * FROM categories")->fetchAll(PDO::FETCH_ASSOC);
foreach ($data as $k => $v){
 echo "Category name: ".$v["name"]."
";
}

PDO и оператор LIKE


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

 $search = "комп";
$query = "SELECT * FROM categories WHERE `name` LIKE ?";
$params = ["%$search%"];
$stmt = $db->prepare($query);
$stmt->execute($params);
$data = $stmt->fetchAll(PDO::FETCH_ASSOC);
$i = 1;
foreach ($data as $category){
 echo $i++ . ". " . $category["name"]."
";
}



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

 $db = new PDO("mysql:host=localhost;dbname=pdo;charset=utf8", "root", "");



PDO и оператор LIMIT


Важно!
 Когда PDO работает в режиме эмуляции, все данные, которые были переданы напрямую в execute() , форматируются как строки. То есть, эскейпятся и обрамляются кавычками. Поэтому LIMIT ?,? превращается в LIMIT "10", "10" и очевидным образом вызывает ошибку синтаксиса и, соответственно, пустой массив данных.


Решение #1: Отключить режим эмуляции:

 $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);

Решение #2: Биндить эти цифры через bindValue() , принудительно выставляя им тип PDO::PARAM_INT:

 $limit = 3;
$stm = $db->prepare("SELECT * FROM categories LIMIT ?");
$stm->bindValue(1, $limit, PDO::PARAM_INT);
$stm->execute();
$data = $stm->fetchAll();
echo "
";
print_r($data);

PDO и оператор IN


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

 $arr = ;
$in = str_repeat("?,", count($arr) - 1) . "?";
$sql = "SELECT * FROM categories WHERE `id` IN ($in)";
$stm = $db->prepare($sql);
$stm->execute($arr);
$data = $stm->fetchAll();
echo "
";
print_r($data);

Добавление записей

 $name = "Новая категория";
$query = "INSERT INTO `categories` (`name`) VALUES (:name)";
$params = [
 ":name" => $name
];
$stmt = $pdo->prepare($query);
$stmt->execute($params);

Изменение записей

 $id = 1;
$name = "Изменённая запись";
$query = "UPDATE `categories` SET `name` = :name WHERE `id` = :id";
$params = [
 ":id" => $id,
 ":name" => $name
];
$stmt = $pdo->prepare($query);
$stmt->execute($params);

Удаление записей

 $id = 1;
$query = "DELETE FROM `categories` WHERE `id` = ?";
$params = [$id];
$stmt = $pdo->prepare($query);
$stmt->execute($params);

Использование транзакций

 try {
 // Начало транзакции
 $pdo->beginTransaction();
 // ... code
 // Если в результате выполнения нашего кода всё прошло успешно,
 // то зафиксируем этот результат
 $pdo->commit();
} catch (Exception $e) {
 // Иначе, откатим транзакцию.
 $pdo->rollBack();
 echo "Ошибка: " . $e->getMessage();
}



Важно! Транзакции в PDO работают только с таблицами InnoDB




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


Соединение с базой данных
 устанавливается тогда, когда создаётся экземпляр класса PDO. Не имеет значения, какой драйвер Вы хотите использовать; Вам всегда нужно будет использовать класс PDO. Его конструктор принимает параметры для того, чтобы определить источник базы данных (известный как DSN), и необязательные параметры для имени пользователя и пароля.


Соединение с MySQL:

 $dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass);

Если произойдут какие либо ошибки соединения, то будет выброшено исключение: объект класса PDOException. Вы можете поймать его, если захотите обработать эту ситуацию, или можете оставить его для глобального обработчика исключений, который устанавливается через set_exception_handler ().


Обработка ошибок соединения:

 try
 {
 $dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass);
 foreach($dbh->query(‘SELECT * from FOO’) as $row)
 {
 print_r($row);
 }
 $dbh = null;
 }
 catch (PDOException $e)
 {
 die("Ошибка! Всё. Приехали... ".$e->getMessage());
 }

Внимание:
 Если Вы не поймаете исключение, брошенное конструктором PDO, действие по умолчанию, предпринятое движком zend, должно остановить скрипт и показать трассировку. Эта хрень выдаст все Ваши интимные подробности общения с базой данной. То есть покажет подробные детали соединения с базой данных, включая имя пользователя и пароль!
На Вашей совести поймать это исключение, либо явно (через утверждение try catch
), либо неявно через set_exception_handler ().


После успешного соединения с базой данных оно остается активным на протяжении всей жизни экземпляра объекта PDO. Чтобы закрыть соединение, Вы должны разрушить объект, гарантируя, что все остающиеся на него ссылки удалены – сделать это можно, присвоив значение NULL переменной, которая содержит объект. Если Вы не сделаете этого явно, то PHP автоматически закроет соединение, когда скрипт завершит работу.


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

 $dbh = new PDO("mysql:host=localhost;dbname=test", $user, $pass);
 // Здесь что то делаем:
 ...
 // А теперь, внимание: конец связи!
 $dbh = null;

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


Установка постоянного соединения:

 $dbh = new PDO("mysql:host=localhost;dbname=test",
 $user, $pass,
 array(PDO::ATTR_PERSISTENT => true));

Имейте ввиду:
 Если Вы хотите использовать постоянное соединение, Вы должны установить PDO::ATTR_PERSISTENT
 в массиве опций драйвера, который передаётся конструктору класса PDO. Устанавливая этот атрибут через PDO::setAttribute() после создания экземпляра объекта, драйвер не будет использовать постоянные связи. А так же, в этом случае вам не удастся расширить класс PDOStatement для каких то своих нужд, т.е. нельзя будет установить: PDO::ATTR_STATEMENT_CLASS




Термин PDO
является сокращением понятия PHP Data Objects
. Как можно судить по названию, эта технология позволяет работать с содержимым базы данных через объекты.


Почему не myqli или mysql?


Чаще всего, в отношении новых технологий, встает вопрос их преимуществ перед старыми-добрыми и проверенными инструментами, а также, перевода на них текущих и старых проектов.


Объектная ориентированность PDO


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


Говоря о PHP
, будем подразумевать современный объектно-ориентированный PHP
, позволяющий писать универсальный код, удобный для тестирования и повторного использования.


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


Абстракция


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


Как минимум, нам придется заменить все вызовы mysqli_connect() (mysql_connect())
 на pg_connect()
 и, по аналогии, другие функции, используемые для запроса и обработки данных.


При использовании PDO
, мы ограничимся изменением нескольких параметров в файлах конфигурации.


Связывание параметров


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


Получение данных в виде объектов


Те, кто уже использует ORM
 (object-relational mapping — объектно-реляционное отображение данных), например, Doctrine
, знают удобство представления данных из таблиц БД в виде объектов. PDO
 позволяет получать данные в виде объектов и без использования ORM
.


Расширение mysql больше не поддерживается


Поддержка расширения mysql
 окончательно удалена из нового PHP 7
. Если вы планируете переносить проект на новую версию PHP
, уже сейчас следует использовать в нем, как минимум, mysqli. Конечно же, лучше начинать использовать PDO
, если вы еще не сделали этого.


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


Проверяем наличие PDO в системе


Версии PHP 5.5
 и выше, чаще всего, уже содержать расширение для работы с PDO
. Для проверки достаточно выполнить в консоли простую команду:

 
php -i | grep "pdo"


Теперь откроем его в любом браузере и найдем нужные данные поиском по строке PDO
.


Знакомимся с PDO


Процесс работы с PDO
 не слишком отличается от традиционного. В общем случае, процесс использования PDO
 выглядит так:


  1. Подключение к базе данных;
    2. 

  2. По необходимости, подготовка запроса и связывание параметров;
    3. 

  3. Выполнение запроса.
    4. 

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


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


В общем случае, DSN
 состоит из имени драйвера, отделенного двоеточием от строки подключения, специфичной для каждого драйвера PDO
.


Для MySQL
, подключение выполняется так:

 
$connection = new PDO("mysql:host=localhost;dbname=mydb;charset=utf8", "root", "root");

 


 
$connection
=
new
PDO
("mysql:host=localhost;dbname=mydb;charset=utf8"
,
"root"
,
"root"
)
;




В данном случае, DSN
 содержит имя драйвера mysql
, указание хоста (возможен формат host=ИМЯ_ХОСТА:ПОРТ
), имя базы данных, кодировка, имя пользователя MySQL
 и его пароль.


Запросы


В отличие от mysqli_query()
, в PDO
 есть два типа запросов:


  • Возвращающие результат (select, show
);
    • 

  • Не возвращающие результат (insert
, detele
 и другие).
    • 

Первым делом, рассмотрим второй вариант.


Выполнение запросов


Рассмотрим пример выполнения запроса на примере insert
.

 
$connection->exec("INSERT INTO users VALUES (1, "somevalue"");

 


 
$connection
->
exec
()
;




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

 
$affectedRows = $connection->exec("INSERT INTO users VALUES (1, "somevalue"");
echo $affectedRows;

 


 
$affectedRows
=
$connection
->
exec
("INSERT INTO users VALUES (1, "somevalue""
)
;

echo
$affectedRows
;




Получение результатов запроса


В случае использования
 mysqli_query
()

, код мог бы быть следующим.

 
$result = mysql_query("SELECT * FROM users");
while($row = mysql_fetch_assoc($result)) {
 echo $row["id"] . " " . $row["name"];
}

 


 
$result
=
mysql_query
("SELECT * FROM users"
)
;

while
($row
=
mysql_fetch_assoc
($result
)
)
{




Для PDO
, код будет проще и лаконичнее.

 
foreach($connection->query("SELECT * FROM users") as $row) {
 echo $row["id"] . " " . $row["name"];
}

 


 
foreach
($connection
->
query
("SELECT * FROM users"
)
as
$row
)
{

echo
$row
[
"id"
]
.
" "
.
$row
[
"name"
]
;




Режимы получения данных


Как и в mysqli
, PDO
 позволяет получать данные в разных режимах. Для определения режима, класс PDO
 содержит соответствующие константы.


  • PDO::
FETCH_ASSOC

 — возвращает массив, индексированный по имени столбца в таблице базы данных;
    • 

  • PDO::
FETCH_NUM

 — возвращает массив, индексированный по номеру столбца;
    • 

  • PDO::
FETCH_OBJ

 — возвращает анонимный объект с именами свойств, соответствующими именам столбцов. Например, $row->id будет содержать значение из столбца id.
    • 

  • PDO::
FETCH_CLASS

 — возвращает новый экземпляр класса, со значениями свойств, соответствующими данным из строки таблицы. В случае, если указан параметр
 PDO::
FETCH_CLASSTYPE

 (например
 PDO::
FETCH_CLASS
|
 PDO::
FETCH_CLASSTYPE

), имя класса будет определено из значения первого столбца.
    • 

Примечание
: это не полный список, все возможные константы и варианты их комбинации доступны в документации .


Пример получения ассоциативного массива:

 
$statement = $connection->query("SELECT * FROM users");
while($row = $statement->fetch(PDO::FETCH_ASSOC)) {
 echo $row["id"] . " " . $row["name"];
}

 


 
$statement
=
$connection
->
while
($row
=
$statement
->
fetch
(PDO::
FETCH_ASSOC
)
)
{

echo
$row
[
"id"
]
.
" "
.
$row
[
"name"
]
;




Примечание
: Рекомендуется всегда указывать режим выборки, так как режим
 PDO::
FETCH_BOTH

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




Рассмотрим использование режима выборки
 PDO::
FETCH_CLASS

. Создадим класс
 User

:

 
class User
{
 protected $id;
 protected $name;
 public function getId()
 {
 return $this->id;
 }
 public function setId($id)
 {
 $this->id = $id;
 }
 public function getName()
 {
 return $this->name;
 }
 public function setName($name)
 {
 $this->name = $name;
 }
}

 


 
class
User

protected
$id
;

protected
$name
;

public
function
getId
()

return
$this
->
id
;

public
function
setId
($id
)

$this
->
id
=
$id
;

public
function
getName
()

return
$this
->
name
;

public
function
setName
($name
)

$this
->
name
=
$name
;




Теперь выберем данные и отобразим данные при помощи методов класса:

 
$statement = $connection->query("SELECT * FROM users");
while($row = $statement->fetch(PDO::FETCH_CLASS, "User")) {
 echo $row->getId() . " " . $row->getName();
}

 


 
$statement
=
$connection
->
query
("SELECT * FROM users"
)
;

while
($row
=
$statement
->
fetch
(PDO::
FETCH_CLASS
,
"User"
)
)
{

echo
$row
->
getId
()
.
" "
.
$row
->
getName
()
;




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


Для понимания сути и всех преимуществ связывания параметров нужно более подробно рассмотреть механизмы PDO
. При вызове
 $statement
->
query
()

 в коде выше, PDO
 подготовит запрос, выполнит его и вернет результат.


При вызове
 $connection
->
prepare
()

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


При вызове
 $statement
->
execute
()

 передаются значения для подстановки в шаблон запроса и СУБД выполняет запрос. Это действие аналогично вызову функции шаблонизатора
 render
()

.


Пример использования подготовленных запросов в PHP PDO
:


В коде выше подготовлен запрос выборки записи с полем
 id

 равным значению, которое будет подставлено вместо
 :
id

. На данном этапе СУБД выполнит анализ и компиляцию запроса, возможно с использованием кеширования (зависит от настроек).


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

 
$id = 5;
$statement->execute([
 ":id" => $id
]);


Преимущества использования связанных параметров


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


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


Вместо этого, теперь целесообразно делать так:


Можно, даже, еще укоротить код, используя нумерованные параметры вместо именованных:


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

 
$numberOfUsers = $connection->query("SELECT COUNT(*) FROM users")->fetchColumn();
$users = ;
$statement = $connection->prepare("SELECT * FROM users WHERE id = ? LIMIT 1");
for ($i = 1; $i <= 5; $i++) {
 $id = rand(1, $numberOfUsers);
 $users = $statement->execute([$id])->fetch(PDO::FETCH_OBJ);
}

 


 
$numberOfUsers
=
$connection
->
query
("SELECT COUNT(*) FROM users"
)
->
fetchColumn
()
;

$users
=

;

for
($i
=
1
;
$i
<=
5
;
$i
++
)
{

$id
=
rand
(1
,
$numberOfUsers
)
;

$users

=
$statement
->
execute
([
$id
]
)
->
fetch
(PDO::
FETCH_OBJ
)
;




При вызове метода
 prepare
()

, СУБД проведет анализ и скомпилирует запрос, при необходимости использует кеширование. Позже, в цикле
 for

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


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

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


Связанные значения и оператор IN


Часто, при начале работы с PDO
, возникают трудности с оператором
 IN

. Например, представим, что пользователь вводит несколько имен, разделенных запятыми. Пользовательский ввод хранится в переменной
 $names

.


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


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


Что такое PDO?


PDO(PHP Data Objects)
 - это просто интерфейс
, позволяющий нам абстрагироваться от конкретной базы данных. Лучше всего показать на примере.
Mysql_connect($host, $user, $pass); // MySQL

mysql_select_db($db);
Sqlite_open($db); // sqlite
Pg_connect("host=$host, dbname=$db, user=$user, password=$pass"); // PostgreSQL

В коде выше представлены способы для подключения к трём разным базам данных: MySQL
, sqlite
 и PostgreSQL
. Как видите, функции у каждой БД отличаются.


То же самое с другими действиями. Например, выборка данных из БД.

 $sql = "INSERT INTO(name, pass) VALUES($name, $pass)";
Mysql_query($sql); // MySQL

sqlite_query($sql); // sqlite

pg_query($sql); // PostgreSQL

Зачем нужен PDO?


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


Давайте рассмотрим, как мы теперь можем подключиться.

 $db = new PDO("mysql:host=$host;dbname=$db", $user, $pass); // MySQL

$db = new PDO("sqlite:host=$host;dbname=$db", $user, $pass); // sqlite

$db = new PDO("pgsql:host=$host;dbname=$db", $user, $pass); // PostgreSQL

Как видно из кода выше, в этих трёх подключениях меняется только строчка с названием БД, а остальное всё то же самое.


Чтобы что-нибудь выбрать, мы можем написать так:

 $db->exec($sql);

Всё! Запрос выполнится независимо от того, какая у нас база данных.


Поддержка


PDO
 доступен с PHP 5.1
. Чтобы мы могли "забыть", какую базу данных мы используем, за нас всё делают их драйверы
. Чтобы их активировать, зайдите в файл php.ini
 и найдите там строчки, которые начинаются на extension=php_pdo_
, а затем идёт название базы данных, и раскоментируйте их.


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


Обеспечивает методы для подготовки выражений и работы с объектами, которые могут сделать Вашу работу более продуктивной!



Введение в PDO



"PDO - PHP Data Objects - это уровень для доступа к базам данных, который обеспечивает унифицированные методы для доступа к различным базам данных."



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



Данный урок не является описанием процесса работы с SQL
. Он предназначен для тех, кто использует расширения mysql
 или mysqli
, чтобы помочь им перейти к более мощному и портируемому PDO.



Поддержка баз данных



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



  • PDO_DBLIB (FreeTDS / Microsoft SQL Server / Sybase)

    • 

  • PDO_FIREBIRD (Firebird/Interbase 6)

    • 

  • PDO_IBM (IBM DB2)

    • 

  • PDO_INFORMIX (IBM Informix Dynamic Server)

    • 

  • PDO_MYSQL (MySQL 3.x/4.x/5.x)

    • 

  • PDO_OCI (Oracle Call Interface)

    • 

  • PDO_ODBC (ODBC v3 (IBM DB2, unixODBC и win32 ODBC))

    • 

  • PDO_PGSQL (PostgreSQL)

    • 

  • PDO_SQLITE (SQLite 3 и SQLite 2)

    • 

  • PDO_4D (4D)

    • 

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

Print_r(PDO::getAvailableDrivers());

Подключение



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



 try {
 # MS SQL Server и Sybase с PDO_DBLIB
 $DBH = new PDO("mssql:host=$host;dbname=$dbname, $user, $pass");
 $DBH = new PDO("sybase:host=$host;dbname=$dbname, $user, $pass");
 # MySQL с PDO_MYSQL
 $DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass);
 # SQLite
 $DBH = new PDO("sqlite:my/database/path/database.db");
}
catch(PDOException $e) {
 echo $e->getMessage();
}

Обратите внимание на блок try/catch
 - всегда нужно оборачивать операции PDO в блок try/catch
 и использовать механизм исключений. Обычно выполняется только одно подключение, в нашем примере показаны несколько подключений для отображения синтаксиса. $DBH
 содержит дескриптор базы данных и будет использоваться на протяжении всего нашего урока.



Вы можете закрыть любое соединение установкой дескриптора в null
.


 # Закрываем соединение
$DBH = null;

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



Исключения и PDO



PDO может использовать исключения для обработки ошибок. Значит все операции PDO должны быть заключены в блок try/catch
. PDO может выдавать ошибки трех уровней, уровень контроля ошибок выбирается установкой атрибута режима контроля ошибок для дескриптора базы данных:


 $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
$DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
$DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

Вне зависимости от установленного уровня контроля ошибка соединения всегда вызывает исключение и поэтому всегда должна быть заключена в блок try/catch
.



PDO::ERRMODE_SILENT



Уровень контроля ошибок, устанавляваемы по умолчанию. На этом уровене ошибки генерируются по такому же принципу, как в расширениях mysql
 или mysqli
. Два других уровня контроля ошибок более подходят для стиля програмирования в стиле DRY (Don"t Repeat Youself - не повторяй сам себя).



PDO::ERRMODE_WARNING



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



PDO::ERRMODE_EXCEPTION



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


 # Подключаемся к базе данных
try {
 $DBH = new PDO("mysql:host=$host;dbname=$dbname", $user, $pass);
 $DBH->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 # Ошибочно набираем DELECT вместо SELECT!
 $DBH->prepare("DELECT name FROM people");
}
catch(PDOException $e) {
 echo " Извините. Но операция не может быть выполнена.";
 file_put_contents("PDOErrors.txt", $e->getMessage(), FILE_APPEND);
}

Здесь сделана преднамеренная ошибка в выражении SELECT. Это вызовет исключение. Исключение отправит описание ошибки в log файл и выдаст сообщение пользователю.



Вставка и обновление данных



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



Здесь приведен пример наиболее используемого типа вставки данных:


 # STH - это "дескриптор состояния"
$STH = $DBH->prepare("INSERT INTO folks (first_name) values ("Cathy")");
$STH->execute();

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



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



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



Вы можете использовать подготовленные выражения с помощью включения шаблонов в ваш код SQL. Ниже приводятся 3 примера: один без шаблонов, один с неименованными шаблонами, один с именоваными шаблонами.


 # нет шаблонов - открыто для атак путем внедрения SQL кода!
$STH = $DBH->("INSERT INTO folks (name, addr, city) values ($name, $addr, $city)");
# неименованые шаблоны
$STH = $DBH->("INSERT INTO folks (name, addr, city) values (?, ?, ?);
# именованые шаблоны
$STH = $DBH->("INSERT INTO folks (name, addr, city) value (:name, :addr, :city)");

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



Неименованные шаблоны


 # назначение переменных каждому шаблону, индексируются от 1 до 3
$STH->bindParam(1, $name);
$STH->bindParam(2, $addr);
$STH->bindParam(3, $city);
# Вставляем одну строку
$name = "Дима"
$addr = "ул. Лизюкова";
$city = "Москва";
$STH->execute();
# Вставляем другую строку
$name = "Сеня"
$addr = "Коммунистический тупик";
$city = "Питер";
$STH->execute();

Операция проходит в два этапа. На первом этапе шаблонам назначаются переменные. Затем, пременным присваиваются значения и выполняем выражение. Чтобы послать следующую порцию данных, нужно изменить значения переменных и выполнить выражение снова.



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


 # Данные, которые надо вставить
$data = array("Моня", "проспект Незабудок", "Закутайск");
$STH = $DBH->("INSERT INTO folks (name, addr, city) values (?, ?, ?)");
$STH->execute($data);

Данные в массиве подставляются в шаблоны в порядке следования. $data идет в первый шаблон, $data - во второй, и так далее. Однако, если массив проиндексирован в другом порядке, то такая операция будет выполняться некорректно. Вам нужно следить за соответствием порядка следования шаблонов и порядком расположения данных в массиве.



Именованные шаблоны



Вот пример использования именованного шаблона:


 # Первый аргумент функции - имя именованного шаблона
# Именованный шаблон всегда начинается с двоеточия
$STH->bindParam(":name", $name);

Вы можете использовать сокращения, но они работают с ассоциированными массивами. Пример:


 # Данные, которые надо вставить
$data = array("name" => "Мишель", "addr" => "переулок Кузнечный", "city" => "Cnjkbwf");
# Сокращение
$STH = $DBH->("INSERT INTO folks (name, addr, city) value (:name, :addr, :city)");
$STH->execute($data);

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



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


 # Простой объект
class person {
 public $name;
 public $addr;
 public $city;
 function __construct($n,$a,$c) {
 $this->name = $n;
 $this->addr = $a;
 $this->city = $c;
 }
 # и т.д. ...
}
$cathy = new person("Катя","проспект Ленина","Можайск");
# Выполняем:
$STH = $DBH->("INSERT INTO folks (name, addr, city) value (:name, :addr, :city)");
$STH->execute((array)$cathy);

Преобразование типа объекта к array
 в execute
 приводит к обработке свойств как ключей массива.



Получение данных



Для получения данных используется метод идентификатора состояния ->fetch()
. Перед вызовом метода fetch()
 нужно указать PDO как Вы будете доставать данные из базы. Можно выбрать следующие опции:



  • PDO::FETCH_ASSOC
: возвращает массив, индексированный по именам столбцов

    • 

  • PDO::FETCH_BOTH (default)
: возвращает массив, индексированный по именам столбцов и по номерам

    • 

  • PDO::FETCH_BOUND
: назначает значения ваших столбцов набору переменных с использованием метода ->bindColumn()


    • 

  • PDO::FETCH_CLASS
: назначает значения столбцов свойствам именованного класса, если соответствующего свойства не существует - оно создается

    • 

  • PDO::FETCH_INTO
: обновляет существующий экземпляр именованного класса

    • 

  • PDO::FETCH_LAZY
: комбинация PDO::FETCH_BOTH/PDO::FETCH_OBJ
, создает имена переменных объекта так как они используются

    • 

  • PDO::FETCH_NUM
: возвращает массив, индексированный по номерам столбцов

    • 

  • PDO::FETCH_OBJ
: возвращает анонимный объект с именами свойств, соответствующих именам столбцов

    • 

В действительности основные ситуации разрешаются с помощью трех опций: FETCH_ASSOC
, FETCH_CLASS
 и FETCH_OBJ
. Для установки метода извлечения данных используется:


 $STH->setFetchMode(PDO::FETCH_ASSOC);

Также можно устанавливать метод извлечения данных непосредственно в вызове метода ->fetch()
.



FETCH_ASSOC



Данный тип извлечения данных создает ассоциативный массив, индексированный по именам столбцов. Он должен быть достаточно хорошо известен тем, кто пользуется расширениями mysql/mysqli
. Пример выборки данных:


 $STH = $DBH->query("SELECT name, addr, city from folks");
# Устанавливаем режим извлечения данных
$STH->setFetchMode(PDO::FETCH_ASSOC);
while($row = $STH->fetch()) {
 echo $row["name"] . "\n";
 echo $row["addr"] . "\n";
 echo $row["city"] . "\n";
}

Цикл while
 продолжает перебирать результат выборки по одной строке до полного завершения.



FETCH_OBJ



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


 $STH = $DBH->query("SELECT name, addr, city from folks");
# Устанавливаем режим извлечения данных
$STH->setFetchMode(PDO::FETCH_OBJ);
# показываем результат
while($row = $STH->fetch()) {
 echo $row->name . "\n";
 echo $row->addr . "\n";
 echo $row->city . "\n";
}

FETCH_CLASS



При данном типе извлечения данные помещаются прямо в класс, который Вы выбирете. При использовании FETCH_CLASS
 свойства вашего объекта устанавливаются ДО вызова конструктора. Это очень важно. Если свойства соответствующего имени столбца не существует, то такое свойство будет создано (как public
) для Вас.



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



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

Class secret_person {
 public $name;
 public $addr;
 public $city;
 public $other_data;
 function __construct($other = "") {
 $this->address = preg_replace("//", "x", $this->address);
 $this->other_data = $other;
 }
}

Как только данные извлечены в класс, все символы a-z в нижнем регистре в адресе будут заменены символом x. Теперь с использованием класса и получением данных трансформация происходит полностью прозрачно:


 $STH = $DBH->query("SELECT name, addr, city from folks");
$STH->setFetchMode(PDO::FETCH_CLASS, "secret_person");
while($obj = $STH->fetch()) {
 echo $obj->addr;
}

Если адрес был ’Ленинский пр-т 5’ Вы увидите ’Лхххххххх хх-х 5’. Конечно, существуют ситуации, когда Вы хотите, чтобы конструктор был вызван перед тем, как будут назначены данные. PDO имеет средства реализовать это:


 $STH->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, "secret_person");

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



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


 $STH->setFetchMode(PDO::FETCH_CLASS, "secret_person", array("stuff"));

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


 $i = 0;
while($rowObj = $STH->fetch(PDO::FETCH_CLASS, "secret_person", array($i))) {
 // do stuff
 $i++
}

Некоторые другие полезные методы



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


 $DBH->lastInsertId();

Метод ->lastInsertId()
 всегда вызывается дескриптором базы данных (а не дескриптором состояния) и возвращает значение автоматически увеличивающегося идентификатора последней вставленной строки для данного соединения.


 $DBH->exec("DELETE FROM folks WHERE 1");
$DBH->exec("SET time_zone = "-8:00"");

Метод ->exec()
 используется для различных вспомогательных операций.


 $safe = $DBH->quote($unsafe);

Метод ->quote()
 квотирует строки, так что они могут быть использованы в запросах. Это Ваш резерв на случай, если подготовленные выражения не используются.


 $rows_affected = $STH->rowCount();

Метод ->rowCount()
 возвращает значение integer
, указывающее количество строк, которые обрабатываются операцией. В последней версии PDO, в соответствии с отчетом об ошибках(http://bugs.php.net/40822) данный метод не работает с выражениями SELECT
. Если у Вас возникли проблемы и Вы не можете обновить PHP, получить количество строк можно следующим способом:


 $sql = "SELECT COUNT(*) FROM folks";
if ($STH = $DBH->query($sql)) {
 # Проверка количества строк
 if ($STH->fetchColumn() > 0) {
 # Здесь должен быть код SELECT
 }
 else {
 echo "Нет строк соответствующих запросу.";
 }
}

Надеюсь, что урок Вам понравился!