В прошлой заметке мы познакомились с основами PDO и простейшими запросами выборки данных из базы данных. В этой заметке мы научимся управлять режимами получения данных.
Все предопределенные константы здесь
PDO::FETCH_BOTH
Аналог mysql_fetch_array(). Все данные возвращаются в дублированном виде, с текстовыми индексами и цифровыми. Этот режим включен в PDO по умолчанию.
$stm = $db->query('SELECT * FROM categories LIMIT 1')->fetch(PDO::FETCH_BOTH);
// Результат
Array
(
[id] => 1
[0] => 1
[name] => Ноутбуки и планшеты
[1] => Ноутбуки и планшеты
)
PDO::FETCH_NUM
Аналог mysql_fetch_row(). Только цифровые индексы:
$stm = $db->query('SELECT * FROM categories LIMIT 1')->fetch(PDO::FETCH_NUM);
// Результат
Array
(
[0] => 1
[1] => Ноутбуки и планшеты
)
PDO::FETCH_ASSOC
Аналог mysql_fetch_assoc() Только текстовые индексы.
$stm = $db->query('SELECT * FROM categories LIMIT 1')->fetch(PDO::FETCH_ASSOC);
// Результат
Array
(
[id] => 1
[name] => Ноутбуки и планшеты
)
PDO::FETCH_OBJ
Аналог mysql_fetch_object() без указания имени класса, возвращает экземпляр stdClass
$stm = $db->query('SELECT * FROM categories LIMIT 1')->fetch(PDO::FETCH_OBJ);
// Результат
stdClass Object
(
[id] => 1
[name] => Ноутбуки и планшеты
)
PDO::FETCH_LAZY
В этом режиме не тратится лишняя память, и к тому же к колонкам можно обращаться любым из трех способов - через индекс, имя, или свойство (через ->). Недостатком же данного режима является то, что он не работает с fetchAll()
$stm = $db->query('SELECT `name` FROM categories')->fetch(PDO::FETCH_LAZY);
// Результат
PDORow Object
(
[queryString] => SELECT `name` FROM categories
[name] => Ноутбуки и планшеты
)
PDO::FETCH_COLUMN
Когда необходимо получить только одну колонку из результата. Соответственно, имеет смысл только при использовании с fetchAll() - и в этом случае возвращает сразу одномерный массив.
$stm = $db->query('SELECT `name` FROM categories')->fetchAll(PDO::FETCH_COLUMN);
// Результат
Array
(
[0] => Ноутбуки и планшеты
[1] => Компьютеры и периферия
[2] => Комплектующие для ПК
[3] => Смартфоны и смарт-часы
[4] => Телевизоры и медиа
[5] => Игры и приставки
[6] => Аудиотехника
[7] => Фото-видеоаппаратура
[8] => Офисная техника и мебель
[9] => Сетевое оборудование
[10] => Крупная бытовая техника
[11] => Товары для кухни
[12] => Красота и здоровье
[13] => Товары для дома
[14] => Инструменты
[15] => Автотовары
)
PDO::FETCH_KEY_PAIR
Малоизвестный, но очень полезный режим, когда из двух запрошенных полей содержимое первого становится ключом, а второго - значением одномерного массива.
$stm = $db->query('SELECT `name`, `id` FROM categories')->fetchAll(PDO::FETCH_KEY_PAIR);
// Результат
Array
(
[Ноутбуки и планшеты] => 1
[Компьютеры и периферия] => 2
[Комплектующие для ПК] => 3
[Смартфоны и смарт-часы] => 4
[Телевизоры и медиа] => 5
[Игры и приставки] => 6
[Аудиотехника] => 7
[Фото-видеоаппаратура] => 8
[Офисная техника и мебель] => 9
[Сетевое оборудование] => 10
[Крупная бытовая техника] => 11
[Товары для кухни] => 12
[Красота и здоровье] => 13
[Товары для дома] => 14
[Инструменты] => 15
[Автотовары] => 16
)
PDO::FETCH_UNIQUE
Похож на предыдущий, но в качестве значения возвращает всю оставшуюся строку. C fetch() этот режим не возвращает ничего вразумительного, а вот с fetchAll() как раз получается такой, весьма востребованный режим. Главное, чтобы первой колонкой в запросе выбиралось уникальное поле - тогда оно будет использовано в качестве индекса возвращаемого массива, вместо обычной нумерации
$stm = $db->query('SELECT * FROM categories LIMIT 3')->fetchAll(PDO::FETCH_UNIQUE);
// Результат
Array
(
[1] => Array
(
[name] => Ноутбуки и планшеты
[0] => Ноутбуки и планшеты
)
[2] => Array
(
[name] => Компьютеры и периферия
[0] => Компьютеры и периферия
)
[3] => Array
(
[name] => Комплектующие для ПК
[0] => Комплектующие для ПК
)
)
PDO::FETCH_GROUP
Группирует значения по первой колонке. К примеру, нижеследующий код разобьёт пользователей на мальчиков и девочек, и положит их в разные массивы:
$data = $pdo->query('SELECT sex, name, car FROM users')->fetchAll(PDO::FETCH_GROUP);
// Результат
array (
'male' => array ( 0 =>
array (
'name' => 'John',
'car' => 'Toyota',
),
1 => array (
'name' => 'Mike',
'car' => 'Ford',
),
),
'female' => array (
0 => array (
'name' => 'Mary',
'car' => 'Mazda',
),
1 => array (
'name' => 'Kathy',
'car' => 'Mazda',
),
),
)
То есть, этот режим идеально подходит для классической задачи вывести события сгруппированные по дням (или вывести товары, сгруппированные по категориям). Также может комбинироваться с PDO::FETCH_COLUMN:
$sql = "SELECT sex, name FROM users";
$data = $pdo->query($sql)->fetchAll(PDO::FETCH_GROUP|PDO::FETCH_COLUMN);
// Результат
array (
'male' =>
array (
0 => 'John',
1 => 'Mike',
),
'female' =>
array (
0 => 'Mary',
1 => 'Kathy',
),
)
PDO::FETCH_CLASS
Создаёт объект указанного класса, заполняя его свойства данными из БД. Однако здесь, увы, начинаются неудобства и непоследовательность в работе вызывающих функций. Если для fetchAll() можно написать красиво и компактно
$data = $pdo->query('SELECT * FROM users LIMIT 1')->fetchAll(PDO::FETCH_CLASS, 'Foo');
то для fetch() приходится писать такую колбасу:
$stmt = $pdo->query('SELECT * FROM users LIMIT 1');
$stmt->setFetchMode( PDO::FETCH_CLASS, 'Foo');
$data = $stmt->fetch();
Из-за того что fetch() не позволяет передать имя класса, мы вынуждены пользоваться setFetchMode(). А учитывая, что эта функция возвращает булево значение, а не ссылку на объект, мы не можем использовать method chaining. Также следует помнить, что в этом режиме PDO будет вызывать магический метод __set() если свойство, совпадающее с именем поля, не найдено в объекте. Для PHP это означает, что если в объекте отсутствует такой метод, то все колонки строки, полученной из БД, будут назначены переменным класса. Если же мы хотим присвоить значения только существующим переменным, то этот момент надо контролировать с помощью метода __set(). Например
class Foo
{
private $name;
public function __set($name, $value) {}
}
$data = $pdo->query('SELECT * FROM users LIMIT 1')
->fetchAll(PDO::FETCH_CLASS, 'Foo');
array(1) {
[0]=> object(Foo)#3 (1) {
["name":"Foo":private]=> string(4) "John"
}
}
в то время как у класса с пустым __set() будут заполнены только существующие свойства:
class Foo {}
$data = $pdo->query('SELECT * FROM users LIMIT 1')
->fetchAll(PDO::FETCH_CLASS, 'Foo');
// Результат
array(1) {
[0]=> object(Foo)#3 (3) {
["name"] => string(4) "John"
["sex"] => string(4) "male"
["car"] => string(6) "Toyota"
}
}
Можно, кстати, заметить, что PDO присваивает значения и приватным свойствам, что несколько неожиданно, но очень удобно.
PDO::FETCH_CLASSTYPE
Очень интересная константа. Представляет собой не самостоятельный режим получения данных, а флаг-модификатор, изменяющий поведение других режимов. При её использовании PDO будет брать имя класса из первой колонки полученных из БД данных. То есть, с её помощью код для fetch() можно сделать короче
class Foo {}
$data = $pdo->query("SELECT 'Foo', name FROM users LIMIT 1")
->fetch(PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE);
// Результат
object(Foo)#3 (1) {
["name"]=> string(4) "John"
}
PDO::FETCH_PROPS_LATE
Ещё один флаг-модификатор. По умолчанию PDO присваивает значения свойствам класса до вызова конструктора. При помощи же данной константы это поведение можно изменить - сначала будет вызываться конструктор:
class Foo {
private $name;
public function __construct() {
$this->name = NULL;
}
}
$data = $pdo->query('SELECT name FROM users LIMIT 1')
->fetchAll(PDO::FETCH_CLASS, 'Foo');
var_dump($data);
$data = $pdo->query('SELECT name FROM users LIMIT 1')
->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, 'Foo');
var_dump($data);
// Результат
array(1) {
[0]=> object(Foo)#3 (1) {
["name":"Foo":private]=>
NULL
}
}
array(1) {
[0]=> object(Foo)#4 (1) {
["name":"Foo":private]=> string(4) "John"
}
}
PDO::FETCH_INTO
В отличие от PDO::FETCH_CLASS не создаёт новый объект, а обновляет существующий. Соответственно, в качестве параметра передается переменная с объектом. По очевидным причинам имеет смысл только с fetch()
class Foo
{
public $name;
public $state;
public function __construct()
{
$this->name = NULL;
}
}
$foo = new Foo;
$foo->state = "up'n'running";
var_dump($foo);
$stmt = $pdo->query('SELECT name FROM users LIMIT 1');
$stmt->setFetchMode(PDO::FETCH_INTO, $foo);
$data = $stmt->fetch();
var_dump($data, $foo);
// Результат
object(Foo)#2 (2) {
["name"] => NULL
["state"] => string(12) "up'n'running"
}
object(Foo)#2 (2) {
["name"] => string(4) "John"
["state"] => string(12) "up'n'running"
}
object(Foo)#2 (2) {
["name"] => string(4) "John"
["state"] => string(12) "up'n'running"
}
Как видно, fetch() возвращает тот же объект, что представляется мне несколько избыточным. Также, с сожалением приходится констатировать, что в отличие от PDO::FETCH_CLASS, этот режим не присваивает значения приватным свойствам.
PDO::FETCH_SERIALIZE
Ещё один флаг для PDO::FETCH_CLASS. Должен возвращать объект, который хранился в БД в сериализованном виде. Конструктор не вызывается. На данный момент не работает. Должно быть что-то вроде такого
class foo {}
$foo = new foo;
$foo->status="up'n'running";
$sFoo = serialize($foo);
// записываем $sFoo в БД
// и потом что-то вроде
$stmt = $pdo->query('SELECT sFoo FROM table');
$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_SERIALIZE, 'foo');
$foo = $stmt->fetch();
PDO::FETCH_FUNC
Для любителей замыканий. Работает только внутри fetchAll(). В параметры функции PDO передаёт переменные для каждого полученного поля, что может быть неудобным - нет доступа к именам полей, а только к значениям. К примеру, эмуляция работы PDO::FETCH_COLUMN:
$data = $pdo
->query('SELECT name FROM users')
->fetchAll(PDO::FETCH_FUNC, function($first) {return $first;});
PDO::FETCH_NAMED
Почти то же самое, что PDO::FETCH_ASSOC, но с одним отличием. Много раз я встречал на форумах вопросы о том, как получить значения полей с одинаковыми именами из разных таблиц при джойне. Всегда ответ был один - писать алиасы руками в запросе или использовать цифровые индексы. А вот и ответ от PDO: получение данных в этом режиме аналогично PDO::FETCH_ASSOC, но если встречаются поля с одинаковыми именами, то все значения по очереди записываются во вложенный массив. Допустим, у нас есть таблицы users и companies, причем в обеих есть поле name. Если получать данные традиционным путём, то одно из полей будет съедено:
$data = $pdo->query("SELECT * FROM users, companies WHERE users.name=username")->fetch();
// Результат
array(3) {
["name"] => string(10) "ACME, Inc."
["sex"] => string(4) "male"
["username"] => string(4) "John"
}
Если же указать это флаг, то все значения колонок с совпадающими именами будут собраны во вложенном массиве в порядке поступления:
$data = $pdo->query("SELECT * FROM users, companies WHERE users.name=username")
->fetch(PDO::FETCH_NAMED);
// Результат
array(3) {
["name"]=> array(2) {
[0]=> string(4) "John"
[1]=> string(10) "ACME, Inc."
}
["sex"] => string(4) "male"
["username"] => string(4) "John"
}
PDO::FETCH_BOUND
Очень интересный режим, сильно отличающийся от других. В отличие от всех остальных, он не возвращает не массив или объект. Вместо этого он присваивает значения переменным, предварительно указанным с помощью bindColumn() - режим, аналогичный тому, что используется в mysqli при получении данных из подготовленного запроса. Пример есть в документации
Материал подготовлен на основе официальной статьи .
