Programación en PHP

TEMA 2
PHP - PDO

Volvamos hablar de PHP la programación, ahora hablado de PHP y

de Bases de Datos es decir PDO.
PDO significa PHP Data Objects, Objetos de Datos de PHP, es
una extensión para acceder a bases de datos. PDO permite acceder a
diferentes sistemas de bases de datos con un controlador específico
(MySQL, SQLite, Oracle...) mediante el cual se conecta.
Independientemente del sistema utilizado, se emplearán siempre los
mismos métodos, lo que hace que cambiar de uno a otro resulte más
sencillo.
 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, además de crear instancias de la clase PDOStatement.

- PDOStatement, se encarga de manejar las sentencias SQL y

devuelve los resultados.

- La clase PDOException se utiliza para manejar los errores.

Bajo estas tres clases se fundamenta el desarrollo y procesos de

bases de datos en PHP, veamos algunos ejemplos de inserción, consulta,
actualización y eliminación de datos.

Dentro de una nueva carpeta, crearemos uno nuevo proyecto para

realizar todas las pruebas y funciones de las bases de datos llamado
“pdo”. Volvamos a la programación orientada a objetos:

Esta será la estructura, dos clases dentro del folder de “pdo”

- Conexión: contendrá una clase con toda la conexión de nuestra

base de datos.
 - Usuarios: contendrá todos los procesos a realizar sobre la base
de datos y en especial, nuestra tabla usuarios creada
anteriormente.

Clase Conexión:

Nuestra clase inicia con la declaración de los respectivos atributos

que contendrá:
 - Protected $db: Determina la variable que contendrá el objeto
de PDO para usar.
- Private $drive = “mysql”: Especifica al driver el motor de
base de datos a utilizar, en nuestro caso será mysql, aunque
puede ser: sql, postgress, etc.
- Private $host = “localhost”: Especifica el lugar donde se
ejecutará la conexión, lo mismo ocurre con el lugar donde
ejecutamos PHP:

- Private $dbname = “notas”: Especifica el nombre (EXACTO)

de nuestra base de datos (previamente creada):
- Private $usuario = “root”: Especifica el usuario de conexión
de nuestra base de datos, que por defecto al instalar XAMPP es
“root”.
- Private $contrasena = “”: Especifica la contraseña de
conexión de nuestra base de datos, que por defecto al instalar
XAMPP es “”, es decir, ninguna.

Estos son todos los atributos establecidos para generar una

exitosa conexión por medio de MySQL, el siguiente paso/pieza de
código será nuestro constructor:
- Primero que todo, qué es “try {} catch () {}”, estas líneas de
código señalan un bloque de instrucciones a intentar (try), y
especifica una respuesta si se produce una excepción (catch).
Es decir, en nuestro caso try catch, será el contener que se
encargará de realizar los procesos en caso de que todo el
código se encuentre bien o arrojará un error (Exception) en
caso de que no lo sea.

- $db = new PDO(….): Crea un instancia de la clase PDO, que en

su constructor recibe todos los datos para realizar una
conexión:

a. $dns: El Nombre del Origen de Datos (DSN), contiene la

información requerida para conectarse a la base de datos. En
nuestro caso la información contenida entre llaves “{}” y a su
vez contiene: Drive – Host – Nombre de la base de datos.

b. $usuario.

c. $contrasena.
 En caso de que nuestra instancia ($db) y los parámetros que
recibe sean los correos y todo esté bien, devolverá un objeto
exitosamente y si no, se lanzará una exception.

- $db->setAttribute(…): PDO maneja los errores en forma de

excepciones, por lo que la conexión siempre ha de ir encerrada
en un bloque try/catch. Se puede (y se debe) especificar el
modo de error estableciendo el atributo error mode:
a. PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION.

No importa el modo de error, si existe un fallo en la conexión

siempre producirá una excepción, por eso siempre se conecta
con try/catch.

- Finalmente, en caso de que todo esté bien. Simplemente se

retornará el objeto: return $db.

- catch (PDOException $e): Se encarga de crear la exceptión y

detener todo el proceso.

Este es todo el código que se ocupa para realizar una conexión en

PHP, para realizar uso de esta, es necesario utilizar herencia, volvamos
a la programación orientada a objetos y sus buenas prácticas.

Ahora implementemos la clase Usuarios para realizar una prueba

de la conexión, para conocer un resultado exitoso o erróneo.
 La clase Usuarios simplemente realiza una herencia de la Conexión
