Какие есть best practices в работе с PDO?

Question

[DukeRaul]

Добрый день.

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

Сейчас любое обращение к базе приводит к тому, что в коде появляется подобная "портянка":

function dinnerBase_getOrderTicket($base_connect, $users, $expiredtime){
    try {
        extract($base_connect);
        $dinnerBase = new PDO($host, $adm_user, $adm_password);
        $dinnerBase -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $dinnerBase->query("SET NAMES utf8");
        $dinnerBase->query("SET CHARACTER SET utf8");

        $query = "CREATE TABLE IF NOT EXISTS `:table_name` (
        ...
                $stmt = $dinnerBase -> prepare($query);
        $stmt -> execute(array(':table_name' => 'order_ticket'));
        }

    $dinnerBase = NULL;    
    } 
    catch (PDOException $e) {
    print "Error!: " . $e->getMessage() . "<br/>";
    die();
    }
}

Довольно объемно выходит, при этом код от обращения к обращению почти не меняется.

Вы могли бы накидать примеров кода с лучшими на ваш взгляд практиками использования PDO? Может стоит подключение к базе вывести в отдельную функцию которая возвращает объект PDO? Тогда как быть с конструкцией try-catch? Может стоит написать свою обертку для PDO? Но мне кажется это избыточно.

Answer 1

[Николай Васильчук]

Напишите простенький синглтон в котором храните соединение с БД, ловите ошибки и т.д.
Или отнаследуйтесь от PDO.
Работать будет как-то так:

$db = DB::getConnection();
$db->exec('UPDATE ...', array(/* arguments */));

Comments

[FanatPHP]

$db = DB::getConnection(); - это бессмыслица. Синглтон - это DB::exec().

[Николай Васильчук]

@FanatPHP Вот вам пример с википедии:

<?php
 class Singleton {
    private static $instance;
    private function __construct(){ /* ... @return Singleton */ }
    private function __clone()    { /* ... @return Singleton */ }
    private function __wakeup()   { /* ... @return Singleton */ }
    public static function getInstance() {
        if ( empty(self::$instance) ) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    public function doAction() { /* ... */ }
 }
 Singleton::getInstance()->doAction(); // Применение
?>

Answer 2

[FanatPHP]

а как быть с конструкцией try-catch?

Никак. Если подумать, то эта конструкция здесь не нужна: www.phpfaq.ru/pdo#exceptions

По поводу же синглтона, то если выкинуть всё лишнее, и использовать РНР5, то получится так

class DB
{
    protected static $instance = null;

    final private function __construct() {}
    final private function __clone() {}

    public static function instance()
    {
        if (self::$instance === null)
        {
            $dsn = 'mysql:host='.DB_HOST.';dbname='.DB_NAME.';charset='.DB_CHARSET;
            self::$instance = new PDO($dsn, DB_USER, DB_PASS);
            self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            self::$instance->query("SET NAMES ".DB_CHARSET);
        }
        return self::$instance;
    }
    public static function __callStatic($method, $args) {
        return call_user_func_array(array(self::instance(), $method), $args);
    }
}

и обращаться напрямую

$stmt = DB::prepare($query);

Comments

[Николай Васильчук]

Решение изящное. Работать будет. Но магический метод намного медленнее наследования.

[DukeRaul]

@FanatPHP за ссылку спасибо, за код тоже. продолжаю разбираться с pdo

[Tema Ovchinnikov]

Эх хотел бы и я так прогать(

Answer 3

[Mikhail Osher]

Да, конечно, незачем плодить 100 соединений.
Если у Вас преобладает функциональный стиль, тогда попробуйте что-то вроде такого:

function pdo()
{
    static $pdo;

    if (!$pdo) {
        // в первый раз инициализируем объект PDO
    }

    return $pdo;
}

И дальше пишите что Вам надо. :)

$stmt = pdo()->prepare('UPDATE order_tickets SET status = :stid WHERE id = :id');
...

Comments

[DukeRaul]

@Miraage Спасибо за Ваш ответ, а как быть с конструкцией try-catch?

[Mikhail Osher]

Обрабатывать на уровне приложения. Смотрите в сторону www.php.net/manual/ru/function.set-exception-handl...

Answer 4

[Dmitry]

Обычно перфекционистский подход следующий: от PDO наследуется класс, в котором определяется логика работы с БД.
Это не мешает ему одновременно быть синглтоном, как указал @Anonym.
Внутри класса, помимо подключения, можно определить свои функции к бд, тогда само соединение вообще не надо будет никуда возвращать, работать только с классом.
Например, вы определяете функцию myPDO::update(), в которую передаете текст запроса с именованными параметрами и сами эти параметры в ассоциативном массиве. Внутри функции вы выполняете обычные PDO функции и можете добавить свою обработку try-catch, тогда она не будет здесь захламлять код на каждом вызове.

Answer 5

[Виталий Желтяков]

Думаю разберётесь...

//---------------- Процедура подключения к базе данных -----------------------//
function dbconnect() {
	global $database;
	if (!isset($database)) {
		// Соединение по IP самое быстрое
		// Сразу задаём кодировку соединения
		$database = new PDO('mysql:host=127.0.0.1;dbname=base_name', "Vita", "god", array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'UTF8\''));
		// Устанавливаем уровень показа ошибок базы
		$database->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
	}
	return true;
}
//----------------------------------------------------------------------------//

