¿Cómo analizo datos de objetos de la base de datos MySQL usando PHP PDO?

Me he encontrado con un problema al intentar devolver datos de objetos de mi base de datos. Seguí a this tutorial para construir un contenedor de base de datos y he estado tratando de extender la funcionalidad para satisfacer mis necesidades. Mi problema es que cuando uso el método “get” de la clase DB para devolver datos, también devuelve una instancia del objeto PDO. Me pregunto cómo analizar estos datos para que solo devuelva objetos de la base de datos, y no el objeto de la base de datos en sí. Quiero poder mostrar diferentes valores de la base de datos para cada objeto eventualmente.

Aquí está todo mi código relevante:

class DB {

private static $_instance = null; //stores instance of database
private $_pdo, 
        $_query, 
        $_error = false, 
        $_results, 
        $_count = 0;


private function __construct() {
    try {
        $this->_pdo = new PDO('mysql:host=' . Config::get('mysql/host') . ';dbname=' . Config::get('mysql/db'), Config::get('mysql/username'),  Config::get('mysql/password'));
    } catch(PDOException $e){
        die($e->getMessage());
    }
}


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

public function query($sql, $params = array()){
    $this->_error = false;
    if($this->_query = $this->_pdo->prepare($sql)) {
        $x = 1;
        if(count($params)) {
            foreach($params as $param) {
                $this->_query->bindValue($x, $param);
                $x++;
            }
        }
        if($this->_query->execute()) {
            $this->_results = $this->_query->fetchAll(PDO::FETCH_OBJ);
            $this->_count = $this->_query->rowCount();
        } else {
            $this->_error = true;
        }
    }
    return $this; 
}


public function action($action, $table, $where = array()) {
    if(count($where) === 3) {
        $operators = array('=', '>', '<', '>=', '<=');

        $field = $where[0];
        $operator = $where[1];
        $value = $where[2];

        if(in_array($operator, $operators)) {
            $sql = "{$action} FROM {$table} WHERE {$field} {$operator} ?";
            if(!$this->query($sql, array($value))->error()) {
                return $this;
            }
        }

    } return $this;

}

public function get($table, $where) {
    return $this->action('SELECT *', $table, $where);

}
}

class Schedule {

private $_db;
protected $_games = array();

public function __construct() {

    $this->_db = DB::getInstance();

}

public function listGames() {

    $data = $this->_db->get('games', array('id', '>', 0));
    var_dump($data);

    echo '<br>';

}
}
Mejor respuesta
El problema con estos tutoriales en video es que sus autores no tienen idea sobre el tema, lo que hace que el resultado sea MUCHO MÁS PEOR que si no estuvieras usando su excremento mental. El daño que están causando es tan grave que incluso tuve que escribir un artículo dedicado que explica por qué todos estos “envoltorios” indefensos son totalmente inutilizables para cualquier aplicación de la vida real, Your first database wrapper’s childhood diseases.

Tome este contenedor del video, por ejemplo:

> El informe de errores es completamente defectuoso
> Una función inútil para SELECT.
> Statefulness
> Instancia de PDO protegida

Entonces, en esencia, no podrás obtener de este “envoltorio” ni siquiera una cosa tan tonta como Insertar Id. Y ningún informe de errores podría ayudarlo incluso a darse cuenta del problema.

A partir de su código, simplemente no negocie por ahorrarse escribiendo una palabra clave SQL. Es tonto SQL es una cosa preciosa, no lo descarte a favor de algunos atajos galimatías. Tampoco debe disminuir la PDO a un estado de inválido inválido, descartando sus características más brillantes.

Su contenedor debe hacer que todas las características de PDO y SQL sean accesibles en lugar de descartarlas. Así que va:

class DB
{
    protected static $instance;
    protected $pdo;

    protected function __construct() {
            $opt  = array(
                PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
                PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_OBJ,
                PDO::ATTR_EMULATE_PREPARES   => FALSE,
            );
            $dsn = 'mysql:host='.DB_HOST.';dbname='.DB_NAME.';charset='.DB_CHAR;
            $this->pdo = new PDO($dsn, DB_USER, DB_PASS, $opt);

    }

    // a classical static method to make it universally available
    public static function instance()
    {
        if (self::$instance === null)
        {
            self::$instance = new self;
        }
        return self::$instance;
    }

    // a proxy to native PDO methods
    public function __call($method, $args)
    {
        return call_user_func_array(array($this->pdo, $method), $args);
    }

    // a helper function to run prepared statements smoothly
    public function run($sql, $args = [])
    {
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute($args);
        return $stmt;
    }
}

Esta envoltura es diez veces más simple y al mismo tiempo diez veces más potente que la del video.

Y ahora tu clase

class Schedule
{
    private $_db;

    public function __construct()
    {
        $this->_db = DB::instance();
    }

    public function listGames()
    {
        $data = $this->_db->query('SELECT * FROM games')->fetchAll();
        var_dump($data);
        echo '<br>';
    }
}

El secreto aquí es que PDO ya puede darle datos de objetos, sin una sola línea adicional de codificación.

Aunque este simple ejemplo no es muy impresionante, el secreto aquí es que este contenedor también le servirá para cualquier otro ejemplo, cuando se ahogue el del video. Intenta pensar en otro ejemplo y te mostraré lo simple pero poderoso que es este contenedor.

Por favor indique la dirección original:¿Cómo analizo datos de objetos de la base de datos MySQL usando PHP PDO? - Código de registro