notifications Notificaciones

Marcar todas como leídas

Ver más

lightbulb_outline

Crear, Modificar, eliminar y Consultar (CRUD) con PDO en PHP7

timer 5 Min.

remove_red_eye 4008

calendar_today 29/10/19

Conexión

PDO es una capa de acceso a la base de datos que proporciona una interfaz rápida y consistente para acceder y administrar bases de datos en aplicaciones PHP. Todos los DBMS tienen controladores PDO específicos que se deben instalar cuando se usa PDO en aplicaciones PHP.

Bases de datos compatibles

Nombre del conductor Base de datos soportada

PDO_CUBRID => Cubrid

PDO_DBLIB => FreeTDS / Microsoft SQL Server / Sybase

PDO_FIREBIRD => Firebird

PDO_IBM => IBM DB2

PDO_INFORMIX => Servidor dinámico de IBM Informix

PDO_MYSQL => MySQL 3.x / 4.x / 5.x

PDO_OCI => Interfaz de llamada de Oracle

PDO_ODBC => ODBC v3 (IBM DB2, unixODBC y win32 ODBC)

PDO_PGSQL => PostgreSQL

PDO_SQLITE => SQLite 3 y SQLite 2

PDO_SQLSRV => Microsoft SQL Server / SQL Azure

PDO_4D => 4D

Por defecto, PHP tiene instalado el controlador PDO_SQLite. Sin embargo, si deseamos trabajar con otras bases de datos, primero debe instalar el controlador correspondiente.En php.init windows extension=php_pdo.dll sistemas unix extension=pdo.so

Para ver los controladores (drivers) disponibles en nuestro servidor, usamos el método getAvailableDrivers(): Ejemplo

print_r(PDO::getAvailableDrivers()); 

El sistema PDO se fundamenta en 3 clases: PDO, PDOStatement y PDOException. La clase PDO se encarga de mantener la conexión a la base de datos y otro tipo de conexiones específicas como transacciones, además de crear instancias de la clase PDOStatement. PDOStatement, la que maneja las sentencias SQL y devuelve los resultados. La clase PDOException se utiliza para manejar los errores. Primero vamos a conectarnos con la base de datos hay que crear una instancia de la clase PDO, que se utiliza en todas las consultas posteriores. Ahora nos vamos a nuestro proyecto y crearemos una clase para poder hacer nuestra conexión a mysql.

Primero vamos a crear un archivo llamado conexion.php en este archivos vamos a conectarnos con el sistema gestor de base de datos que en este caso es mysql, para podernos conectar a mysql necesitamos sus características, en este caso: Driver: que es el nombre del sistema gestor de base de datos. host: en este caso el host es localhost, pero cuando ustedes lo monten en un servidor deberán colocarle la ip de su servidor. usuario: Mi caso uso el username por default que es root ustedes si tienen un usuario específico lo colocan al igual que pass. Sino tengo una contraseña dejamos vacío el campo. dbName: El nombre de nuestra base de datos, recuerden que sunnyside. charset: UTF-8 puede representar cualquier carácter en el estándar Unicode.

<?php
class Connection{
  private $driver="mysql";
  private $host ="localhost";
  private $user="root";
  private $pass='';
  private $dbName="colegio";
  private $charset="utf8";
?>

Ahora vamos a crear una instancia de PDO, para poder hacer la instancia necesitamos colocar las características que creamos, después establecemos atributos para el manejador de la base de datos, esto lo haremos con el método, setAttribute, usaremos los atributos genéricos ATTR_ERRMODE que nos reportará errores y ERRMODE_EXCEPTION para que nos lance excepciones, las excepciones las cacharemos en PDOException para saber el error que está pasando. Al final retornamos el método setAttribute nos Devuelve TRUE en caso de éxito o FALSE en caso de error.

<?php
class Connection{
  private $driver="mysql";
  private $host ="localhost";
  private $user="root";
  private $pass='';
  private $dbName="colegio";
  private $charset="utf8";

protected function conexion(){
try{      
$pdo=newPDO("{$this->driver}:host={$this->host};dbname={$this->dbName};charset={$this->charset}", $this->user, $this->pass);
      $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      return $pdo;
  catch (PDOException $e)
        {
            die($e->getMessage());
        }
    }
  }
?>

Crear, Modificar, eliminar y Consultar (CRUD)

El acrónimo CRUD se refiere a todas las principales funciones que se implementan en las aplicaciones de bases de datos. Cada letra en el acrónimo se puede asignar a una declaración SQL estándar:

Texto alternativo

Ya usamos PDO para crear una instancia PDOException para cachar errores ahora veremos el tercero que es PDOStatement este nos ayudará a realizaremos operaciones CRUD. Creamos nuestra clase Crud, donde nosotros vamos a heredar de Connection, creamos dos atributos nombre de la tabla y nuestra conexión PDO, ahora creamos un constructor, donde recibiremos el nombre de nuestra tabla, recuerden que nuestro método conexion es de acceso protected, por lo tanto accederemos a esta con la palabra reservada parent, y asignamos estos dos datos a nuestras variables locales para compartirlos con la clase.

<?php
require_once 'model/conexion.php';
abstract class Crud extends Conectar{
    private $table;
    public $pdo;