y el constructor de la clase hijo, Usuario realiza un llamado al
constructor de la clase Padre, Conexión. Este resultado, que en realidad
recordando a lección anterior, retorna un objeto de la clase PDO, será
almacenada en la variable $db para hacer uso de la misma. Es decir, por
medio de la herencia haremos uso del atributo db que la clase conexión
nos retorna en caso de obtener una conexión exitosa.

Al igual que en la programación orientada a objetos, para realizar

una operación sobre las clases, ocupamos un nuevo archivo para
realizar los llamados a la misma, en este caso lo llamaremos:
“ProcesosUsuario.php” y contendrá simplemente creará un objeto.

Para esta prueba, realicemos el siguiente cambio en la clase

Conexión y en su constructor:
 Un simple echo “Conectado.”.

El ir al navegador al archivo “ProcesosUsuario.php”:

http://localhost//pdo/ProcesosUsuario.php

Estaremos conectados exitosamente en nuestro base de datos.

Ahora podremos realizar operaciones sobre la base de datos. Veamos:

 Insertar

La función insertar es muy sencilla, consta de un método que

realizará uso de las clases de PDO para operar sobre las tablas de
nuestra base de datos. Sintaxis:

INSERT INTO nombre_tabla (columna1, columna2, …) VALUES (:value1, :value2,

…)

Veamos el código.
 En primera instancia, recordando la programación orientada a
objetos, los métodos deben ser muy bien declarados, en este caso,
todos deben de ser públicos, contar con la palabra reservada function y
el nombre del método (que puede ser cualquiera, siempre y cuando sea
descriptivo. Ej: add, agregar, insertar, registrar. Etc).

El método debe recibir los parámetros que se desean insertar en la

sentencia de SQL. Es decir, debemos basarnos en los descriptos en
nuestra tabla de la base de datos.

Entonces, según esto, debemos pasar un parámetro por cada

columna de la tabla. Exceptuando el ID, dado que especificamos que
fuese automático. Para nuestro caso serían entonces: $Nombre,
$Apellido, $Usuario, $Password, $Perfil, $Estado.

Teniendo nuestros parámetros, podemos proceder a realizar

nuestra instrucción para insertar los datos. Recuerda que al insertar
datos en XAMPP, se tenían 2 opciones, por código o de forma gráfica.
Por este medio realizaremos únicamente instrucciones por medio de
código.

