Plantilla:PHP/Mysqli
De WikiEducator
Revisión a fecha de 23:06 9 ene 2017; ManuelRomero (Discusión | contribuciones)
Contenido
- 1 Introducción al Uso de extensiones orientadas a objetos
- 2 Línea de comandos de Mysql
- 3 Actividad
- 4 Actividad
- 5 Actividad
- 6 Actividad
- 7 Resumen
- 8 Actividad
- 9 Actividad
- 10 Resumen
- 11 Actividad
- 12 Definición
- 13 Actividad
- 14 Recursos de la Web
- 15 Resumen
- 16 Actividad
- 17 Práctica de tienda
- 18 Práctica de tienda
- 19 Resumen
- 20 Actividad
- 21 Actividad
- 22 Actividad
Mysql y php
Mysql es un gestor de bases de datos relacional. Actualmente es un producto propietario de la empresa Oracle, y el software correspondiente libre es Maria que en estos momentos funciona exactamente igual que Mysql y con los mismos comandos. (año 2017).
Tener en cuenta la diferencia de la parte del servidor (donde realmente se guardan los datos), y la parte del cliente que es un software que nos ofrece una interfaz de comandos o gráfica y nos permite conectarnos al servidor y gestionar la bases de datos (básicamente enviar sentencias SQL y recoger los resultado).
apt-get install mysql-server mysql-clientComo todos servicio se puede arrancar o parar
service mysql start/stop/restart/status
- El fichero de configuración
/etc/mysql/my.cnf
- Mysql
- En él podemos ver el puerto (3306 por defecto), el usuario y otros parámetros del servicio
|
Línea de comandos de Mysql
Es importante saber manejar la línea de comandos con el cliente mysql. En alguna ocasión puede ser la forma más rápida de obtener información o realizar acciones sobre la base de dados. Para ello debemos de repasar algún comandos. Son pocos, pero hay que conocerlos.
- Acciones que hay que saber hacer
- Conectarse a una base de datos en un servidor
mysql -u usuario -ppassword # Si no especificas el passowr, se solicitará # Si lo especificas ha de ir sin ningún espacio entre el parámetro -p
- Mostrar las bases de datos
SHOW DATABASES;
- Usar una base de datos concreta
USE nombre_base_datos;- Mostrar la descripción de una base de datos (Las tablas que contiene)
DESCRIBE nombre_tabla;- Obtener ayuda de los comandos disponibles
help;
- Por supuesto debemos de poder ejecutar sentencias SQL
- Crear una base de datos (Sentencia SQL), y borrarla
- Crear una tabla
- Crear un usuario y darle permisos
- Modificar y borrar una tabla
- Insertar, modificar y borrar registros o tuplas
- Realizar consultas select
connect -h,-u, -p use database exit o quit help Para conocer los comandos que se pueden usar. http://ftp.nchu.edu.tw/MySQL/doc/refman/5.0/es/sql-syntax.html
|
- Bases de datos
-- Creamos la base de datos CREATE DATABASE `dwes` DEFAULT CHARACTER SET utf8 COLLATE utf8_spanish_ci; USE `dwes`; -- Creamos las tablas CREATE TABLE `dwes`.`tienda` ( `cod` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `nombre` VARCHAR( 100 ) NOT NULL , `tlf` VARCHAR( 13 ) NULL ) ENGINE = INNODB; CREATE TABLE `dwes`.`producto` ( `cod` VARCHAR( 12 ) NOT NULL , `nombre` VARCHAR( 200 ) NULL , `nombre_corto` VARCHAR( 50 ) NOT NULL , `descripcion` TEXT NULL , `PVP` DECIMAL( 10, 2 ) NOT NULL , `familia` VARCHAR( 6 ) NOT NULL , PRIMARY KEY ( `cod` ) , INDEX ( `familia` ) , UNIQUE ( `nombre_corto` ) ) ENGINE = INNODB; CREATE TABLE `dwes`.`familia` ( `cod` VARCHAR( 6 ) NOT NULL , `nombre` VARCHAR( 200 ) NOT NULL , PRIMARY KEY ( `cod` ) ) ENGINE = INNODB; CREATE TABLE `dwes`.`stock` ( `producto` VARCHAR( 12 ) NOT NULL , `tienda` INT NOT NULL , `unidades` INT NOT NULL , PRIMARY KEY ( `producto` , `tienda` ) ) ENGINE = INNODB; -- Creamos las claves foráneas ALTER TABLE `producto` ADD CONSTRAINT `producto_ibfk_1` FOREIGN KEY (`familia`) REFERENCES `familia` (`cod`) ON UPDATE CASCADE; ALTER TABLE `stock` ADD CONSTRAINT `stock_ibfk_2` FOREIGN KEY (`tienda`) REFERENCES `tienda` (`cod`) ON UPDATE CASCADE, ADD CONSTRAINT `stock_ibfk_1` FOREIGN KEY (`producto`) REFERENCES `producto` (`cod`) ON UPDATE CASCADE; CREATE USER `dwes` IDENTIFIED BY 'abc123.'; GRANT ALL ON `dwes`.* TO `dwes`;
|
Usa mysql para cargar por líneas de comandos el siguiente fichero arriba especificado
|
Interfaz gráfica
Además de línea de comandos también se dispone de varias herramientas gráficas alternativas. Siempre resulta más agradable e intuitivo, pero requiere más recursos y tener instalados aplicaciones concretas.
En windows o con wine en linux podemos probar SQLyog https://www.webyog.com/product/sqlyog, una herramienta intuitiva y de poco peso. No obstante usaremos phpmyadmin, por ser un clásico y de sencillo uso.
| {{{1}}}
|
-- Creamos la base de datos CREATE DATABASE `dwes` DEFAULT CHARACTER SET utf8 COLLATE utf8_spanish_ci; USE `dwes`; -- Creamos las tablas CREATE TABLE `dwes`.`tienda` ( `cod` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , `nombre` VARCHAR( 100 ) NOT NULL , `tlf` VARCHAR( 13 ) NULL ) ENGINE = INNODB; CREATE TABLE `dwes`.`producto` ( `cod` VARCHAR( 12 ) NOT NULL , `nombre` VARCHAR( 200 ) NULL , `nombre_corto` VARCHAR( 50 ) NOT NULL , `descripcion` TEXT NULL , `PVP` DECIMAL( 10, 2 ) NOT NULL , `familia` VARCHAR( 6 ) NOT NULL , PRIMARY KEY ( `cod` ) , INDEX ( `familia` ) , UNIQUE ( `nombre_corto` ) ) ENGINE = INNODB; CREATE TABLE `dwes`.`familia` ( `cod` VARCHAR( 6 ) NOT NULL , `nombre` VARCHAR( 200 ) NOT NULL , PRIMARY KEY ( `cod` ) ) ENGINE = INNODB; CREATE TABLE `dwes`.`stock` ( `producto` VARCHAR( 12 ) NOT NULL , `tienda` INT NOT NULL , `unidades` INT NOT NULL , PRIMARY KEY ( `producto` , `tienda` ) ) ENGINE = INNODB; -- Creamos las claves foráneas ALTER TABLE `producto` ADD CONSTRAINT `producto_ibfk_1` FOREIGN KEY (`familia`) REFERENCES `familia` (`cod`) ON UPDATE CASCADE; ALTER TABLE `stock` ADD CONSTRAINT `stock_ibfk_2` FOREIGN KEY (`tienda`) REFERENCES `tienda` (`cod`) ON UPDATE CASCADE, ADD CONSTRAINT `stock_ibfk_1` FOREIGN KEY (`producto`) REFERENCES `producto` (`cod`) ON UPDATE CASCADE; CREATE USER `dwes` IDENTIFIED BY 'abc123.'; GRANT ALL ON `dwes`.* TO `dwes`;
|
Usando phpmyadmin, carga los datos para poblar la base de datos
|
- Otra herramienta importante que permite realizar diseños es workbrench
http://dev.mysql.com/doc/workbench/en/index.html
sudo add-apt-repository ppa:olivier-berten/misc sudo apt-get update sudo apt-get install mysql-workbench
|
|
Prueba a hacer cada una de las acciones especificadas anteriormente
|
- Para ver información sobre la conexión se puede usar los atributos *server_info o host_info
$conesion= new mysqli($host,$user,$pass,$bd); mysqli->conect_error mysqli->conect_errno mysqli->server_info mysqli->host_info |
- La lista completa la podemos ver en el siguiente link
http://php.net/manual/es/mysqli.configuration.php
|
INSERT, UPDATE Y DELETE: Método query(...)
El método query, es un método de la clase mysqli que permite enviar una sentencia sql a la base de datos con la que tengamos conexión. En función del tipo de consulta, el método nos puede devolver los siguientes valores:
- Booleano (con las sentencias Insert, Update, Delete); indica si la acción se realizó o no correctamente.
- mysqli_result (con la sentencia Select); si la consulta es de tipo select, el método retornará un conjunto de filas (0 o más); Dispondremos de esta información en un objeto del la clase mysql_result. Esta clase la estudiamos posteriormente.
Hay que tener en cuenta que este método modifica el objeto de la clase mysqli pudiendo afectar a los siguiente atributos:
|
//Me conecto a la base de datos $miConexion = new mysqli("localhost", "root", "root", "dwes"); //Me preparo sentencias //Actuaré sobre la tabla tienda (ver BD anterior) //Tiene los campos cod (autogenerado de forma incremental), nombre y tlf (ambos de tipo varchar) $sentenciaInsert="INSERT INTO tienda (nombre, tlf) VALUES ('Tienda centro', '111-155226')"; $sentenciaDelete="DELETE FROM tienda WHERE nombre = 'Tienda centro' "; $sentenciaUpdate="UPDATE tabla tienda SET nombre = 'Tienda principal' WHERE nombre = 'Tienda centro'"; //Hago una consulta de tipo insert $resultado=miConexion->query($sentenciaInsert) if($resultado){ echo"Se han insertado $miConexion->affected_rows filas en esta acción <br />"; echo "en la inserción se asignó el id autogenerado $miConexion->insert_id <br />"; } |
Tip: Muy importante observa el tema de las comillas, los valores de las instrucciones sql sin son de tipo varchar deben de ir entre comillas
'Tip: Muy importante para la BD es igual comilla simple '''''' que comillas dobles "
|
Qué pasa si en nombre de la tienda es por ejemplo Technology's house
|
Escapar caracteres
Consiste en que de una forma automática si una cadena de caracteres tiene comillas, que estás queden escapadas para que formen parte de la cadena de caracteres y no especifique delimitación de la cadena.
string cadena_escapada ( string $cadena_a_escapar ) |
 |
Escapar caracteres
|
//... $descripción = "I don't want go animal's house" //Esta asignación es correcta //... $consulta = "INSERT INTO acciones VALUES (1, '$descripcion')" //... si yo miro el contenido de la variable $consulta que es lo que pasare al método query() INSERT INTO acciones VALUES (1, 'I don't want go animal's house')
INSERT INTO acciones VALUES (1, 'I don\'t want go animal\'s house')
|
Tip: Observa el tema de las comillas, los valores de las instrucciones sql sin son de tipo varchar deben de ir entre comillas
|
- Para liberar un recurso del tipo mysqli_result, usamos el método free();
$conexion= new mysqli($host,$user,$pass,$bd); if ($conexion->connect_errno==null){ $resultado = $conexion->query($consulta); $numFilas = $resultado->num_rows; $numCampos = $resultado->fields_count; echo "La consulta ha retornado $numFilas filas con $numCampos columnas"; $fila = $resultado->fetch_array(); while ( $fila){ echo"El valor del primer campo es $fila[0]"; $fila = $resultado->fetch_array(); } $resultado->free(); $conexion->close(); } |
|
Haciendo una consulta del tipo select * from producto where pvp < 200, realiza un código que visualizce en una tabla los resultados
|
Transacciones
|
- Supongamos que hacemos una transferencia bancaria; cuando menos implica descontar dinera de una cuenta e ingresaro en otra
|
Ejercicio de transacciones
|
- A continuación y usando el ejemplo anterior de acceso vamos a probar a realizar un sencillo ataques sql.
- Entrar en la plataforma sin tener acceso
Entrar en la plataforma sin tener acceso
- Entramos en una página y vemos el siguiente acceso
- Como no sabemos el usuario ni contraseña probamos a ver si se puede hacer una inserción no controlada
- Como programadores esperamos que en el código haya algo del estilo, como es nuestro caso
- Así que si introducimos estos datos
- Entramos al sistema sin conocer usuario y contraseña
- Insisto en que siempre hay que especificar variables, nunca directamente valores.
- Vemos el siguiente ejemplo:
$consulta->bind_param('ss', 'TABLET', 'Tablet PC'); // Genera un error
$conexion = new mysqli(...); $consulta = $conexion->stmt_init(); $consulta->prepare(...sentencia ... con ???) $consulta->bind_param('s-i-b-d(tipo_de_valores)',valores_en_variables_respectivos_a_????'); $consulta->execute(); $consulta->close(); $conexion->close(); |
- Aquí hay un enlace para una información completa sobre consultas preparadas
http://php.net/manual/es/class.mysqli-stmt.php
|
|
|
Bases de datos con PDO
Qué es PDO
- La extensión PDO (PHP Data Objects) permite acceder a diferentes gestores de bases de datos utilizando las misma funciones.
- Esto es una gran ventaja frente a la extensión vista anteriormente mysqli,
- PDO nos abstrae de forma completa el sistema gestor que se utiliza.
- Como comentamos en el tema anterior, necesitaremos el driver concreto dependiendo del sistema gestor de bases de datos.
- Esto es lo único que tendremos que cambiar en nuestro programa para que funcione en uno u otro gestor de bases de datos, sin tener que cambiar nada del sql.
- En PHP 5 existen drivers para acceder a las bases de datos más populares (MySQL, Oracle, MS SQL Server, PostgreSQL, SQLite, Firebird, DB2, Informix, etc).
- En el siguiente enlace podemos ver los controladores de PDO que soporta directamente php.
http://es.php.net/manual/es/pdo.drivers.php
- En esta lección se explica el acceso a MySQL y SQLite mediante PDO. La extensión PDO no evalúa la correción de las consultas SQL.
Establecer conexión con PDO
- Para establecer una conexión lo que hacemos es instanciar un objeto de la clase PDO
$conexion = new PDO(...);
El constructor tien 4 parámetros de los cuales sólo el primero es obligatorio
- Origen de datos (DSN).
- Este parámetro es un string que la información del controlador del driver que voy a utilizar y se especifica de la siguiente manera
controlador:parametro1=dato1;parametro2=datos...parametron=daton
- Los parámetros a especificar dependerá del controlador que vamos a utilizar, en general me informarán del controlador del driver que voy a utilizar como por ejemplo el nombre o dirección IP del servidor, el nombre de la base de datos).
- Por ejemplo en el caso del controlador mysql
$conexion = new PDO('mysql:host=localhost;dbname=dwes', ...);
- Nombre de usuario
- Contraseña del usuario.
- Opciones de conexión, almacenadas en forma de array.
- Muchas de las opciones de conexión dependerán del driver que vayamos a utilizar
- Por ejemplo con mysql podemos verlas aquí http://php.net/manual/es/ref.pdo-mysql.php
(Ver dentro de cada página de controladores http://php.net/manual/es/pdo.drivers.php)
Conxión con mysql
- En el caso de mysql en parámetro DNS tendríamos los siguientes datos
- host Nombre o dirección IP del servidor.
- port Número de puerto TCP en el que escucha el servidor.
- dbname Nombre de la base de datos.
- unix_socket Socket de MySQL en sistemas Unix.
- Como podemos ver en el ejemplo anterior, no todos los datos del parámetro DNS son obligatorios, podemos establecer la conexión con host y dbname.
- Respecto a las opciones de conexión permiten establecer varios cuestiones
- Una vez establecida la conexión se pueden consultar/acutalizar valores de opciones de la conexión usando los métodos
getAtribute(int $atributo); setAtribute(int $atributo, mixed $valor);
- Podemos ver los atributos en la página http://es.php.net/manual/es/pdo.setattribute.php http://es.php.net/manual/es/pdo.getattribute.php
Realizar consultas con PDO
- En el caso de PDO, se diferencias las consultas que retornan datos (SELECT) y las que actúan sobre el contendio de los datos (INSERT, UPDATE, DELETE)
- INSERT, OPDATE, DELETE
- En este caso la sentencia se ejecuta envíandola con el método exec($sentencia)
- Este método retorna un entero que indica en número de registros afectados
$conexion= NEW PDO("mysql:host=localhost;db=dwes","root","root"); $registros = $conexion->EXEC("DELETE FROM stock WHERE unidades=0"); print "<p>Se han borrado $registros registros.</p>";
- SELECT
- En este caso debemos usar el método de la clase PDO llamado query($consulta)
- Este método retorna un objeto de la clase PDOStatement http://es1.php.net/manual/es/class.pdostatement.php
- Una vez que tenemos el objeto de la clase ya tenemos ese cursor o conjunto de filas con su puntero
- Para extraer cada fila usamos el método fetch(), el cual en caso de que no haya filas que retornar devuelve null (El mismo concepto trabajado hasta ahora).
- Cada vez que hacemos un fetch obtenemos un array con la fila que podemos usar tanto de forma asociativa como indexada.
- Este comportamiento por defecto se puede cambiar, es decir que podemos obligar a que el array que devuelve sea indexado, asociativo o que sea un objeto.
- Para ello debemos pasar al método fetch un valor que lo especifique según la lista siguiente.
- Para cerrar el cursor se emplea el método closeCursor(); muchos gestores de bases de datos necesitas que se libere, antes de ser usado para realizar otra consulta.
- PDO::FETCH_ASSOC. Devuelve solo un array asociativo.
- PDO::FETCH_NUM. Devuelve solo un array con claves numéricas.
- PDO::FETCH_BOTH. Devuelve un array con claves numéricas y asociativas. Es el comportamiento por defecto.
- PDO::FETCH_OBJ. Devuelve un objeto cuyas propiedades se corresponden con los campos del registro.
- A continuación diferentes formas de hacer exactamente lo mismo
$conexion = new PDO("mysql:host=localhost;dbname=dwes", "dwes", "abc123."); $resultado = $conexion->query("SELECT producto, unidades FROM stock"); while ($registro = $resultado->fetch()) { echo "Producto ".$registro['producto'].": ".$registro['unidades']."<br />"; }
$conexion = new PDO("mysql:host=localhost;dbname=dwes", "dwes", "abc123."); $resultado = $conexion->query("SELECT producto, unidades FROM stock"); while ($registro = $resultado->fetch(PDO::FETCH_ASSOC)) { echo "Producto ".$registro['producto'].": ".$registro['unidades']."<br />"; }
$conexion = new PDO("mysql:host=localhost;dbname=dwes", "dwes", "abc123."); $resultado = $conexion->query("SELECT producto, unidades FROM stock"); while ($registro = $resultado->fetch(PDO::FETCH_NUM)) { echo "Producto ".$registro[0].": ".$registro[1]."<br />"; }
$conexion = new PDO("mysql:host=localhost;dbname=dwes", "dwes", "abc123."); $resultado = $conexion->query("SELECT producto, unidades FROM stock"); while ($registro = $resultado->fetch(PDO::FETCH_OBJ)) { echo "Producto ".$registro->producto.": ".$registro->unidades."<br />"; }
$conexion="mysql:host=localhost;dbname=dwes"; $user="root"; $pass="root"; $opciones=array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"); $conexion=new PDO($conexion,$usuario,$pass, $opciones); $consulta = "Select * from ..."; $sentencia = "Insert into ....." $resultado = $conexion->exec($sentencia); $sentencia->closeCursor(); echo "Se han insertado $resultado filas"; $resultado = $conexion->query($sconsulta); while $resultado->fetch(){ echo "se la leído el valor $resultado[0], ..."; } $conexion=null; //Es la manera de liberar a la memoria de este objeto. |
Consultas preparadas
- Al igual que en mysqli, podemos preparar las consultas. Esta forma de trabajar es cómoda y mas segura que la habitual, según viemos en apartados anteriores
- Para realizar una consulta parametrizada, hay que seguir unos pasos al igual que en mysqli
- preparar la consulta prepare(...)
- Para ello se pueden pasar con ? los valores de los parámetros o bien poner un nombre precedido de :
$conexion = new PDO("mysql:host=localhost;dbname=dwes", "dwes", "abc123."); $consulta = $conexion->prepare('INSERT INTO familia (cod, nombre) VALUES (?, ?)');
Es igual que hacer
$conexion = new PDO("mysql:host=localhost;dbname=dwes", "dwes", "abc123."); $consulta = $conexion->prepare('INSERT INTO familia (cod, nombre) VALUES (:codigoProducto, :nombreProducto)');
- Asignar valores a la consulta pararmetrizada
- Si se han especificado ? se asigna dando a cada parámetro un valor con el método bindParam(posicion, valor)
$cod_producto = "TABLET"; $nombre_producto = "Tablet PC"; $consulta->bindParam(1, $cod_producto); $consulta->bindParam(2, $nombre_producto);
- Si se han especificado con nombre se usan los nombre en lugar de los números
$cod_producto = "TABLET"; $nombre_producto = "Tablet PC"; $consulta->bindParam(":cod", $cod_producto); $consulta->bindParam(":nombre", $nombre_producto);
- Se ejecuta con el método execute()
- Este método permite alternativamente suplir las asignaciones anteriores realizadas con el método bindParam, pasándole en un argumento meditante una array dicha asignación.
- El array utilizado será asociativo o con claves numéricas dependiendo de la forma en que hayas indicado los parámetros.
- En el primer caso
$parametros = array["TABLET", ":nombre"]; $consulta->execute($parametros);
- En el segundo caso
$parametros = array(":cod" => "TABLET", ":nombre" => "Tablet PC"); $consulta->execute($parametros);
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<?php
$dns = "mysql:host=localhost; dbname=dwes";
$user='root';
$pass='root';
$opciones= array( PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8");
//Realizamos una conexión básico pdo
$conexion = new PDO($dns, $user, $pass, $opciones);
if ($conexion)
echo "conexión realizada satisfactoriamente";
else
echo "ohhhh!!!! no se ha conectado";
//Ahora planteamos una sentencia de tipo insert
$sentencia = "insert into producto
values('NEW_PRODUCTO12','NOMBRE_PRODUCTO','NOMBRE_CORTO','DESCRIPCION
DESCRIPCION',10000,'MP3')";
//Y planteamos tambión una sentencia select
$consulta ="select nombre_corto from producto";
$filas= $conexion->exec($sentencia);
echo"Se ha insertado correctamene $filas";
//$filas será un objeto del tipo PDOStatement
$filas= $conexion->query($consulta);
while ($fila=$filas->fetch()){
echo "Se ha recuperado $fila[0]<br/>";
}
$filas->closeCursor();
$conexon=null;
//Ahora hacemos la consulta parametrizadas
//usando un objeto de la clase PDOStatement
//Hacemos el prepare
$sentencia= "Select producto from stock where tienda = :nom";
$consulta = $conexion->prepare($sentencia);
$tienda =3;
//$consulta->bindParam(':nom',$tienda,PDO::PARAM_INT);
//$consulta->execute();
//Podemos usar la opción de antes o esta otra
$consulta->execute(array(":nom"=>$tienda));
//Ahora mostramos los resultados
while ($fila=$consulta->fetch()){
echo "Visualizo el producto $fila[0]<br/>";
}
?>
</body>
</html>
|
Control de excepticones
- A partir de la versión 5 se introdujo en PHP un modelo de excepciones similar al existente en otros lenguajes de programación:
- El código susceptible de producir algún error se introduce en un bloque try - catch.
try{ //Instrucciones que pueden lanzar una excepción y //puedo capturar en tiempo de ejecución }cathc(Exception $e){ echo "Se ha producido una excepcion". $e->getMessage(); }
- Cuando se produce algún error, se lanza una excepción utilizando la instrucción throw.
- Después del bloque try debe haber como mínimo un bloque catch encargado de procesar el error.
- Si una vez acabado el bloque try no se ha lanzado ninguna excepción, se continúa con la ejecución en la línea siguiente al bloque o bloques catch.
|
Haz un programa que si dividimos por cero pase una exepcion try { if ($divisor == 0) throw new Exception("División por cero."); $resultado = $dividendo / $divisor; } catch (Exception $e) { echo "Se ha producido el siguiente error: ".$e->getMessage(); }
|
- PHP ofrece una clase base Exception para utilizar como manejador de excepciones.
- Esta clase implementa dos métodos generales que nos muestran información sobre la excepticon que se ha podido producir
- getMessage. Devuelve el mensaje, en caso de que se haya puesto alguno.
- getCode. Devuelve el código de error si existe.
- El caso de PDO define su propia clase de excepciones que deriva o hereada de la clase Exception
- Para el caso concreto de PDO, hay que configurar para que lance las excepciones, puediento esta configuración tomar los siguientes valores:
- PDO::ERRMODE_SILENT. No se hace nada cuando ocurre un error. Es el comportamiento por defecto.
- PDO::ERRMODE_WARNING. Genera un error de tipo E_WARNING cuando se produce un error.
- PDO::ERRMODE_EXCEPTION. Cuando se produce un error lanza una excepción utilizando el manejador propio PDOException.
- Vamos a ver como se utiliza:
- Primero activamos las excepciones, y luego ya se pueden utilizar
$dwes = new PDO("mysql:host=localhost; dbname=dwes", "dwes", "abc123."); $dwes->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); try { $sql = "SELECT * FROM stox"; $result = $dwes->query($sql); //… } catch (PDOException $p) { echo "Error ".$p->getMessage()."<br />"; }
- En este caso que no existe la tabla nos diría
Error SQLSTATE[42S02]: Base table or view not found: 1146 Table 'dwes.stox' doesn't exist
- En el caso de mysqli usaríamos la clase mysqli_sql_exception que gestiona el tema de las excepciones
http://es.php.net/manual/es/class.mysqli-sql-exception.php
|
Filtros
- Qué es
- Para qué sirve
- Dónde aplicarlo
http://php.net/manual/es/ref.filter.php
- Concepto de escapar las comillas simples y dobles
- Ecapar las barras invertidas
http://php.net/manual/es/function.addslashes.php
Transacciones
-->
- Resetear la password de root
https://www.howtoforge.com/reset-forgotten-mysql-root-password
