Introducción al Uso de extensiones orientadas a objetos
- Para trabajar con las extensiones, las usaremos siempre orientadas a objetos, aunque tengan
la correspondiente funcionalidad en el lenguaje estructurado.
- Para recordar muy brevemente posemos usar el siguiente enlace
http://www.desarrolloweb.com/articulos/1540.php
- Uso básico de POO
- Recordamos que para crear una nueva instancia de una clase usamos el operador new
- Para acceder a los diferentes métodos del objeto instaciado, usamos el operador de indirección ->
$miObjeto->metodo($parametros);
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-client
Como 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
Mysql con docker
- Monta un contenedor de docker llamado contenedorMysql.
- Instala en el contenedor mysql.
- Guarda el contenedor como una imagen y llámalo imagen Mysql.
- Crea un nuevo contenedor de esa imagen.
- Prueba desde tu localhost a conectarte a la base de datos de ese contenedor.
|
Widget:Quiz Visual Spelling
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
- Usar una base de datos concreta
- Mostrar la descripción de una base de datos (Las tablas que contiene)
- Obtener ayuda de los comandos disponibles
- 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
Actividad
- Conectar a mysql
- Mira Las bases de datos que tienes
- usa una base de datos concreta
- mira las tablas que tiene esa bases de datos
- mira la estructura de la tabla
- Haz una consulta de los valores que tiene su primera columna
- ejecuta el comando help
- sal de sql
|
- Bases de datos
Archivo:BaseDatos.pdf
-- 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`;
Actividad
|
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.
Archivo:Datos.sql
-- 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`;
Actividad
|
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
Actividad
- Instalamos y probamos las diferentes opciones con esta herramienta
- Probamos a hacer un diseño en modelo relacional y a partir del modelo creamos las tablas.
- Probamos las opciones forward engineer y reverser engineer
|
Herramientas de administración
- Con phpmyadmin, podemos hacer casi todo de administrar y manejar las bases de datos
- No obstante mysql proporciona una serie de herramientas que permiten administrar por línea de comandos .
- En muchas ocasiones este tipo de operaciones resultan muy interesantes.
- mysql
- myhsqladmin
- mysqlshow
- mysqladmin
- Es un cliente específico para la administración
- Entre otras acciones podemos realizar:
- crear y eliminar bases de datos.
- mostrar la configuración y el estado del servidor.
- cambiar contraseñas.
- detener un servidor.
- ver la version del servidor
http://ftp.nchu.edu.tw/MySQL/doc/refman/5.0/es/mysqladmin.html
Actividad
|
Prueba a hacer cada una de las acciones especificadas anteriormente
|
Mysql y su extensión mysqli para php
- CONECTARNOS A LA BASE DE DATOS
- A continuación iremos viendo como implementar las acciones básicas en el lenguaje
- Conectarse
- Para conectarse a una base de datos , creamos una instacia de la clase mysqli de la forma
$miConexion = new mysqli(....);
- Extensión Mysqli
- El constructor de la clase puede recibir hasta 5 parámetros, de los cuales 4 se suelen usar con bastante frecuencia
- $host nombre o ip del equipo (null o localhost, identificaría el equipo actual).i
- $usario es el usuario de la base de datos
- $pass
- $nombreBD
- $puerto
- $shocket
- Ejemplo new mysqli(...)
$host="localhost"
$usuario="manolo";
$pass="romero";
$nombreBD="alumnos";
$miConexion = new mysqli ($host,$usuario,$pass,$nombreBD);
if ($miConexion==null)
echo"Error conectando a la base de datos";
else
echo "Conectado a la base de datos";
- mysqli(...)
- Esta función retorna el recurso de la conexión
- Para gestionar los errores deberíamos usar el atributo connect_error de la clase mysqli
- Este atributo aporta información sobre el error o contiene null si no se ha producido ninguno.
- En el código anterior
if ($miConexion->connect_error)
echo "Error conectando con la base de datos: ".$miConexion->connect_error;
- Para ver información sobre la conexión se puede usar los atributos *server_info o host_info
Resumen
$conesion= new mysqli($host,$user,$pass,$bd);
mysqli->conect_error
mysqli->conect_errno
mysqli->server_info
mysqli->host_info |
- Opciones por defecto
- Hay muchas opciones de mysqli que se pueden configurar en el fichero php.ini
- Aquí tenemos alguna de ellas
- mysqli.allow_persistent
- Permite crear conexiones persistentes.
- mysqli.default_port
- Número de puerto TCP predeterminado a utilizar cuando se conecta al Servidor de base de datos.
- Opciones por defecto
- mysqli.reconnect
- Indica si se debe volver a conectar automáticamente en caso de que se pierda la conexión.
- mysqli.default_host.
- Host predeterminado a usar cuando se conecta al servidor de base de datos.
- mysqli.default_user.
- Nombre de usuario predeterminado a usar cuando se conecta al servidor de base de datos.
- mysqli.default_pw
- Contraseña predeterminada a usar cuando se conecta al servidor de base de datos.
Cambiar la base de datos
- Si hemos seleccionado una base de datos, o no hemos seleccionado ninguna y queremos cambiar a otra
$miConexion->select_db("nombre_base_datos");
- Cuando ya no vamos a usar un recurso, conviente y repito CONVIENE, liberarlo.
DML
- En SQL sabemos que tenmos tres tipos de lenguajes DDL, DML, DCL
- Ahora toca DML, Leguane de maninputación de datos
- Podemos clasificar en dos tipos de clúsulas:
- las que no devuelven registros de datos (INSERT, DELETE, UPDATE)
- Generalmente retornan un entero que es el número de filas aceptadas o un booleano que indica si se realizó no la operación
- DML
- Las que pueden retornan una colección de filas (SELECT), generalmente conocidas como cursor.
- En mysqli podemos enviar cualquiera de estas claúsulas con el método query
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:
Atributos que puede modificar query()
- $affected_rows. Número de filas modificadas por la acción.
- $error, $errno. En caso de producir un error la sentencia.
- $insert_id Devuelve el id autogenerado que se utilizó en la última inserción.
|
Resumen
//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 "
Pregunta
|
Qué pasa si en nombre de la tienda es por ejemplo Technology's house
- Habría que escapar ese caracter
|
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.
Método para escapar cadenas
- Es un método de la clase mysqli
string cadena_escapada ( string $cadena_a_escapar ) |
|
|
Escapar caracteres
|
|
|
- suponemos que tenemos una tabla llamada acciones que tiene el campo descripcion y cod_usuario
- Quiero insertar este valor para descripcion como muestra el siguiente código:
//...
$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')
- Esto a la hora de insertar me generará un error, ya que el gestor interpreta que el contenido para el campo descripcion es 'I don'
- Para evitar esto yo querría que el valor de $descripcion estuviera escapado
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
$miConexion->query($sentenciasDelete);
$resultado =$miConexion->query($sentenciaDELETE);
if ($resultado){
echo "Se han borrado $miConexion->affected_rows filas ";
}
$miConexion->query($sentenciasUpdate);
$resultado = $miConexion->query($sentenciaUPDATE);
if ($resultado){
echo "Se han actualizado $miConexion->affected_rows filas ";
}
</sourece>
</div>
<div class="slide">
<source lang=php>
$miConexion->query($sentenciasInsert);
$resultado = $miConexion->query($sentenciaINSERT);
if ($resultado){
echo "Se han insertado $miConexion->affected_rows filas ";
}
- Observemos su uso en el ejemplo
//Establecemos la conexión
$miConexion = new mysqli('localhost', 'manolo', '12345.', 'baseDatosPrueba');
//Capturamos un posible error
$error = $miConexion->connect_errno;
//En caso de error informamos de ello
if ($error == null) {
$resultado = $miConexion->query('DELETE FROM stock WHERE unidades=0');
if ($resultado) {
print "<p>Se han borrado $miConexion->affected_rows registros.</p>";
}
}
$miConexion->close();
}
Clausula SELECT con query
- Tenemos dos maneras de realizar consultas con mysqli
- query
- real_query
- En el primero caso el método nos retorna un cursor que será de la clase mysqli_result
- En el segundo caso nos retornará un booleano y para leer los datos deberemos usar o store_result o use_result según veamos a continuación.
Método query
- Una vez que tenemos los datos almacenados debemos saber acceder.
- Tenemos 4 formas de poder acceder a los datos según usemos un método u otro
- fetch_array()
- Va obteniendo cada registro como un array
- Este array podemos usar tanto de forma indexada, como asociativa (con el nombre del campo)
- fetch_assoc()
- En este caso el array que retorna es asociativo
- fetch_row()
- En este caso el array que retorna es indexado
- fetch_object()
- En este caso en lugar de retornar un array, retorna un objeto, donde cada campo son los diferentes atributos de ese objeto
- En todos los casos cada vez que leemos un elemento de mysqli_result, lo que por comparativa sería un cursor, vamos avanzando al siguiente. Cuando hayamos leído todos retornaría null
Actividad
- Optén todos los registros de la tabla familia
- visualizalos en una tabla usando los tres modos de lectura de datos vistos anteriormente
|
- Para liberar un recurso del tipo mysqli_result, usamos el método free();
- La clase mysqli_result, además de los métodos vistos tiene un par de atributos interesantes
- int $field_count;
- Nos dice cuantas columnos tiene el query actual
- int $num_rows;
- Nos dice cuantas filas hemos obtenido con la consulta
- Tenemos una lista completa
http://es.php.net/manual/es/class.mysqli-result.php
Resumen
$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();
} |
Actividad
|
Haciendo una consulta del tipo select * from producto where pvp < 200, realiza un código que visualizce en una tabla los resultados
|
Transacciones
Definición
- Una transacción es un conjunto de acciones u operaciones que
- Esta se realizan contra una base de datos de modo que o bien se realizan correctamente todas
- o no se realiza ninguna
|
- Supongamos que hacemos una transferencia bancaria; cuando menos implica descontar dinera de una cuenta e ingresaro en otra
- Transacciones
- Ahora supongamos que nada mas descontar el dinero de una cuenta se cae la luz y se apaga el servidor
- Esto creará una inconsistencia en la base de datos
- Por defecto en mysqli cada acción con la base de datos es una transacción en sí misma, pero esto se puede modificar
$conexion = new mysqli(..);
$conexion->autocommit(false);
.....
- Si se ha desactivado el autocommit, para terminar una transacción debemos usar los métodos commit o rollback
$conexion = new mysqli(..);
$conexion->autocommit(false);
.....
if (CondicionOK){
//Terminamos la transacción confirmando todas las acciones sobre la base de datos desde que se inició la
transaccion
$conexion->commit();
}else{
//Terminamos la transacción desaciendo todas las acciones sobre la base de datos desde que se inició la
transaccion, y dejando la base de datos igual que estaba al principio
$conexion->rollback();
}
Actividad
|
Ejercicio de transacciones
|
Injecciones SQL
- Es un problema de seguridad importante, que hay que conocer y evitar
- Existe mucha documentación al respecto, en general podemos afirmar que un buen conocimiento de SQL proporcina herramientas tanto para poder establecer este tipo de ataques, como para podernos prevenir de ellos.
- Aportamos referenicas de web que nos pueden interesar consultar
- 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
$nombre=$_POST['usuario'];
$pass=$_POST['pass'];
$consulta="select * from usuarios where nombre = \"$nombre\" and pass = \"$pass\" ";
$resultado = $conexion->query($consulta);
- Si todo fuera normal y nombre fuera por ejemplo "maría" la consulta que se envía al servidor sería
select * from usuarios where nombre = "maria"
- Esta consulta si existe el usuario maría nos retornará una tupla, si no no devolverá ninguna.
- Inyecciones sql
- Pero si añadimos más cosas obtendremos segura una respuesta, por ejemplo si en el codigo $nombre="maria or \"1\"= \"1\" "
- Entonces la consulta quedaría
select * from usuarios where nombre = "maria" or "1"="1"
- Que nos devolverá todas las filas
- Así que si introducimos estos datos
- Entramos al sistema sin conocer usuario y contraseña
Consultas preparadas
- Una consulta preparada consiste en establecer una consulta como si fuera una variable y ejecutarla posteriormente tantas veces como sea necesario.
- Estas consultas se almacenan en el servidor y están listas para ser ejecutadas cuando sea necesario. El servidor solo tiene que analizarlas una vez
- Para trabajar con consultas preparadas, debemos usar la clase mysqli_stmt, e inicializarla con el método stmt_init
$conexion = new mysqli('localhost', 'dwes', 'abc123.', 'dwes');
//Preparo el objeto $consulta para crear consultas preparadas en él
$consulta = $conexion->stmt_init();
Los pasos para trabajar con consultas preparadas son:
- Preparar la consulta en el servidor MySQL utilizando el método prepare.
- Ejecutar la consulta, tantas veces como sea necesario, con el método execute.
- Una vez que ya no se necesita más, se debe ejecutar el método close.
$consulta = $conexion->stmt_init();
$consulta->prepare('INSERT INTO familia (cod, nombre) VALUES ("TABLET", "Tablet PC")');
$consulta->execute();
$consulta->close();
$conexion->close();
Parametrizar las consultas preparadas
- El uso real de las consultas preparadas es que los valores que pasas se asignen antes de ejectuar la consulta.
- La idea es preapara la consulta sin indicar los valores.
- Asignar los valores y ejectuar la consulta cuantas veces sea necesario.
- Veamos el proceso
- Parametrizar la consulta
- Consiste en indicar en la consulta preparada en lugar de los valores, signos de interrogación ?
- En el caso anterior
$consulta->prepare('INSERT INTO familia (cod, nombre) VALUES (?,?);
- Ahora habría que asigar los valores. Para ello usamos el método bind_param'
bind_param(tipoDatos, variables_con_los_valores)
- Este método recibe dos tipos de parámetros
- El primero es una cadena de caracteres, donde cada carácter especifica el tipo de valor que va a recibir cada uno de los valores esperados en la consulta.
- s: cadena de caracteres
- i: número entero
- d: número float
- b: valor binario (BLOB)
- Consultas preparadas
- En nuestro caso como va a recibir en los dos parámetros cada uno una cadena de caracteres sería "ss"
- El segundo grupo sería cada uno de los valores.SIEMPRE hay que especificar variables
- En el ejemplo que estamos siguiendo
$consulta = $conexion->stmt_init();
$consulta->prepare('INSERT INTO familia (cod, nombre) VALUES (?, ?)');
$cod_producto = "TABLET";
$nombre_producto = "Tablet PC";
$consulta->bind_param('ss', $cod_producto, $nombre_producto);
- 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
Resumen
$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(); |
Consultas preparadas que retornan valores
- En caso de que la consulta preparada retorne valores se recogen con el método bind_result'
- Este método recibirá variables en los que se almacenarán los valores
- Para recorre el conjunto de valores, usamos el método fectch()
- Vemos el siguiente ejemplo
- Consultas preparadas que generan valores
$consulta = $conexion->stmt_init();
$consulta->prepare('SELECT producto, unidades FROM stock WHERE unidades<2');
$consulta->execute();
$consulta->bind_result($producto, $unidades);
while($consulta->fetch()) {
print "<p>Producto $producto: $unidades unidades.</p>";
}
$consulta->close();
$conexion->close();
Práctica de tienda
- Vamos a trabajar con la base de datos de la tienda
- Lo primero usando la herramienta workbench generamos el modelo de tablas de la base de datos dwes y la analizamos
- Crea una página web en la que se muestre el stock existente de un determinado producto en cada una de las tiendas.
- Para seleccionar el producto concreto utiliza un cuadro de selección dentro de un formulario en esa misma página.
|
Práctica de tienda
- Puedes usar como base los siguientes ficheros css y plantilla adjuntos.
- Añade la opción de modificar el número de unidades del producto en cada una de las tiendas.
- Utiliza una consulta preparada para la actualización de registros en la tabla stock.
- No es necesario tener en cuenta las tareas de inserción
- (no existían unidades anteriormente)
- Tampoco las de borrado (si el número final de unidades es cero).
|