    public function __construct($table) {
        $this->table=(string) $table;
        $this->pdo=parent::conexion();
    }
}

Ahora vamos a obtener todos los datos que están registrados en nuestra tabla, para eso llamamos nuestra conexión y usamos la función prepare para preparar nuestra sentencias SQL, después la ejecutamos con el método execute para poder obtener los datos usaremos fetchAll nos devuelve un array que contiene todas las filas de la tabla, para poder obtener un objeto y no un arreglo lo hacemos con PDO::FETCH_OBJ , consultamos nuestra tabla y obtenemos todos los datos. try catch para obtener los errores que se regresen.

    public function getAll(){
        try
        {
            $stm = $this->pdo->prepare("SELECT * FROM $this->table");
            $stm->execute();
            return $stm->fetchAll(PDO::FETCH_OBJ);
        }
        catch (PDOException $e)
        {
            die($e->getMessage());
        }
    }

Ahora obtenemos un dato en específico de la tabla.

   public function getById($id){
        try
        {
            $stm = $this->pdo->prepare("SELECT * FROM $this->table WHERE id=$id");
            $stm->execute(array($id));
            return $stm->fetch(PDO::FETCH_OBJ);
        }
        catch (PDOException $e)
        {
            die($e->getMessage());
        }
    }

Las sentencias preparadas se utilizan para desinfectar la entrada de datos, evitando inyecciones de código SQL malicioso en la base de datos, ya que los valores de los parámetros, que son transmitidos después usando un protocolo diferente. Otra cosa importante es que las sentencias preparadas reducen en tiempo de análisis ya que la preparación de la consulta se realiza sólo una vez.

Vamos a ver un ejemplo de Sentencias Preparadas Primero en el método prepare tenemos que crear nuestra plantilla de la sentencia SQL se crea y se envía a la base de datos. Algunos valores se dejan sin especificar, estos datos serán los parámetros y estarán representados por un interrogante "?": En este caso como vamos a eliminar solo tendremos un valor que es el id, el cual buscará el registro y lo eliminará.

  public function delete($id){
        try
        {
            $stm = $this->pdo->prepare("DELETE FROM $this->table WHERE id=?");
            $stm->execute(array($id));
        }
        catch (PDOException $e)
        {
            die($e->getMessage());
        }
    }

En este caso sabemos que al insertar y actualizar nos toparemos con datos más específicos por lo cual debemos de realizar estas dos operaciones CRUD directamente en la clase, para implementarlas, vamos a crear funciones abstractas para implementarlas en las clases.

    abstract function create();
    abstract function update();

Usar CRUD

 <?php
require_once 'core/crud.php';
class Animal extends Crud
{
  private $id;
  private $name;
  private $specie;
  private $breed;
  private $gender;
  private $color;
  private $age;
  const TABLE='animal';
  private $pdo;
  public function __construct()
  {
//En el constructor enviaremos el nombre de la tabla recuerden que lo necesitamos para //poder hacer las acciones crud.
    parent::__construct(self::TABLE);
    $this->pdo=parent::conexion();
  }

  public function __set($name,$value){
    $this->$name=$value;
  }
  public function __get($name){
    return $this->$name;
  }

/*Aquí Insertamos un animal, tenemos que crear forzosamente este método porque en el CRUD lo agregamos como **abstract** sino lo agregamos obtendremos un error.*/
  public function create(){
    try{
    $stm=$this->pdo->prepare("INSERT INTO ".self::TABLE." (name, specie,    
breed, gender, color, age) VALUES (?,?,?,?,?,?)");
    $stm->execute(array($this->name,$this->specie,$this->breed,$this->gender,$this->color,$this->age));
  }catch(PDOException $e){
    echo $e->getMessage();
  }

  }

/*Aquí actualizamos un animal, tenemos que crear forzosamente este método porque en el CRUD lo agregamos como **abstract** sino lo agregamos obtendremos un error.*/

  public function update(){
    try{
    $stm=$this->pdo->prepare("UPDATE ".self::TABLE." SET name=?, specie=?,  
breed=?,gender=?,color=?,age=? WHERE id=?");
    $stm->execute(array($this->name,$this->specie,$this->breed,$this->gender,$this->color,$this->age,$this->id));
  }catch(PDOException $e){
    echo $e->getMessage();
  }
  }
}

 ?>

Otros artículos del blog

Comunidad