$statement = $this->db->prepare("INSERT INTO usuarios

(NOMBRE, APELLIDO, USUARIO, PASSWORD, PERFIL, ESTADO) VALUES
(:Nombre, :Apellido, :Usuario, :Password, :Perfil, :Estado)");

$statement, será la variable que contendrá el objeto de la

sentencia de MySQL generada por el prepare. Para preparar nuestra
sentencia, debemos hacer uso del objeto que extendemos de nuestra
clase conexión ($this->db->prerpare) para poder acceder al método
prepare.

Prepare(..), Este método prepara una sentencia para su

ejecución y devuelve un objeto sentencia. El parámetro de este método
recibirá una sentencia MySQL, en este caso un INSERT.
 Nuestro INSERT se compone de las siguientes características que
lo denotan.

a. INSERT INTO: son las palabras reservadas de MySQL para

indicar que se realizará una inserción.

b. “usuarios”: especifica la base de datos sobre la cual se desea

realizar la operación determinada anteriormente.

c. (NOMBRE, APELLIDO…..): hace referencia a los campos de la

base de datos en el orden que se encuentran referenciados en nuestra
tabla previamente especificada.

d. VALUES: es una palabra reservada de MySQL que indica que se

realizará la referencia de los valores a partir de los campos de la base
de datos.

e. (:Nombre, :Apellido….): representa los parámetros recibidos por

el método que presentan cada uno de los campos de la base de datos en
orden. Es decir, en el punto (c) especificamos los campos sobre los
cuales deseamos insertar datos, y en el punto (e) referenciamos ya los
valores. Es muy importante, si referenciamos 6 campos de la tabla de
nuestra base de datos, debemos referenciar 6 parámetros. Cada uno
inicia con “:” y finaliza separando cada uno por “,”. Ej: (:Nombre,
:Apellido, :Usuario, :Password, :Perfil, :Estado).

El resultado final es este:

 Obteniendo de esta forma en el $statement, el objeto de la clase
PDOStatemet, resultado de la consulta preparada, podemos ahora,
“setear” los valores a nuestra consulta veamos.

Nuestro método recibe 6 parámetros, y nuestra sentencia

preparada cuenta con esos mismos parámetros “referenciados”, para
poder asignar los valores finalmente a nuestra sentencia, debemos
hacer uso del método bindParam.

BindParam se encarga de vincular un parámetro al nombre de

variable especificado, un ejemplo sería el parámetro de “$Nombre
“recibido por el método y la variable establecida en la sentencia
preparada “:Nombre”. El proceso se realiza de la siguiente forma:

$statement->bindParam(':Nombre',$Nombre);

Debemos hacer uso principalmente del objeto creado de la clase

PDOStatement para acceder a binParam, este método recibe:

- La variable referenciada en la sentencia preparada.

- El parámetro que contiene el valor que se asignará a la
sentencia.

Para nuestro caso el resultado para todas nuestras variables y

nuestros parámetros sería este.
 Según esto se debe crear un bindParam para cada parámetro
que deseamos enlazar con nuestra sentencia preparada.

Finalmente debemos ejecutar nuestra sentencia preparada por

medio del método execute(), este método se encarga de ejecutar
nuestra sentencia prepara y las referencias de los valores, en caso de
que todo salga bien, retornará true, sino, false.

Por esto mismo se valida por medio de una condicional que el

resultado sea exitoso o erróneo.

Ahora para realizar pruebas, al igual que en la programación

orientada a objetos, realicemos un llamado al método add de la clase
Usuarios:

Ejecutamos nuevamente : localhost//pdo/ProcesosUsuario.php

¿¿
 Actualizar

La función actualizar es muy sencilla, parecido al insertar, consta

de un método que realizará uso de las clases de PDO para operar sobre
las tablas de nuestra base de datos. Sintaxis:

UPDATE nombre_tabla SET columna1 = :value1, columna2 =

:value2 WHERE columna_condicion = :value_condicion

Veamos el código.

El código opera de la misma forma, lo único que cambia en este

método es la sentencia preparada, para el insert hacíamos uso de la
palabra reservada INSERT ahora haremos uso de UPDATE.

Omitiré la explicación de algunos conceptos y entraré en lo nuevo

de este método.

La principal condición de los UPDATEs es que se realiza sobre

registros ya insertados y que se encuentran en la base de datos. Cuando
operamos con UPDATEs, hay una característica que se debe tener muy
presente y es la palabra reservada WHERE.
 WHERE es una cláusula de condición que permite para las
sentencias UPDATEs determinar qué voy actualizar y qué no voy
actualizar. Por ejemplo:

Si en la tabla usuarios quisiera cambiar el ESTADO de uno de los

registros, debo agregar la cláusula WHERE y realizando la condición:
Ej:

En el siguiente registro tenemos la información de toda una

persona y tenemos un dato muy importante que asigna especialmente la
misma tabla, y este es el ID.

Si sobre este registro quisiéramos actualizar el ESTADO del

registro a Inactivo. Simplemente deberé agregar la siguiente condicional
con el WHERE.

…… WHERE ID_USUARIO = 1

Con este simple bloque de código, determinamos que solo

actualizaremos el registro que tenga un ID = 1, sino agregásemos una
condicional, la sentencia afectaría toda la tabla.

Según lo anterior, 6 parámetros no será suficientes para realizar

una actualización correcta de datos; ahora deberemos adjuntar el $Id
del usuario:

$Id, $Nombre, $Apellido, $Usuario, $Password, $Perfil, $Estado

El ID será nuestro elemento clave para realizar condicionales a la

hora de actualizar.
 Por otra parte, encontramos la palabra reservada SET, se indica en
la sentencia las columnas que será afectas o los valores que tendrán las
mismas en el siguiente orden a partir de la sintaxis:

COLUMNA1 = :Valor1, COLUMNA2 = :Valor2

Las columnas en igual medida que en los insertar, al igual que los
valores, el orden y la consistencia se deben mantener: NOMBRE con
:Nombre, APELLIDO con :Apellido. En la sentencia se puede especificar
únicamente que datos quiero actualizar; si sólo desease actualizar
NOMBRE y APELLIDO, lo más acertado será únicamente agregar estos
dos, pero para efectos prácticos de este ejercicio lo haremos todos. El
resultado final de nuestra sentencia será:

Una forma amigable de leer esta sentencia sería la siguiente: De

la tabla usuarios, actualizar los siguientes campos, NOMBRE será igual a
:Nombre, APELLIDO será igual a :Apellido, USUARIO será igual a
:Usuario, PASSWORD será igual a :Password, PERFIL será igual a :Perfil
y ESTADO será igual a :Estado, siempre y cuando se cumpla la
condición de que el ID_USUARIO sea igual a :Id.

Finalmente realizamos la asignación de valores por medio de

bindParam, adicionalmente es importante resaltar que el orden no
importa, simplemente se debe cumplir con asignar correctamente los
valores de los parámetros a las variables de la sentencia preparada.
 Y ejecutamos nuestra sentencia preparada por medio de execute()
contenida de nueva dentro de la condicional:

En este momento en nuestra tabla usuarios contamos con la

siguiente información registrada:

Hasta el momento debemos contar mínimamente con este

registro, realicemos un UPDATE sobre este, cambiemos la siguiente
información:
- El perfil pasará de ser Administrar a Docente.
- Agregaremos un Segundo Nombre (Diego Alejandro) y Segundo
Apellido (Palacio Valencia).
- La nueva contraseña ahora será abc9292.
Los demás datos se deberán conservar tal como están:
localhost//pdo/ProcesosUsuario.php

El proceso funcionó correctamente.

Nota: no solamente puedes realizar condicionales con la cláusula

WHERE y los IDs, puedes utilizar cualquier dato, fechas, nombres,
edad, etc. Solo que, por convención, en la mayoría de los casos se usan
los IDs.
 Listar - Get
La función listar es muy sencilla, esta permite consultar datos de
una o varias tablas. Consta de un método que realizará uso de las clases
de PDO para operar sobre las tablas de nuestra base de datos. Sintaxis:

SELECT * FROM nombre_tabla

SELECT columna1, columna2… FROM nombre_tabla

Las dos sintaxis son completamente válidas, la primera que usa el

(*) indica que traerá toda la información de los campos. La segunda,
por otra parte, indica qué campos quiero traer separados por “,”.
Veamos el código:
Sintaxis 1:

El código es muy corto y sencillo, la forma de operar es la

siguiente:

El método no recibe parámetros, únicamente se recibe, en caso de

que se desee implementar una clausula WHERE personalizada. Más
adelante veremos esto.
 La forma en que retornaremos los datos de nuestra tabla será por
medio de una array, este lo declaramos de la siguiente forma:
$rows = null; vacío, dado que al final realizaremos la inserción de
los datos en el mismo.

Nuestra sentencia preparada contiene una nueva palabra

reservada SELECT: Select indica a la sentencia preparada que se
realizará una selección de datos.

Al no recibir parámetros, no hace falta realizar referencia de

valores por medio de bindParam, así que directamente se realiza la
ejecución de la sentencia por medio de execute().

En las anteriores funciones, realizábamos el execute() y ahí

finalizaba el proceso, dado que no ocupábamos realizar retornos de
información, pero cuando trabajamos con sentencias de selección y
consulta, es muy importante el retorno y para esto creamos el arreglo
$rows (filas).

Dentro de los métodos que utilizamos en PDO hay uno muy

especial y útil para trabajar con SELECTs y es el fetch().
Fetch() permite recorrer sentencias de selección fila por fila hasta
finalizar el recorrido. Pero este es un proceso repetitivo, o sea, un ciclo;
recordemos que estructura se acomoda más a lo que necesitamos, ¿Ya
lo tienes?, los ciclos while, ¿cierto?
 Los ciclos while recorrerán el resultado de fetch() hasta que no
encuentre más iteraciones por realizar y esos resultados irán siendo
guardados en nuestro arreglo de la siguiente forma:

Result contendrá el resultado de UNA fila a la vez, recuerda que el

ciclo while evalúa una condición y si es verdadera realiza el proceso
interno. Al encontrar datos, while permitirá almacenar los mismos
dentro del arreglo, para finalmente, al momento de no encontrar más,
retornar el mismo.

http://localhost/pdo/ProcesosUsuario.php
 El proceso de impresión es bastante simple, es similar al visto en
módulo pasado con relación a los arreglos, simplemente realizaremos la
impresión por medio de un foreach y dando haciendo referencia a cada
una de nuestras columnas de nuestra tabla.

Sintaxis 2:

En la sintaxis 2, especificamos los campos que deseamos obtener

por medio del SELECT, pueden ser todos, 3, 2 o 1, todo depende de la
necesidad. El resto del proceso es el mismo, mostremos en este caso:
NOMBRE y APELLIDO.
 Eliminar
La función eliminar, permite eliminar los datos de una tabla.
Consta de un método que realizará uso de las clases de PDO para operar
sobre las tablas de nuestra base de datos. Sintaxis:

DELETE FROM nombre_tabla WHERE columna_condicion =

:value_condicion
Veamos el código:

Llegados a este punto, es fácil entender el funcionamiento de la

sentencia, la palabra reservada DELETE indica a la sentencia que se
realizará una eliminación de información, simplemente se debe
especificar el nombre de la tabla y la condicional para la eliminación.
Veamos a ver: