В прошлой заметке мы познакомились с основами 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 при получении данных из подготовленного запроса. Пример есть в документации

Материал подготовлен на основе официальной статьи .