//--------------------- Функция выполнения запросов --------------------------//
function sql_query($query) {
	global $errors;
	global $database;
	
	try { 
      if (dbconnect()) $return = $database->query($query);
   } 
   catch (PDOException $e) { 
      $error = $e->getMessage();
  		writelog('sql_error', date("y.m.d H:m:s")."\t".$error);
		$errors .= $error;
		return false;
   }

	return $return;
}
//----------------------------------------------------------------------------//

//------------------------ Процедура записи в лог фаил -----------------------//
function writelog($typelog, $log_text) {
	file_put_contents('logs/'.$typelog.'.txt', "$log_text\r\n", FILE_APPEND | LOCK_EX);
}
//----------------------------------------------------------------------------//

Comments

[Николай Васильчук]

Не совсем говнокод, конечно, но наличие global как-бы намекает.

[Виталий Желтяков]

@Anonym Вы боитесь глобальных переменных? Вам нужно срочно лечиться.

Неуместное использование глобальных переменных - это плохо, но это не значит, что их ненужно использовать вовсе

[Николай Васильчук]

@VitaZheltyakov Использование глобальных переменных говорит о том, что архитектура приложения - говно. А в данном конкретном случае они вообще не нужны.

[Виталий Желтяков]

@Anonym Я же говорю - лечиться Вам надо...

[Николай Васильчук]

@VitaZheltyakov Обязательно прислушаюсь к вашему авторитетному мнению

[Mikhail Osher]

Ничего личного, но глобальные переменные - это говнокод чистой воды.

[Виталий Желтяков]

@Miraage И чем Вы хотите их заменить - суперкласом или костылями?

[Николай Васильчук]

@VitaZheltyakov Конкретно в вашем случае - static переменной хватило бы.
А вообще, для работы с БД, обычно делают синглтон.
Я даже не могу представить себе пример приложения в котором потребуется использование глобальных переменных.

[Виталий Желтяков]

@Anonym Во-первых, что плохого в глобальных переменных?
Во-вторых, в моём случае статическая переменная не прокатит, т.к. нужно объединять функции.
В-третьих, чем ваш синглтон отличается от моего кода?

[Николай Васильчук]

@VitaZheltyakov Вам не нужно "объединять функции", сделайте, чтобы dbconnect() возвращала инстанс соединения или бросала исключение (ну или возвращала FALSE). Тогда необходимость переменной $database отпадет.
Чем плохи глобальные переменные и чем от них отличается синглтон - почитайте в википедии.

[Виталий Желтяков]

@Anonym Ход с инстансом, признаю, хороший.

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

Я спросил, чем ваш синглтон отличается от моего кода, а не от глобальных переменных (хотелось бы услышать ответ).

[Николай Васильчук]

@VitaZheltyakov Код должен быть модульным, чтобы "модули" можно было независимо тестировать, чтобы их области видимости не пересекались и чтобы их можно было использовать повторно.
Для работы с БД обычно пишут синглтон, в котором хранится инстанс подключения, обрабатываются ошибки, ведется лог, выполняются предварительные запросы (типа SET NAMES) и т.д. Один класс для работы с БД лучше, чем 3 функции и 2 глобальных переменных.

[Виталий Желтяков]

@Anonym
А если нужен сток данных? Например, как у меня с переменной $error, которая собирает не только ошибки базы.

Чем класс лучше функции?

[Николай Васильчук]

@VitaZheltyakov Чтобы собирать не только данные, сделайте класс Logger, который будет отвечать за сбор ошибок. В классе DB напишите use App\Logger и возрадуйтесь.

Чем ООП лучше можете погуглить, ну или вот статейку почитать habrahabr.ru/post/23619

[Виталий Желтяков]

Заменяем использование глобальной переменной использованием класса. Подвох не чувствуете?

Объективных причин превосходства классов над функциями нет, кроме 3 случаев: необходимости инкасуляции, наследования и полиморфизма.

