Edi 2 PHP - Mysql - Pdo
Cargado por
Paula QuirogaEdi 2 PHP - Mysql - Pdo
Cargado por
Paula QuirogaEDI 2
PHP-MYSQL
Hablaremos sobre la forma de trabajar con datos de una Base de Datos
de MySql desde PHP
El primer paso es tener creada la Base de Datos con las tablas que se desean acceder desde
PHP.
Para esto creamos la Base de Datos “colores_php”
Luego creamos una tabla llamada colores con los campos: id(clave), color y descripción.
Insertamos algunos datos:
(1,"Primario","Color azul");
(2,"Danger","Rojo");
Ya tenemos creadas las Base de Datos y la tabla que necesitamos para conectarnos desde
PHP
Conexión desde PHP:
Se puede obtener el modo de conexión desde la página de PHP donde se observan varias
alternativas.
El link es: https://www.php.net/manual/es/pdo.connections.php
Conexión desde PHP:
Vamos a utilizar el modo de conexión con manejo de errores:
<?php
try {
$mbd = new PDO('mysql:host=localhost;dbname=prueba', $usuario, $contraseña);
foreach($mbd->query('SELECT * from FOO') as $fila) {
print_r($fila);
}
$mbd = null;
} catch (PDOException $e) {
print "¡Error!: " . $e->getMessage() . "<br/>";
die();
}
?>
Conexión desde PHP:
Creamos una carpeta para trabajar:
C:\xampp\htdocs\phpApp\MySql\ con el nombre conexión.php y lo abrimos desde Visual
Studio Code
Conexión desde PHP:
PDO:
PDO significa PHP Data Objects, Objetos de Datos de PHP, 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.
Conexión desde PHP:
PDO:
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.
Conectar a una base de datos con PDO
El primer argumento de la clase PDO es el DSN, Data Source Name, en el cual se han de
especificar el tipo de base de datos (mysql), el host (localhost) y el nombre de la base de
datos (se puede especificar también el puerto). Diferentes sistemas de bases de datos
tienen distintos métodos para conectarse. La mayoría se conectan de forma parecida a
como se conecta a MySQL
$link='mysql:host=localhost;dbname=colores_php'; Para cerrar una conexión:
$usuario='root'; $pdo= null;
$pass='';
$pdo = new PDO($link, $usuario,$pass);
Conexión desde PHP:
La clase PDOStatement es la que trata las sentencias SQL. Una instancia de PDOStatement
se crea cuando se llama a PDO->prepare(), y con ese objeto creado se llama a métodos
como bindParam() para pasar valores o execute() para ejecutar sentencias.
PDO facilita el uso de sentencias preparadas en PHP, que mejoran el rendimiento y la
seguridad de la aplicación.
Cuando se obtienen, insertan o actualizan datos, el esquema es:
PREPARE -> [BIND] -> EXECUTE.
Se pueden indicar los parámetros en la sentencia con un interrogante "?" o mediante un
nombre específico.
También existe un método lazy, que es pasando los valores mediante un array (siempre
array, aunque sólo haya un valor) al método execute()
Es el método execute() el que realmente envía los datos a la base de datos. Si no se llama a
execute no se obtendrán los resultados sino un error.
Conexión desde PHP:
PDOStatement: Utilizando interrogantes para los
valores
// Prepare
$stmt = $dbh->prepare("INSERT INTO Clientes (nombre,
ciudad) VALUES (?, ?)");
// Bind
// Bind $nombre = "Martha";
$nombre = "Peter"; $ciudad = "Cáceres";
$ciudad = "Madrid"; $stmt->bindParam(1, $nombre);
$stmt->bindParam(1, $nombre); $stmt->bindParam(2, $ciudad);
$stmt->bindParam(2, $ciudad);
// Execute
// Excecute $stmt->execute();
$stmt->execute();
Conexión desde PHP:
PDOStatement: Utilizando variables para los valores
// Prepare
$stmt = $dbh->prepare("INSERT INTO Clientes (nombre,
ciudad) VALUES (:nombre, :ciudad)");
// Bind
// Bind
$nombre = "Anne";
$nombre = "Charles";
$ciudad = "Lugo";
$ciudad = "Valladolid";
$stmt->bindParam(':nombre',
$stmt->bindParam(':nombre', $nombre); $nombre);
$stmt->bindParam(':ciudad', $ciudad); $stmt->bindParam(':ciudad',
$ciudad);
// Excecute // Execute
$stmt->execute(); $stmt->execute();
Conexión desde PHP:
PDOStatement: Utilizando array para los valores
// Prepare:
$stmt = $dbh->prepare("INSERT INTO Clientes (nombre, ciudad) VALUES (:nombre, :ciudad)");
$nombre = "Luis";
$ciudad = "Barcelona";
// Bind y execute:
if($stmt->execute(array(':nombre'=>$nombre, ':ciudad'=>$ciudad))) {
echo "Se ha creado el nuevo registro!";
}
Conexión desde PHP:
PDOStatement: Diferencia entre bindParam() y bindValue()
Con bindParam() la variable es enlazada como una referencia y sólo será evaluada cuando se llame a
execute():
// Prepare:
$stmt = $dbh->prepare("INSERT INTO Clientes (nombre) VALUES (:nombre)");
$nombre = "Morgan";
// Bind
$stmt->bindParam(':nombre', $nombre); // Se enlaza a la variable $nombre
// Si ahora cambiamos el valor de $nombre:
$nombre = "John";
$stmt->execute(); // Se insertará el cliente con el nombre John
Conexión desde PHP:
PDOStatement: Diferencia entre bindParam() y bindValue()
Con bindValue() se enlaza el valor de la variable y permanece hasta execute():
// Prepare:
$stmt = $dbh->prepare("INSERT INTO Clientes (nombre) VALUES (:nombre)");
$nombre = "Morgan";
// Bind
$stmt->bindValue(':nombre', $nombre); // Se enlaza al valor Morgan
// Si ahora cambiamos el valor de $nombre:
$nombre = "John";
$stmt->execute(); // Se insertará el cliente con el nombre Morgan
En la práctica bindValue() se suele usar cuando se tienen que insertar datos sólo una vez, y bindParam()
cuando se tienen que pasar datos múltiples (desde un array por ejemplo).
Conexión desde PHP:
PDOStatement: Consultar datos con PDO
La consulta de datos se realiza mediante PDOStatement::fetch, que obtiene la siguiente fila de un conjunto de
resultados. Antes de llamar a fetch (o durante) hay que especificar como se quieren devolver los datos:
Entre otros podemos encontrar:
PDO::FETCH_ASSOC: devuelve un array indexado cuyos keys son el nombre de las columnas.
PDO::FETCH_BOUND: asigna los valores de las columnas a las variables establecidas con el método
PDOStatement::bindColumn.
PDOStatement::bindColumn() se encarga de tener una variable en particular vinculada a una columna
dada en el conjunto de resultados desde una consulta. Cada llamada a PDOStatement::fetch() o a
PDOStatement::fetchAll() actualizará todas las variables que estén vinculadas a columnas. Devuelve
TRUE en caso de éxito o FALSE en caso de error.
PDOStatement::fetchAll(), que devuelve un array con todas las filas devueltas por la base de datos con las que
poder iterar. También acepta estilos de devolución.
Conexión desde PHP:
PDOStatement: Consultar datos con PDO
PDO::FETCH_ASSOC: devuelve un array indexado cuyos keys son el nombre de las columnas.
$stmt = $dbh->prepare("SELECT * FROM Clientes");
// Especificamos el fetch mode antes de llamar a fetch()
$stmt->setFetchMode(PDO::FETCH_ASSOC);
// Ejecutamos
$stmt->execute();
// Mostramos los resultados
while ($row = $stmt->fetch()){
echo "Nombre: {$row["nombre"]} <br>";
echo "Ciudad: {$row["ciudad"]} <br><br>";
}
Conexión desde PHP:
PDOStatement: Consultar datos con PDO
PDO::FETCH_BOUND: asigna los valores de las columnas a las variables establecidas con el método
PDOStatement::bindColumn.
// Preparamos
$stmt = $dbh->prepare("SELECT nombre, ciudad FROM Clientes");
// Ejecutamos
$stmt->execute();
// bindColumn
/* Vincular por número de columna */
$stmt->bindColumn(1, $nombre);
/* Vincular por nombre de columna */
$stmt->bindColumn('ciudad', $ciudad);
while ($row = $stmt->fetch(PDO::FETCH_BOUND)) {
$cliente = $nombre . ": " . $ciudad;
echo $cliente . "<br>";
}
Conexión desde PHP:
PDOStatement: Consultar datos con PDO
PDOStatement::fetchAll():
// fetchAll() con PDO::FETCH_ASSOC
$stmt = $dbh->prepare("SELECT * FROM Clientes");
$stmt->execute();
$clientes = $stmt->fetchAll(PDO::FETCH_ASSOC);
foreach($clientes as $cliente){
echo $cliente['nombre'] . "<br>";
}
Conexión desde PHP:
PDOStatement: Diferencia entre query() y prepare()/execute()
El método query() ejecuta la sentencia directamente y necesita que se escapen los datos
adecuadamente para evitar ataques SQL Injection y otros problemas.
execute() ejecuta una sentencia preparada lo que permite enlazar parámetros y evitar tener que
escapar los parámetros. execute() también tiene mejor rendimiento si se repite una sentencia
múltiples veces, ya que se compila en el servidor de bases de datos sólo una vez.
$stmt = $dbh->query("SELECT * FROM Clientes");
$clientes = $stmt->fetchAll(PDO::FETCH_OBJ);
foreach ($clientes as $cliente){
echo $cliente->nombre . "<br>";
}
Se cambia prepare por query y se quita el execute.
Conexión desde PHP:
PDOStatement: Otras funciones de utilidad
PDO::exec(). Ejecuta una sentencia SQL y devuelve el número de filas afectadas. Devuelve el número
de filas modificadas o borradas, no devuelve resultados de una secuencia SELECT:
// Si lo siguiente devuelve 1, es que se ha eliminado correctamente:
echo $dbh->exec("DELETE FROM Clientes WHERE nombre='Luis'");
// No devuelve el número de filas con SELECT, devuelve 0
echo $dbh->exec("SELECT * FROM Clientes");
Conexión desde PHP:
PDOStatement: Otras funciones de utilidad
PDO::lastInsertId(). Este método devuelve el id autoincrementado del último registro en esa
conexión:
$stmt = $dbh->prepare("INSERT INTO Clientes (nombre) VALUES (:nombre)");
$nombre = "Angelina";
$stmt->bindValue(':nombre', $nombre);
$stmt->execute();
echo $dbh->lastInsertId();
Conexión desde PHP:
PDOStatement: Otras funciones de utilidad
PDOStatement::fetchColumn(). Devuelve una única columna de un conjunto de resultados. La
columna se indica con un integer, empezando desde cero. Si no se proporciona valor, obtiene la
primera columna.
$stmt = $dbh->prepare("SELECT * FROM Clientes");
$stmt->execute();
while ($row = $stmt->fetchColumn(1)){
echo "Ciudad: $row <br>";
}
Conexión desde PHP:
PDOStatement: Otras funciones de utilidad
PDOStatement::rowCount(). Devuelve el número de filas afectadas por la última sentencia SQL:
$stmt = $dbh->prepare("SELECT * FROM Clientes");
$stmt->execute();
echo $stmt->rowCount();
Conexión desde PHP:
PDOStatement: Transacciones con PDO
Una transacción en PDO comienza con el método PDO::beginTransaction(). Este método desactiva
cualquier otro commit o sentencia SQL o consultas que aún no son commited hasta que la transacción es
committed con PDO::commit(). Cuando este método es llamado, todas las acciones que estuvieran
pendientes se activan y la conexión a la base de datos vuelve de nuevo a su estado por defecto que es
auto-commit. Con PDO::rollback() se revierten los cambios realizados durante la transacción.
try {
$dbh->beginTransaction();
$dbh->query("INSERT INTO Clientes (nombre, ciudad) VALUES ('Leila Birdsall', 'Madrid')");
$dbh->query("INSERT INTO Clientes (nombre, ciudad) VALUES ('Brice Osterberg', 'Teruel')");
$dbh->query("INSERT INTO Clientes (nombre, ciudad) VALUES ('Latrisha Wagar', 'Valencia')");
$dbh->commit();
echo "Se han introducido los nuevos clientes";
} catch (Exception $e){
echo "Ha habido algún error";
$dbh->rollback();
}
