Введение в работу с MySQL в PHP
Как правило, в качестве хранилища данных используются базы данных. PHP позволяет использовать различные системы управления базами данных, но наиболее популярной на сегодняшний день в связке с PHP является СУБД MySQL.
MySQL бесплатную систему управления базами данных, которая разрабатывается компанией Oracle и которая позволяет взаимодействовать с базой данных с помощью команд языка SQL. MySQL относительно легко устанавливать и настраивать. Более того эта СУБД может работать на всех популярных ОС — на Windows, MacOS, Linux. MySQL вполне подходит как для маленьких, так и для больших проектов.
Сам процесс установки и конфигурации MySQL можно посмотреть в соответствующем руководстве — Руководство по MySQL. В данном случае мы будем рассматривать только взаимодействие PHP с MySQL.
Формально есть два способа для подключения к MySQL из PHP:
- Библиотека MySQLi (Improved MySQL)
- Библиотека PDO (PHP Data Objects)
Преимуществом pdo является то, что оно позволяет работать не только с mysql, но и с еще рядом систем баз данных — Firebird, PostreSQL, SQLite, Oracle, MS SQL Server и т.д. С помощью PDO можно использовать общий подход для подключения к поддерживаемым системам баз данных, где часто достаточно изменить строку подключения, что естественно добавляет гибкости. Также особенностью PDO является то, что эта библиотека представляет объектно-ориентированный подход для работы с базами данных.
Расширение MySQLi ограничено только одной СУБД — MySQL. MySQLi предоставляет два способа взаимодействия с базами данных: объектно-ориентированный и процедурный. К преимуществам MySQLi нередко относят то, что она больше ориентирована на специфику MySQL, специфичные для этой СУБД возможности и быстрее применяет новвоведения, которая появляются с новыми выпусками MySQL. Кроме того, также в качестве преимущества MySQLi нередко заявляют о большей производительности и скорости по сравнению с PDO.
Как бы то ни было, в настоящее время распространены оба подхода. Поэтому далее мы рассмотрим, как работать с MySQL как через PDO, так и через MySQLi.
Обе библиотеки — и mysqli и pdo_mysql по умолчанию включены в базовый комплект PHP. И нам только надо немного изменить файл конфигурации php.ini , чтобы начать работу с этими библиотеками.
Подключение mysqli
Чтобы использовать библиотеку mysqli для работы с MySQL, нам надо указать соответствующее расширение в файле php.ini . По умолчанию оно уже имеется в файле, только оно закомментировано. Так, найдем в файле php.ini следующую строку:
;extension=mysqli
Раскомментируем ее, убрав знак точки с запятой:
extension=mysqli
Подключение pdo_mysql
Чтобы использовать библиотеку pdo_mysql найдеем в файле php.ini следующую строку:
;extension=pdo_mysql
Раскомментируем ее, убрав точку с запятой:
extension=pdo_mysql
Теперь мы можем использовать оба расширения для работы с базой данных MySQL.
PDO против MySQLi. Что выбрать?
Когда возникает вопрос о доступе к базе данных из кода PHP, есть два варианта: MySQLi и PDO. Что нужно знать, прежде чем сделать выбор? Различия, поддержка баз данных, стабильность, и производительность в общих чертах описываются в данном уроке.
Резюме
| PDO | MySQLi | |
| Поддержка баз данных | 12 различных драйверов | Только MySQL |
| API | ООП | ООП+процедурная часть |
| Соединение | Просто | Просто |
| Именованные параметры | Есть | Нет |
| Объектное отображение | Есть | Есть |
| Подготовленные выражения (сторона клиента) | Есть | Нет |
| Производительность | Хорошая | Хорошая |
| Хранимые процедуры | Есть | Есть |
СоединениеConnection
Оба варианта предоставляют очень простые инструменты для соединения с базой данных:
// PDO $pdo = new PDO("mysql:host=localhost;dbname=database", 'username', 'password'); // MySQLi, процедурная часть $mysqli = mysqli_connect('localhost','username','password','database'); // MySQLi, ООП $mysqli = new mysqli('localhost','username','password','database');
API
И PDO и MySQLi предлагают объектно-ориентированное API. Но MySQLi также имеет процедурную часть API, которая для новичков может показаться проще для освоения. Если вы знакомы с собственным драйвером PHP MySQL, то мигрирование на процедурную часть MySQLi будет для вас проще. Но достигнув вершин мастерства в использовании PDO, его можно будет использовать с любой базой данных без каких-либо изменений основного кода
Поддержка баз данных
Ключевым преимуществом PDO перед MySQLi является его могучая поддержка различных баз данных. На момент написания урока PDO может использовать 12 драйверов. А MySQLi — поддерживает только MySQL.
Чтобы распечатать список поддерживаемых драйверов PDO можно использовать следующий код:
var_dump(PDO::getAvailableDrivers());
Что означает разница в количестве поддерживаемых баз данных? Для ситуаций, когда в проекте надо перейти на использование другой базы данных, PDO позволит сделать процесс прозрачным. Все, что нужно будет сделать — изменить строку соединения и несколько запросов, если какие-либо методы не поддерживаются новой базой данных. В случае с MySQLi придется переписывать весь код, включая запросы.
Именованные параметры
Другой важной отличительной особенностью PDO являются именованные параметры, которые делают процедуру привязывания существенно проще:
$params = array(':username' => 'test', ':email' => $mail, ':last_login' => time() - 3600); $pdo->prepare(' SELECT * FROM users WHERE username = :username AND email = :email AND last_login > :last_login'); $pdo->execute($params);
Сравните с MySQLi:
$query = $mysqli->prepare(' SELECT * FROM users WHERE username = ? AND email = ? AND last_login > ?'); $query->bind_param('sss', 'test', $mail, time() - 3600); $query->execute();
Знак вопроса может показаться короче, чем символьные имена. Однако, теряется гибкость и устойчивость к ошибкам, так как разработчику нужно помнить о порядке следования параметров, что в большинстве случаев представляет собой зону с очень высокой вероятностью трудно распознаваемых ошибок.
К сожалению, MySQLi не поддерживает именованные параметры.
Объектное отображение
И PDO и MySQLi могут отображать результаты как объекты. Данная особенность может быть полезна в том случае, если вы не хотите использовать уровень абстракций базы данных и желаете реализовать модель объектно-реляционного отображения. Допустим, у нас есть класс User с некоторыми свойствами, которые соответствуют именам полей в базе данных:
class User < public $id; public $first_name; public $last_name; public function info() < return '#'.$this->id.': '.$this->first_name.' '.$this->last_name; > >
Без объектного отображения нужно будет заполнять значениями каждое поле (либо вручную, либо с помощью конструктора) прежде, чем можно будет использовать метод info() корректно.
Но объектное отображение позволяет предопределять свойства даже до того, как объект будет построен. Например:
$query = "SELECT id, first_name, last_name FROM users"; // PDO $result = $pdo->query($query); $result->setFetchMode(PDO::FETCH_CLASS, 'User'); while ($user = $result->fetch()) < echo $user->info()."\n"; > // MySQLI, процедурная часть if ($result = mysqli_query($mysqli, $query)) < while ($user = mysqli_fetch_object($result, 'User')) < echo $user->info()."\n"; > > // MySQLi, ООП if ($result = $mysqli->query($query)) < while ($user = $result->fetch_object('User')) < echo $user->info()."\n"; > >
Безопасность
Обе библиотеки предоставляют средства для защиты от SQL инъекций, которые разработчики могут использовать по своему усмотрению.
Допустим, злодей пытается встроить вредный запрос SQL через параметр ‘username’ HTTP запроса (GET):
$_GET['username'] = "'; DELETE FROM users; /*"
Если пропустить такое выражение, то оно будет включено в запрос в том виде, как есть – запрос удаляет все строки из таблицы users (и PDO и MySQLi поддерживают множественные запросы).
// PDO, "ручная" зачистка параметра $username = PDO::quote($_GET['username']); $pdo->query("SELECT * FROM users WHERE username = $username"); // MySQLi, "ручная" зачистка параметра $username = mysqli_real_escape_string($_GET['username']); $mysqli->query("SELECT * FROM users WHERE username = '$username'");
Метод PDO::quote() не только отбрасывает лишние символы в строке, но и заключает ее в кавычки. А функция mysqli_real_escape_string() только отбрасывает лишние символы в строке, а в кавычки ее надо будет помещать вручную.
Другой метод защиты:
// PDO, подготовленные выражения $pdo->prepare('SELECT * FROM users WHERE username = :username'); $pdo->execute(array(':username' => $_GET['username'])); // mysqli, подготовленные выражения $query = $mysqli->prepare('SELECT * FROM users WHERE username = ?'); $query->bind_param('s', $_GET['username']); $query->execute();
Лучше использовать подготовленные выражения, чем метод PDO::quote() и функцию mysqli_real_escape_string() .
Производительность
И PDO и MySQLi достаточно быстро выполняются. MySQLi имеет небольшое преимущество по результатам тестов – ~2.5% для обычных запросов и ~6.5% для подготовленных выражений. Так что стоит принять информацию во внимание, если для вас будет важно даже минимальное различие в характеристиках.
Заключение
PDO одержал сравнительно легкую победу в данном поединке. С 12 различными драйверами для баз данных (доступны 18 разных баз данных!) и именованными параметрами можно игнорировать небольшое отставание в производительности. С точки зрения безопасности обе библиотеки предоставляют разработчику равные возможности и стойкость кода зависит только от программиста.
Данный урок подготовлен для вас командой сайта ruseller.com
Источник урока: net.tutsplus.com/tutorials/php/pdo-vs-mysqli-which-should-you-use/
Перевел: Сергей Фастунов
Урок создан: 25 Февраля 2012
Просмотров: 79079
Правила перепечатки
5 последних уроков рубрики «PHP»
Фильтрация данных с помощью zend-filter
Когда речь идёт о безопасности веб-сайта, то фраза «фильтруйте всё, экранируйте всё» всегда будет актуальна. Сегодня поговорим о фильтрации данных.
Контекстное экранирование с помощью zend-escaper
Обеспечение безопасности веб-сайта — это не только защита от SQL инъекций, но и протекция от межсайтового скриптинга (XSS), межсайтовой подделки запросов (CSRF) и от других видов атак. В частности, вам нужно очень осторожно подходить к формированию HTML, CSS и JavaScript кода.
Подключение Zend модулей к Expressive
Expressive 2 поддерживает возможность подключения других ZF компонент по специальной схеме. Не всем нравится данное решение. В этой статье мы расскажем как улучшили процесс подключение нескольких модулей.
Совет: отправка информации в Google Analytics через API
Предположим, что вам необходимо отправить какую-то информацию в Google Analytics из серверного скрипта. Как это сделать. Ответ в этой заметке.
Подборка PHP песочниц
Подборка из нескольких видов PHP песочниц. На некоторых вы в режиме online сможете потестить свой код, но есть так же решения, которые можно внедрить на свой сайт.
PDO vs MySQLi: что выбрать?
При работе с базами данных в PHP, у нас есть два варианта на выбор: MySQLi и PDO. И так, что вы должны знать, перед тем как сделаете свой выбор? В этой статье будут изложены различия, поддержка баз данных, стабильность и проблемы производительности.
Резюме
| PDO | MySQLi | |
| Поддержка баз данных | 12 различных драйверов | Только MySQL |
| API | OOP | OOP и процедурный |
| Соединение | Легкое | Легкое |
| Именованные параметры | Есть | Нет |
| Отображение на объект | Есть | Нет |
| Подготовленные запросы (на клиенте) |
Есть | Нет |
| Производительность | Высокая | Высокая |
| Хранимые процедруы | Есть | Есть |
Соединение
Подключение к базе для обоих вариантов:
$pdo = new PDO("mysql:host=localhost;dbname=database", 'username', 'password');
// mysqli, procedural way
$mysqli = mysqli_connect('localhost','username','password','database');
// mysqli, object oriented way
$mysqli = new mysqli('localhost','username','password','database');
Обратите внимание, что эти объекты соединений/ресурсы далее будут рассматриваться как уже существующие.
Поддержка API
Оба PDO и MySQLi предлагают объектно-ориентированный API, но MySQLi так же предлагает и процедурный подход — что делает его для новичков легче в понимании. Если вы знакомы с нативным PHP драйвером для MySQL, то с легкостью перейдете на процедурный интерфейс MySQLi. С другой стороны, как только вы освоите PDO, то сможете использовать его с любой базой данной, как пожелаете.
Поддержка баз данных
Основное преимущество PDO над MySQLi в поддержке различных драйверов. На момент написания этой статьи, PDO поддерживает 12 различных драйверов, в отличие от MySQLi, который поддерживает только MySQL.
Чтобы вывести все поддерживаемые PDO драйверы, воспользуйтесь следующим кодом:
var_dump(PDO::getAvailableDrivers());
Что это значит? В ситуациях, когда в вашем проекте вы решите поменять базу данных, с PDO этот процесс будет достаточно прозрачным. Итак, все что вам нужно будет сделать, это изменить строку подключения и несколько запросов, если в них используются методы, не поддерживаемые вашей новой базой данных. С MySQLi вам придется переписать каждую строчку кода — включая запросы.
Именованные параметры
Это еще одна важная возможность в PDO; привязка параметров гораздо удобнее, чем просто использовать нумерацию:
$params = array(':username' => 'test', ':email' => $mail, ':last_login' => time() - 3600);
PDO vs. MySQLi: The Battle of PHP Database APIs
Long gone are the days of using the mysql_ extension, as its methods have been deprecated since PHP 5.5 and removed as of PHP 7. Alas, the internet is still plagued with a ton of old tutorials that beginners will simply copy/paste and use on a shared hosting platform with an older PHP version, thus continuing its legacy.
If you are using MySQL or MariaDB in PHP, then you have the ability to choose either MySQLi or PDO. The former is simply an improved version with procedural and OOP support and added prepared statements, while the latter is an abstraction layer that allows you to use a unified API for all 12 database drivers it supports. Though it should be mentioned that MySQL is undoubtedly the most popular database to use in the PHP world anyway.
In theory, one might assume the discussion should be over. We don’t need a vendor-specific API for every type of database that exists, as it’s so much simpler to use just one. While there’s certainly a lot of truth to this, the problem is that PDO_MYSQL simply doesn’t have all of the newest and most advanced features MySQLi does. I honestly don’t understand why this is the case, as it would completely eliminate any reason to use the vendor-specific API. That said, I’d imagine that most people don’t need these extra features, but there are definitely some who do.
For anyone who’s interested, here’s a full writeup of PDO and MySQLi.
PDO Advantages
MySQLi has quite a few aspects to play catchup with PDO. It needs to adds features like:
- Useful fetch modes
- Allow to pass variables and values directly into execute
- Ability to auto-detect variable types (What actually happens is that everything is treated as a string when sent to the sever, but is converted to the correct type. This works 100% of the time with native prepared statements but doesn’t work with certain edge cases, such as LIKE with emulation mode.)
- Provides an option to have automatically buffered results with prepared statements
- Named parameters (though useless with emulation mode turned off in PDO, as you can only use the same name once)
As you can see, there are quite a few things MySQLi should learn from PDO if it wants to stay relevant.
If it does, then there should really be no difference at all. People always talk about how you’d have to learn a whole new extension, yet they’re actually already nearly identical for the most part. For this article, I’ll be using native prepared statements, but emulated ones are perfectly acceptable as well. Here’s a short writeup on the differences between the two.
MySQLi Advantages
PDO is also missing some features, albeit far less important ones for most users, such as:
- Asynchronous queries
- Ability to get more info on affected rows, like updating a row with the same values (can be done in PDO as a constructor setting you can’t change it later)
- Proper database closing method
- Multiple queries at once (though it can if emulation mode is turned on in PDO)
- Automatic cleanup with persistent connections
So Which Should I Use?
My opinion is that PDO should be used by default, especially beginners, due to its versatility, general predictability and useful fetch modes. However, MySQLi would be a better choice for advanced users who want the newest, MySQL-specific functionality.
It’s somewhat ironic that more experienced PHP developers tend think PDO is the only acceptable option 100% of the time, while beginners tend to use MySQLi. This is absolutely nutty from both ends. Of course most developers don’t really need the extra advanced features MySQLi offers, but it certainly could be extremely useful for some, as previously mentioned.
It’s especially curious that novices are scared to try something «new» and switch to PDO, while a lot of advanced users recite the good ole «ease of switching from database driver» argument as PDO’s advantage. Anyone who believes the myth that you can easily switch among databases in PDO seamlessly has obviously never attempted to do so. Each driver is different, and a switch from Microsoft SQL Server to MySQL will certainly not be automated. First of all let’s make one thing clear, the syntax is very similar — almost identical, and I will present that in examples. PDO is also not some abstraction layer over MySQLi, but rather over PDO_MYSQL.
If PDO does end up keeping up with all of the latest or distinct MySQL functionality, then I could see why MySQLi should go away; I’d even encourage it, if it ends up being the case. Though PDO does have several driver-specific features, it doesn’t have all nor keep up with the latest. This is precisely why I don’t think MySQLi and PDO aren’t necessarily competitors, but rather two powerful libraries with completely different focuses for now. Obviously PDO should be more widely used, however. But as said before, the difference is pretty much negligible as is anyway. As mentioned several times earlier, MySQLi’s survival relies on it catching up to PDO, along with PDO primarily sticking with features that are used among most of the DB drivers it supports.
Code Differences
As stated earlier, both PDO and MySQLi are extremely similar, but there’s slight differences in syntax. MySQLi follows the old-school PHP snake_case convention, while PDO uses camelCase. Additionally, MySQLi’s methods are used as object properties, while PDO uses the traditional syntax for functions.
I’ll never understand why both PDO and MySQLi complicated things by forcing you to use two separate methods to use prepared statement. Luckily PDO removed the need to use a dedicated bind function — though I’m not sure why the same isn’t done for execute() . Non-prepared MySQLi and PDO really aren’t so bad, and it’s only really the unfortunate implementation of prepared statements that caused them to seem verbose. For instance, in the vendor-specific PostgreSQL API you can do it like this. Here’s an example of how you’d do a «non-prepared» query to fetch an associative array with MySQLi and PDO, for reference.
$arr = $mysqli->query("SELECT * FROM myTable")->fetch_all(MYSQLI_ASSOC); $arr = $pdo->query("SELECT * FROM myTable")->fetchAll(PDO::FETCH_ASSOC); In reality, the best route is to use a wrapper, query builder or ORM. I have a fairly rudimentary MySQLi wrapper you might like. While PDO is a step in the right direction, as you can bind values directly into execute, it’s still not ideal. In the class I made, you can chain all of your calls, while passing in the values to bind as a parameter argument. Check out what you can do.
$arr = $mysqli->query("SELECT * FROM myTable WHERE id > ?", [12])->fetchAll('assoc'); You now have an entire associative array stored in the variable in a far more concise manner. It’s strange why both PDO and MySQLi don’t do it like this.
For the rest of the tutorial, we’ll be using prepared statements, as there isn’t a good reason not to use them for SQL injection protection, unless you’re using a feature like async, which currently doesn’t support them. Otherwise, you’ll need to properly manually format your queries.
Creating a New Database Connection
PDO
$dsn = "mysql:host=localhost;dbname=myDatabase;charset=utf8mb4"; $options = [ PDO::ATTR_EMULATE_PREPARES => false, // turn off emulation mode for "real" prepared statements PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, //turn on errors in the form of exceptions PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, //make the default fetch be an associative array ]; try < $pdo = new PDO($dsn, "username", "password", $options); >catch (Exception $e) < error_log($e->getMessage()); exit('Something weird happened'); //something a user can understand > MySQLi
mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT); try < $mysqli = new mysqli("localhost", "username", "password", "databaseName"); $mysqli->set_charset("utf8mb4"); > catch(Exception $e) < error_log($e->getMessage()); exit('Error connecting to database'); //Should be a message a typical user could understand > Insert, Update, Delete
PDO
$stmt = $pdo->prepare("INSERT INTO myTable (name, age) VALUES (?, ?)"); $stmt->execute([$_POST['name'], 29]); $stmt = null; MySQLi
$stmt = $mysqli->prepare("UPDATE myTable SET name = ? WHERE $_POST['name'], $_SESSION['id']); $stmt->execute(); $stmt->close(); It should be noted that with PDO, you can chain prepare() and execute() , though you won’t be to get the affected rows, so I can’t see that being useful.
Get Number of Affected Rows
PDO
$stmt->rowCount(); MySQLi
$stmt->affected_rows; Get Latest Primary Key Inserted
Notice, how both of these use the connection variable, instead of $stmt .
PDO
$pdo->lastInsertId(); MySQLi
$mysqli->insert_id; Get Rows Matched
PDO
In PDO, the only way to achieve this is by setting it as a connection option to change the behavior of rowCount() , unfortunately. This means rowCount() will either return rows matched or rows changed for your entire database connection, but not both.
$options = [ PDO::MYSQL_ATTR_FOUND_ROWS => true ]; MySQLi
$mysqli->info; This will output an entire string of information, like so:
Rows matched: 1 Changed: 0 Warnings: 0 I have no idea why they thought this would be a wise implementation, as it would be far more convenient in an array. Luckily, you can do this.
preg_match_all('/(\S[^:]+): (\d+)/', $mysqli->info, $matches); $infoArr = array_combine ($matches[1], $matches[2]); var_export($infoArr); Now you can access the values pretty easily. Note, that the value is a string, so you either cast all the values to ints, so === can work or strictly check with == .
['Rows matched' => '1', 'Changed' => '0', 'Warnings' => '0'] Fetching
Fetch Associative Array
PDO
$stmt = $pdo->prepare("SELECT * FROM myTable WHERE id execute([5]); $arr = $stmt->fetchAll(PDO::FETCH_ASSOC); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$stmt = $mysqli->prepare("SELECT id, name, age FROM myTable WHERE name = ?"); $stmt->bind_param("s", $_POST['name']); $stmt->execute(); $arr = $stmt->get_result()->fetch_all(MYSQLI_ASSOC); if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); Fetch Single Row
PDO
$stmt = $pdo->prepare("SELECT id, name, age FROM myTable WHERE name = ?"); $stmt->execute([$_POST['name']]); $arr = $stmt->fetch(PDO::FETCH_ASSOC); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$stmt = $mysqli->prepare("SELECT id, name, age FROM myTable WHERE name = ?"); $stmt->bind_param("s", $_POST['name']); $stmt->execute(); $arr = $stmt->get_result()->fetch_assoc(); if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); Fetch Single Value (Scalar)
PDO
$stmt = $pdo->prepare("SELECT id, name, age FROM myTable WHERE name = ?"); $stmt->execute([$_POST['name']]); $arr = $stmt->fetch(PDO::FETCH_COLUMN); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$stmt = $mysqli->prepare("SELECT id, name, age FROM myTable WHERE name = ?"); $stmt->bind_param("s", $_POST['name']); $stmt->execute(); $arr = $stmt->get_result()->fetch_row()[0]; if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); Fetch Array of Objects
PDO
class myClass <> $stmt = $pdo->prepare("SELECT name, age, weight FROM myTable WHERE name = ?"); $stmt->execute(['Joe']); $arr = $stmt->fetchAll(PDO::FETCH_CLASS, 'myClass'); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
class myClass <> $arr = []; $stmt = $mysqli->prepare("SELECT id, name, age FROM myTable WHERE $_SESSION['id']); $stmt->execute(); $result = $stmt->get_result(); while($row = $result->fetch_object('myClass')) < $arr[] = $row; >if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); PDO really shines here as you can see. It’s very odd why MySQLi doesn’t have something like $mysqli_result->fetch_all(MYSQLI_OBJ) . PDO even takes it a step further and has an awesome way to deal with the annoying default behavior of it getting called after the class constructor, via bitwising it with fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, ‘myClass’) . It’s possible to replicate this behavior in MySQLi, but it relies on either leaving out the constructor and relying on the magic __set() or by only setting it in the constructor if it doesn’t equal the default value.
Like
PDO
$search = "%%"; $stmt = $pdo->prepare("SELECT id, name, age FROM myTable WHERE name LIKE ?"); $stmt->execute([$search]); $arr = $stmt->fetchAll(); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$search = "%%"; $stmt = $mysqli->prepare("SELECT id, name, age FROM myTable WHERE name LIKE ?"); $stmt->bind_param("s", $search); $stmt->execute(); $arr = $stmt->get_result()->fetch_all(MYSQLI_ASSOC); if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); Fetch Modes
This is by far my favorite feature about PDO. The fetch modes in PDO are extremely useful and it’s quite shocking that MySQLi hasn’t added them yet.
Fetch Key/Value Pair
PDO
$stmt = $pdo->prepare("SELECT event_name, location FROM events WHERE id < ?"); $stmt->execute([25]); $arr = $stmt->fetchAll(PDO::FETCH_KEY_PAIR); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$arr = []; $id = 25; $stmt = $con->prepare("SELECT event_name, location FROM events WHERE id < ?"); $stmt->bind_param("i", $id); $stmt->execute(); $result = $stmt->get_result(); while($row = $result->fetch_row()) < $arr[$row[0]] = $row[1]; >if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); ['Cool Event' => 'Seattle', 'Fun Event' => 'Dallas', 'Boring Event' => 'Chicago'] Fetch Group Column
PDO
$stmt = $pdo->prepare("SELECT hair_color, name FROM myTable WHERE id < ?"); $stmt->execute([10]); $arr = $stmt->fetchAll(PDO::FETCH_GROUP | PDO::FETCH_COLUMN); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$arr = []; $id = 10; $stmt = $con->prepare("SELECT hair_color, name FROM myTable WHERE id < ?"); $stmt->bind_param("i", $id); $stmt->execute(); $result = $stmt->get_result(); while($row = $result->fetch_row()) < $arr[$row[0]][] = $row[1]; >if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); [ 'blonde' => ['Patrick', 'Olivia'], 'brunette' => ['Kyle', 'Ricky'], 'red' => ['Jordan', 'Eric'] ] Fetch Key/Value Pair Array
PDO
$stmt = $pdo->prepare("SELECT id, max_bench, max_squat FROM myTable WHERE weight < ?"); $stmt->execute([200]); $arr = $stmt->fetchAll(PDO::FETCH_UNIQUE); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$arr = []; $weight = 200; $stmt = $con->prepare("SELECT id, max_bench, max_squat FROM myTable WHERE weight < ?"); $stmt->bind_param("i", $weight); $stmt->execute(); $result = $stmt->get_result(); $firstColName = $result->fetch_field_direct(0)->name; while($row = $stmtResult->fetch_assoc()) < $firstColVal = $row[$firstColName]; unset($row[$firstColName]); $arr[$firstColVal] = $row; >if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); [ 17 => ['max_bench' => 230, 'max_squat' => 175], 84 => ['max_bench' => 195, 'max_squat' => 235], 136 => ['max_bench' => 135, 'max_squat' => 285] ] Fetch Group
PDO
$stmt = $pdo->prepare("SELECT hair_color, name, age FROM myTable WHERE id < ?"); $stmt->execute([12]); $arr = $stmt->fetchAll(PDO::FETCH_GROUP); if(!$arr) exit('No rows'); var_export($arr); $stmt = null; MySQLi
$arr = []; $id = 12; $stmt = $con->prepare("SELECT hair_color, name, age FROM myTable WHERE id < ?"); $stmt->bind_param("i", $id); $stmt->execute(); $result = $stmt->get_result(); $firstColName = $result->fetch_field_direct(0)->name; while($row = $stmtResult->fetch_assoc()) < $firstColVal = $row[$firstColName]; unset($row[$firstColName]); $arr[$firstColVal][] = $row; >if(!$arr) exit('No rows'); var_export($arr); $stmt->close(); [ 'blonde' => [ ['name' => 'Patrick', 'age' => 22], ['name' => 'Olivia', 'age' => 18] ], 'brunette' => [ ['name' => 'Kyle', 'age'=> 25], ['name' => 'Ricky', 'age' => 34] ], 'red' => [ ['name' => 'Jordan', 'age' => 17], ['name' => 'Eric', 'age' => 52] ] ] Where In Array
PDO
$inArr = [1, 3, 5]; $clause = implode(',', array_fill(0, count($inArr), '?')); //create 3 question marks $stmt = $pdo->prepare("SELECT * FROM myTable WHERE id IN ($clause)"); $stmt->execute($inArr); $resArr = $stmt->fetchAll(); if(!$resArr) exit('No rows'); var_export($resArr); $stmt = null; MySQLi
$inArr = [12, 23, 44]; $clause = implode(',', array_fill(0, count($inArr), '?')); //create 3 question marks $types = str_repeat('i', count($inArr)); //create 3 ints for bind_param $stmt = $mysqli->prepare("SELECT id, name FROM myTable WHERE id IN ($clause)"); $stmt->bind_param($types, . $inArr); $stmt->execute(); $resArr = $stmt->get_result()->fetch_all(MYSQLI_ASSOC); if(!$resArr) exit('No rows'); var_export($resArr); $stmt->close(); Where In Array With Other Placeholders
PDO
$inArr = [1, 3, 5]; $clause = implode(',', array_fill(0, count($inArr), '?')); //create 3 question marks $stmt = $pdo->prepare("SELECT * FROM myTable WHERE id IN ($clause) AND id < ?"); $fullArr = array_merge($inArr, [5]); //merge WHERE IN array with other value(s) $stmt->execute($fullArr); $resArr = $stmt->fetchAll(); if(!$resArr) exit('No rows'); var_export($resArr); $stmt = null; MySQLi
$inArr = [12, 23, 44]; $clause = implode(',', array_fill(0, count($inArr), '?')); //create 3 question marks $types = str_repeat('i', count($inArr)); //create 3 ints for bind_param $types .= 'i'; //add 1 more int type $fullArr = array_merge($inArr, [26]); //merge WHERE IN array with other value(s) $stmt = $mysqli->prepare("SELECT id, name FROM myTable WHERE id IN ($clause) AND age > ?"); $stmt->bind_param($types, . $fullArr); //4 placeholders to bind $stmt->execute(); $resArr = $stmt->get_result()->fetch_all(MYSQLI_ASSOC); if(!$resArr) exit('No rows'); var_export($resArr); $stmt->close(); Transactions
PDO
try < $pdo->beginTransaction(); $stmt1 = $pdo->prepare("INSERT INTO myTable (name, state) VALUES (?, ?)"); $stmt2 = $pdo->prepare("UPDATE myTable SET age = ? WHERE if(!$stmt1->execute(['Rick', 'NY'])) throw new Exception('Stmt 1 Failed'); else if(!$stmt2->execute([27, 139])) throw new Exception('Stmt 2 Failed'); $stmt1 = null; $stmt2 = null; $pdo->commit(); > catch(Exception $e) < $pdo->rollback(); throw $e; > You might be wondering why I’m solely checking for truthiness on execute() with PDO. This is due to the fact that it can return false, while silently failing. Here’s a more detailed explanation.
MySQLi
try < $mysqli->autocommit(FALSE); //turn on transactions $stmt1 = $mysqli->prepare("INSERT INTO myTable (name, age) VALUES (?, ?)"); $stmt2 = $mysqli->prepare("UPDATE myTable SET name = ? WHERE $stmt1->bind_param("si", $_POST['name'], $_POST['age']); $stmt2->bind_param("si", $_POST['name'], $_SESSION['id']); $stmt1->execute(); $stmt2->execute(); $stmt1->close(); $stmt2->close(); $mysqli->autocommit(TRUE); //turn off transactions + commit queued queries > catch(Exception $e) < $mysqli->rollback(); //remove all queries from queue if error (undo) throw $e; > MySQLi also has a gotcha, but the solution is to convert errors to exception with a global handler. Read about it more here.
Named Paramters
This is a PDO-only feature, but it’s only useful if emulation mode is turned off. Otherwise, you can only use the same variable once. It should also be noted that the leading colon is not required, but this isn’t documented anywhere. It likely will eventually anyway, but you never know, I suppose. You also can’t mix ? placeholders with named ones; it’s either one or the other.
$stmt = $pdo->prepare("UPDATE myTable SET name = :name WHERE => 'David', ':id' => 3]); $stmt = null; Series
Author — Daniel Marcus
Firmly believes that web technologies should take over everything. Enjoys writing tutorials about JavaScript and PHP.