[Николай Васильчук]

@VitaZheltyakov Мне всё равно, я не собираюсь навязывать вам своё мнение.
Раз вы не верите мне, почитайте хотя бы Макконнелла и Кнута.
Ну или посмотрите исходники популярных фреймворков.
Не просто так ведь ООП используют.

[Виталий Желтяков]

@Anonym Мне, если честно, Вас вразумлять не прельщает.
Только не надо называть говнокодом, то что не ООП.

[DukeRaul]

@Anonym извиняюсь, что отвлекаю :), Вы не могли бы чуть ниже глянуть на код.

[Николай Васильчук]

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

Answer 6

[DukeRaul]

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

<?php
class DB {
    protected static $_instance = null;
    public $_pdo = null;

    private function __construct() {
    try {
        $this -> _pdo = new PDO(
                'mysql:host=localhost;dbname=xxx', 'root', 'xxx');
        $this -> _pdo -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this -> _pdo -> query("SET NAMES utf8");
        $this -> _pdo -> query("SET CHARACTER SET utf8");
        } 
    catch (PDOException $e) {
        print "Error!: " . $e->getMessage() . "<br/>";
        die();
        }
    }

    public static function getInstance() {
    if (self::$_instance === null) {
        self::$_instance = new self;
        } 
    return self::$_instance;
    }

    private function __clone() {
    }

    private function __wakeup() {
    }     
}
?>

Обращение к инстансу:

$order_ticket_query = "CREATE TABLE IF NOT EXISTS `:table_name` (
                    `ID` INT AUTO_INCREMENT NOT NULL,
                    `oID` varchar(10),
                    `week` INT,
                    `name` varchar(70),
                    `expired` DATETIME,
                    `created` DATETIME,
                    `use` BOOL,
                    PRIMARY KEY (`ID`)
                    ) CHARACTER SET utf8 COLLATE utf8_general_ci;";
                           
        $stmt = DB::getInstance() -> _pdo -> prepare($order_ticket_query);
        $stmt -> execute(array(':table_name' => 'order_ticket'));

Comments

[Николай Васильчук]

Можно отнаследоваться от PDO и избавиться от public $_pdo

[Николай Васильчук]

А в целом хорошо. Суть вы уловили - это главное

[DukeRaul]

@Anonym спасибо, но тогда придется в новом классе дублировать методы PDO? В моем примере как минимум execute и prepare или я неверно Вас понял?

[Николай Васильчук]

Зачем их дублировать? В дочернем классе и так будут доступны методы родителя.

[DukeRaul]

@Anonym если не затруднит, можете пример? Я довольно долго пытался уйти от $_pdo

[Николай Васильчук]

Позднее напишу. Сейчас с телефона.

[Николай Васильчук]

Нашел в старом проекте пример для sqlite, но смысл примерно один:

/**
 * Provide functionality for use PDO with one connection
 */
class DB extends PDO {
  /**
   * @var PDO Link to connection
   */
  protected static $_instance;

  /**
   * Creates a PDO instance representing a connection to a database
   * @link http://php.net/manual/en/pdo.construct.php
   * @param $dsn
   * @param $username [optional]
   * @param $password [optional]
   * @param $options [optional]
   */
  public function __construct($dsn, $username = NULL, $password = NULL, $options = NULL) {
    parent::__construct($dsn, $username, $password, $options);
  }

  /**
   * @static Return PDO connection instance
   * @return PDO Link to connection
   * @throws Exception
   */
  public static function getInstance() {
    if (is_null(self::$_instance)) {
      $filepath = dirname(__FILE__) . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'db' . DIRECTORY_SEPARATOR . 'database.sqlite';
      self::$_instance = new self('sqlite:' . $filepath);
      self::$_instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      if (is_null(self::$_instance)) {
        throw new Exception('Could not connect to database');
      }
    }
    return self::$_instance;
  }
}

[Николай Васильчук]

И пример использования (всё как в PDO):

$db = DB::getInstance();
$stmt = $db->prepare('SELECT * FROM table WHERE id = :id');
$res = $stmt->execute(array(':id' => $id));
$data = $stmt->fetch(PDO::FETCH_ASSOC);

[DukeRaul]

@Anonym спасибо за пример.

p.s. гммм..public function __construct в синглтоне?

[Николай Васильчук]

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

[DukeRaul]

@Anonym понял :) ну пока при своем останусь

[FanatPHP]

самое интересное, что приведенный пример кода не будет работать. подробнее см. по ссылке в моём ответе

[Николай Васильчук]

@FanatPHP Вы про код @DukeRaul или про мой?