1. Instalar MySQL en Linux
apt-get update && apt-get upgrade
apt-get install mysql-server
2. Estructura de una BBDD
3. Autenticarnos en MySQL
mysql -u root -p
NOTA: Mysql> no es una orden, es el prompt de mysql. Nos pedirá la contraseña, se la metemos y listo.
Vamos a desarrollar el artículo directamente en la consola de MySQL, pero hay otras opciones válidas como instalar phpmyadmin y de esa forma trabajar sobre un entorno gráfico.
4. Crear bases de datos
create database prueba;
mysql> CREATE DATABASE prueba; Query OK, 1 row affected (0.03 sec) mysql>
4.1. Mostrar las bases de datos creadas
show databases;
mysql> SHOW DATABASES; +--------------------+ | Database | +--------------------+ | mysql | | prueba | | test | +--------------------+ 3 rows in set (0.00 sec) mysql>
5. Crear tablas dentro de la BBDD.
La sintaxis para definir columnas es:
nombre_col tipo [NOT NULL | NULL] [DEFAULT valor_por_defecto]
[AUTO_INCREMENT] [[PRIMARY] KEY] [COMMENT 'string']
[definición_referencia]
Lo primero que hay que hacer es seleccionar la base de datos prueba.
use prueba;
mysql> USE prueba; Database changed mysql>
Veamos ahora la sentencia CREATE TABLE que sirve para crear tablas.
La sintaxis de esta sentencia es compleja, ya que existen muchas opciones y tenemos muchas posibilidades diferentes a la hora de crear una tabla. Las iremos viendo paso a paso, y en poco tiempo sabremos usar muchas de sus posibilidades.
En su forma más simple, la sentencia CREATE TABLE creará una tabla con las columnas que indiquemos. Crearemos, como ejemplo, una tabla que nos permitirá almacenar nombres de personas y sus fechas de nacimiento. Deberemos indicar el nombre de la tabla y los nombres y tipos de las columnas:
mysql> CREATE TABLE gente (nombre VARCHAR(40), fecha DATE); Query OK, 0 rows affected (0.53 sec) mysql>
Hemos creado una tabla llamada «gente» con dos columnas: «nombre» que puede contener cadenas de hasta 40 caracteres y «fecha» de tipo fecha.
Si no nos encontramos dentro de la base de datos prueba hay que poner el nombre de la BBDD y la tabla que queremos crear, es decir.
create table prueba.gente(nombre varchar(40), fecha DATE);
5.1. Mostrar las tablas de una base de datos creada.
Lo primero que hay que hacer es seleccionar la base de datos prueba.
use prueba;
Posteriormente una vez dentro ya podemos mostrar las tablas.
show tables;
mysql> SHOW TABLES; +------------------+ | Tables_in_prueba | +------------------+ | gente | +------------------+ 1 row in set (0.01 sec) mysql>
5.2. Crear tabla con valores nulos.
Al definir cada columna podemos decidir si podrá o no contener valores nulos.
Aquellas columnas que son o forman parte de una clave primaria no pueden contener valores nulos y registros repetidos.
Veremos que, si definimos una columna como clave primaria, automáticamente se impide que pueda contener valores nulos, pero este no es el único caso en que puede ser interesante impedir la asignación de valores nulos para una columna.
La opción por defecto es que se permitan valores nulos, NULL, y para que no se permitan, se usa NOT NULL. Por ejemplo:
mysql> CREATE TABLE ciudad1 (nombre CHAR(20) NOT NULL, poblacion INT NULL); Query OK, 0 rows affected (0.98 sec)
5.3. Crear tabla con valores por defecto.
Para cada columna también se puede definir, opcionalmente, un valor por defecto. El valor por defecto se asignará de forma automática a una columna cuando no se especifique un valor determinado al añadir filas.
Si una columna puede tener un valor nulo, y no se especifica un valor por defecto, se usará NULL como valor por defecto. En el ejemplo anterior, el valor por defecto para población es NULL.
Por ejemplo, si queremos que el valor por defecto para población sea 5000, podemos crear la tabla como:
mysql> CREATE TABLE ciudad2 (nombre CHAR(20) NOT NULL,
-> poblacion INT NULL DEFAULT 5000);
Query OK, 0 rows affected (0.09 sec)
5.4. Claves primarias.
También se puede definir una clave primaria sobre una columna, usando la palabra clave KEY o PRIMARY KEY.
No puede existir más de una clave primaria en cada tabla, y la columna sobre la que se define una clave primaria no puede tener valores NULL, ni valores repetidos. Si esto no se especifica de forma explícita, MySQL lo hará de forma automática. Lo que si puede haber es una clave primaria que se componga de dos campos de una tabla.
Si borramos una primary key, podemos crear otro registro con los mismos datos de esa primary key (Esto no es posible en Access)
Por ejemplo, si queremos crear un índice en la columna nombre de la tabla de ciudades, crearemos la tabla así:
mysql> CREATE TABLE ciudad3 (nombre CHAR(20) NOT NULL PRIMARY KEY,
-> poblacion INT NULL DEFAULT 5000);
Query OK, 0 rows affected (0.20 sec)
Hay otra forma de crear las claves primarias.
mysql> CREATE TABLE ciudad4 (nombre CHAR(20) NOT NULL,
-> poblacion INT NULL DEFAULT 5000,
-> PRIMARY KEY (nombre));
Query OK, 0 rows affected (0.17 sec)
Pero esta forma tiene más opciones, por ejemplo, entre los paréntesis podemos especificar varios nombres de columnas, para construir claves primarias compuestas por varias columnas:
mysql> CREATE TABLE mitabla1 (
-> id1 CHAR(2) NOT NULL,
-> id2 CHAR(2) NOT NULL,
-> texto CHAR(30),
-> PRIMARY KEY (id1, id2));
Query OK, 0 rows affected (0.09 sec)
mysql>
5.5. Columnas autoincrementadas.
En MySQL tenemos la posibilidad de crear una columna autoincrementada, aunque esta columna sólo puede ser de tipo entero.
Si al insertar una fila se omite el valor de la columna autoincrementada o si se inserta un valor nulo para esa columna, su valor se calcula automáticamente, tomando el valor más alto de esa columna y sumándole una unidad. Esto permite crear, de una forma sencilla, una columna con un valor único para cada fila de la tabla.
Generalmente, estas columnas se usan como claves primarias ‘artificiales’. MySQL está optimizado para usar valores enteros como claves primarias, de modo que la combinación de clave primaria, que sea entera y autoincrementada es ideal para usarla como clave primaria artificial:
mysql> CREATE TABLE ciudad5 (clave INT AUTO_INCREMENT PRIMARY KEY,
-> nombre CHAR(20) NOT NULL,
-> poblacion INT NULL DEFAULT 5000);
Query OK, 0 rows affected (0.11 sec)
mysql>
5.6. Claves Foráneas o Claves ajenas.
En MySQL sólo existe soporte para claves foráneas en tablas de tipo InnoDB.
NOTA: InnoDB es un mecanismo de almacenamiento de datos de código abierto para la base de datos MySQL.
Usando tablas InnoDB y esta definición de claves foráneas quedará así:
mysql> CREATE TABLE personas2 (
-> id INT AUTO_INCREMENT PRIMARY KEY,
-> nombre VARCHAR(40),
-> fecha DATE)
-> ENGINE=InnoDB;
Query OK, 0 rows affected (0.13 sec)
mysql> CREATE TABLE telefonos2 (
-> numero CHAR(12),
-> id INT NOT NULL,
-> KEY (id), (1)
-> FOREIGN KEY (id) REFERENCES personas2 (id)
-> ON DELETE CASCADE ON UPDATE CASCADE) (2)
-> ENGINE=InnoDB;
Query OK, 0 rows affected (0.13 sec)
mysql>
Es imprescindible que la columna que contiene una definición de clave foránea esté indexada (1). Pero esto no debe preocuparnos demasiado, ya que si no lo hacemos de forma explícita, MySQL lo hará por nosotros de forma implícita.
Esta forma define una clave foránea en la columna ‘id’, que hace referencia a la columna ‘id’ de la tabla ‘personas2’ (2). La definición incluye las tareas a realizar en el caso de que se elimine una fila en la tabla ‘personas2’.
ON DELETE <opción>, indica que acciones se deben realizar en la tabla actual si se borra una fila en la tabla referenciada.
ON UPDATE <opción>, es análogo pero para modificaciones de claves. Existen cinco opciones diferentes. Veamos lo que hace cada una de ellas:
- RESTRICT: esta opción impide eliminar o modificar filas en la tabla referenciada si existen filas con el mismo valor de clave foránea.
- CASCADE: borrar o modificar una clave en una fila en la tabla referenciada con un valor determinado de clave, implica borrar las filas con el mismo valor de clave foránea o modificar los valores de esas claves foráneas.
- SET NULL: borrar o modificar una clave en una fila en la tabla referenciada con un valor determinado de clave, implica asignar el valor NULL a las claves foráneas con el mismo valor.
- NO ACTION: las claves foráneas no se modifican, ni se eliminan filas en la tabla que las contiene.
- SET DEFAULT: borrar o modificar una clave en una fila en la tabla referenciada con un valor determinado implica asignar el valor por defecto a las claves forá- neas con el mismo valor.
Por ejemplo, veamos esta definición de la tabla ‘telefonos3’:
mysql> CREATE TABLE personas3 (
-> id INT AUTO_INCREMENT PRIMARY KEY,
-> nombre VARCHAR(40),
-> fecha DATE)
-> ENGINE=InnoDB;
Query OK, 0 rows affected (0.13 sec)
mysql> CREATE TABLE telefonos3 (
-> numero CHAR(12),
-> id INT NOT NULL,
-> KEY (id),
-> FOREIGN KEY (id) REFERENCES personas3 (id)
-> ON DELETE RESTRICT ON UPDATE CASCADE)
-> ENGINE=InnoDB;
Query OK, 0 rows affected (0.13 sec)
mysql>
Si se intenta borrar una fila de ‘personas3’ con un determinado valor de ‘id’, se producirá un error si existen filas en la tabla ‘telefonos3’ con mismo valor en la columna ‘id’. La fila de ‘personas3’ no se eliminará, a no ser que previamente eliminemos las filas con el mismo valor de clave foránea en ‘teléfonos3’.
Si se modifica el valor de la columna ‘id’ en la tabla ‘personas3’, se modificarán los valores de la columna ‘id’ para mantener la relación.
Veamos un ejemplo más práctico:
personas3
| id | nombre | fecha |
| 1 | Fulanito | 1998/04/14 |
| 2 | Menganito | 1975/06/18 |
| 3 | Tulanito | 1984/07/05 |
telefonos3
| numero | id |
| 12322132 | 1 |
| 12332221 | 1 |
| 55546545 | 3 |
| 55565445 | 3 |
Si intentamos borrar la fila correspondiente a «Fulanito» se producirá un error, ya que existen dos filas en ‘telefonos3’ con el valor 1 en la columna ‘id’.
Sí será posible borrar la fila correspondiente a «Menganito», ya que no existe ninguna fila en la tabla ‘telefonos3’ con el valor 2 en la columna ‘id’.
Si modificamos el valor de ‘id’ en la fila correspondiente a «Tulanito», por el valor 4, por ejemplo, se asignará el valor 4 a la columna ‘id’ de las filas 3ª y 4ª de la tabla ‘telefonos3’:
personas3
| id | nombre | fecha |
| 1 | Fulanito | 1998/04/14 |
| 2 | Menganito | 1975/06/18 |
| 4 | Tulanito | 1984/07/05 |
telefonos3
| numero | id |
| 12322132 | 1 |
| 12332221 | 1 |
| 55546545 | 4 |
| 55565445 | 4 |
6. Eliminar una tabla
A veces es necesario eliminar una tabla, ya sea porque es más sencillo crearla de nuevo que modificarla, o porque ya no es necesaria.
mysql> DROP TABLE ciudad6; Query OK, 0 rows affected (0.75 sec) mysql>
7. Eliminar una BBDD
mysql> DROP DATABASE borrame; Query OK, 0 rows affected, 1 warning (0.00 sec) mysql>
8. Actualizar los privilegios
FLUSH PRIVILEGES;
Cuando creas usuarios o cuando modificas los privilegios de un usuario muchas veces no se reflejan los cambios hasta que reinicias el servidor. Este comando fuerza al servidor a recargar los privilegios logrando que dichos cambios se noten al instante sin necesidad de reiniciar.
9. Insertar, consultar y modificar datos en una BBDD
Llegamos ahora a un punto interesante, una base de datos sin datos no sirve para mucho, de modo que veremos cómo agregar, modificar o eliminar los datos que contienen nuestras bases de datos.
9.1. Insertar filas en una tabla de una BBDD
mysql> INSERT INTO gente VALUES ('Fulano','1974-04-12');
Query OK, 1 row affected (0.05 sec)
mysql> INSERT INTO gente VALUES ('Mengano','1978-06-15');
Query OK, 1 row affected (0.04 sec)
mysql> INSERT INTO gente VALUES
-> ('Tulano','2000-12-02'),
-> ('Pegano','1993-02-10');
Query OK, 2 rows affected (0.02 sec)
Records: 2 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM gente;
+--------+------------+
| nombre | fecha |
+--------+------------+
| Fulano | 1974-04-12 |
| Mengano| 1978-06-15 |
| Tulano | 2000-12-02 |
| Pegano | 1993-02-10 |
+--------+------------+
4 rows in set (0.08 sec)
mysql>
Si no necesitamos asignar un valor concreto para alguna columna, podemos asignarle el valor por defecto indicado para esa columna cuando se creó la tabla, usando la palabra DEFAULT:
mysql> INSERT INTO ciudad2 VALUES ('Perillo', DEFAULT);
Query OK, 1 row affected (0.03 sec)
mysql> SELECT * FROM ciudad2;
+---------+-----------+
| nombre | poblacion |
+---------+-----------+
| Perillo | 5000 |
+---------+-----------+
1 row in set (0.02 sec)
mysql>
mysql> INSERT INTO ciudad3 (nombre, poblacion) VALUES
-> ('Madrid', 7000000);
Query OK, 1 rows affected (0.02 sec)
mysql> INSERT INTO ciudad3 (nombre, poblacion) VALUES
-> ('París', 9000000),
-> ('Madrid', 7200000)
-> ON DUPLICATE KEY UPDATE poblacion=VALUES(poblacion);
Query OK, 3 rows affected (0.06 sec)
Records: 2 Duplicates: 1 Warnings: 0
mysql> SELECT * FROM ciudad3;
+--------+-----------+
| nombre | poblacion |
+--------+-----------+
| Madrid | 7200000 |
| París | 9000000 |
+--------+-----------+
2 rows in set (0.00 sec)
mysql>
9.2. Mostrar/Consultar los registros de una tabla de la BBDD
La parte de consultas a una BBDD es una parte muy extensa y sólo me voy a limitar a ver lo más importante, ya que es una introducción a MySQL
La forma más sencilla es la que hemos usado hasta ahora, consiste en pedir todas las columnas y no especificar condiciones.
mysql>mysql> SELECT * FROM gente; +--------+------------+ | nombre | fecha | +--------+------------+ | Fulano | 1985-04-12 | | Mengano| 1978-06-15 | | Tulano | 2001-12-02 | | Pegano | 1993-02-10 | +--------+------------+ 4 rows in set (0.00 sec) mysql>
Es posible hacer una proyección de una tabla, seleccionando las columnas de las que queremos obtener datos.
mysql> SELECT nombre FROM gente; +--------+ | nombre | +--------+ | Fulano | | Mengano| | Tulano | | Pegano | +--------+ 4 rows in set (0.00 sec) mysql> SELECT clave,poblacion FROM ciudad5; Empty set (0.00 sec)
9.3. Reemplazar filas de una tabla de una BBDD
mysql> REPLACE INTO ciudad3 (nombre, poblacion) VALUES
-> ('Madrid', 7200000),
-> ('París', 9200000),
-> ('Berlín', 6000000);
Query OK, 5 rows affected (0.05 sec) Records: 3 Duplicates: 2 Warnings: 0
mysql> SELECT * FROM ciudad3;
+--------+-----------+
| nombre | poblacion |
+--------+-----------+
| Berlín | 6000000 |
| Madrid | 7200000 |
| París | 9200000 |
+--------+-----------+
3 rows in set (0.00 sec)
mysql>
En este ejemplo se sustituyen las filas correspondientes a ‘Madrid’ y ‘París’, que ya existían en la tabla y se inserta la de ‘Berlín’ que no estaba previamente.
9.4. Actualizar filas de una traba de una BBDD
Por ejemplo, podemos aumentar en un 10% la población de todas las ciudades de la tabla ciudad3 usando esta sentencia:
mysql> UPDATE ciudad3 SET poblacion=poblacion*1.10; Query OK, 5 rows affected (0.15 sec) Rows matched: 5 Changed: 5 Warnings: 0 mysql> SELECT * FROM ciudad3; +--------+-----------+ | nombre | poblacion | +--------+-----------+ | Berlín | 6600000 | | Londres| 11000000 | | Madrid | 7920000 | | París | 10120000 | | Roma | 10450000 | +--------+-----------+ 5 rows in set (0.00 sec) mysql>
Podemos, del mismo modo, actualizar el valor de más de una columna, separándolas en la sección SET mediante comas:
9.5. Eliminar filas de una tabla de una BBDD
La forma más simple es no usar ninguna de las cláusulas opcionales:
mysql> DELETE FROM ciudad3; Query OK, 5 rows affected (0.05 sec) mysql>
De este modo se eliminan todas las filas de la tabla.
Pero es más frecuente que sólo queramos eliminar ciertas filas que cumplan determinadas condiciones. La forma más normal de hacer esto es usar la cláusula WHERE:
mysql> DELETE FROM ciudad5 WHERE clave=2; Query OK, 1 row affected (0.05 sec) mysql> SELECT * FROM ciudad5; +-------+--------+-----------+ | clave | nombre | poblacion | +-------+--------+-----------+ | 1 | Madrid | 6790000 | | 13 | Berlín | 3395000 | | 14 | Roma | 7992800 | +-------+--------+-----------+ 3 rows in set (0.01 sec) mysql>
También podemos usar las cláusulas LIMIT y ORDER BY del mismo modo que en la sentencia UPDATE, por ejemplo, para eliminar las dos ciudades con más población:
mysql> DELETE FROM ciudad5 ORDER BY poblacion DESC LIMIT 2; Query OK, 2 rows affected (0.03 sec) mysql> SELECT * FROM ciudad5; +-------+--------+-----------+ | clave | nombre | poblacion | +-------+--------+-----------+ | 13 | Berlín | 3395000 | +-------+--------+-----------+ 1 row in set (0.00 sec) mysql>
10. Salir de MySQL
quit
exit
11. Tipos de datos en MySQL
Los tipos de datos que puede permitirnos MySQL es muy variada, aquí tenéis algunos de ellos, no están todos. Hay 3 tipos de datos, cadenas de caracteres, números y fechas.
11.1. Cadenas de caracteres
CHAR/CHAR(): Las columnas de tipo char o char() almacenan un carácter o una cadena de caracteres de 0 hasta 255 respectivamente (Si lo recuerdan, este fue el tipo de datos que le asignamos a todas nuestras columnas en la tabla UNO)
VARCHAR: Estas columnas almacenan una cadena de caracteres variables de 0 a 255.
TEXT: Almacena una columna BLOB o TEXT con una longitud de hasta 65535 caracteres (216-1)
MEDIUMTEXT: Almacena una columna BLOB o TEXT con una longitud de hasta 16777215 caracteres (224-1)
LONGTEXT: Almacena una columna BLOB o TEXT con una longitud de hasta 4294967298 caracteres (232-1)
ENUM: Almacena un enumerado, el cual es un objeto cadena que pueden un valor de entre una lista, el valor NULL o el valor de error “”. Este valor puede tener un máximo de 65535 valores diferentes.
SET: Almacena un conjunto. Es una cadena que puede tener 0 ó más valores. Todos esos valores debe estar entre una lista de valores. El máximo de miembros de un conjunto puede ser 64.
11.2. Números
TINYINT(): Almacena un valor entero pequeño de 0 a 255 o de -128 a 127
BOOLEAN: Todos estos tipos son sinónimos de TINYINT(1).
INT/INTEGER: Contiene un entero de tamaño normal (este normal es para nosotros en realidad un tamaño) entre -2147483648 y 2147483647 o entre 0 y 4294967295.
FLOAT/FLOAT(): Guarda un número de coma flotante. Opcionalmente puede acompañarse (al tipo flota sin los paréntesis) de la palabra precisión que le indica la precisión decimal que se desea, que puede llegar hasta 24 para precisión sencilla y de 25 a 53 para una precisión doble. Para flota(), los valores permitidos van desde -3402823466E+38 y -1.175494351E-38, 0, y entre 1.175494351E+38 y 3.402823466E+38. En caso de especificarse el modificador UNSIGNED los valores negativos no son permitidos.
DOUBLE: Contiene un número de coma flotante de precisión normal. Sus valores van desde – 1.7976931348623157E+308 y -2.2250738585072014E-308, 0, y entre 2.2250738585072014E-
308 y 1.7976931348623157E+308. Una vez más, si se define UNSIGNED, los valores negativos no son permitidos.
DECIMAL: Guarda un número de coma flotante sin empaquetar. Esto de sin empaquetar implica que se guarda como una cadena (véase CHAR), usando un carácter para dígito del valor.
11.3. Fechas
DATE: Almacena un valor de fecha, los rangos permitidos son desde ‘1000-01-01’ y ‘9999-12- 31’ (Fecha en la que podría que nosotros ya no estemos vivos). El formato de fecha presentado es, como ya lo habrán imaginado ‘AAAA-MM-DD’
TIME: Es una hora que permite los valores ‘-838:59:59’ a ‘838:59:59’. Los valores se muestran en formato HH:MM:SS
YEAR: Guarda un año en formato de 2 o 4 dígitos, siendo el valor por defecto 4. Los valores permitidos son desde 1901 a 2155 y 0000 en el formato de 4 dígitos y desde 1970 a 2069 en el formato de 2 dígitos (70-69).
DATETIME: Contiene un “MIX” (para demostrar que sabemos de terminología moderna), es decir una mezcla de fecha y hora. El rango que MySQL soporta es desde ‘1000-01-01 00:00:00’ hasta ‘9999-12-31 23:59:59’. El formato es del tipo ‘AAAA-MM-DD HH:MM:SS’
12. Ejercicios
Ejercicio 1. Crear una base de datos llamada videoteca, y dentro de esta una tabla llamada películas, los campos son los siguientes.
1. Meter los siguientes 3 registros en la tabla películas.
| Id_pelicula | Película | Director | |
| 1 | Kill Bill | Jesús Fernández | |
| 2 | Avatar | James Cameron | |
| 3 | Gran Torino | Clint Eastwood | |
2. Eliminar el registro 3
3. Cambiar el director de Kill Bill por Quentin Tarantino.
Ejercicio 2. Crear una base de datos llamada hinarejos y dentro de ella crear una tabla llamada alumnos con los siguientes campos:
| Nombre | Apellidos | DNI | Edad | Teléfono |
1. Meter los 3 registros siguientes en la BBDD.
| Jesus | Fernández | 11111111A | 33 | 111111111 |
| Pedro | Muela | 22222222B | 23 | 222222222 |
| Pepe | Pepón | 33333333C | 45 | 333333333 |
2. Eliminar el registro Pepe.
3. Cambiar la edad de Pedro a 24.
4. Incrementar todas las edades en 1.
Ejercicio 3. Ver las bases de datos creadas desde un entorno gráfico como phpmyadmin.
Ejercicio 4. Eliminar las tablas y BBDD desde el promt de MySQL.
- Eliminar la tabla alumnos de la BBDD hinarejos.
- Eliminar la tabla películas de la BBDD videoteca.
- Eliminar las BBDD hinarejos y videoteca.
Ejercicio 5. Crea una base de datos «ejercicio» desde el prompt de MySQL y realiza todo lo que te propongo.
1. Crea las tablas
Queremos almacenar datos en una estructura parecida a esta: Debes crear las tablas, eligiendo los tipos de datos adecuados.
- Las columnas en negrita identifican la clave primaria de cada tabla.
- Todas las columnas, excepto las claves primarias, permiten nulos.
- Además, COMPRA.idcliente es una clave ajena a CLIENTE.idcliente, y COMPRA.codigo es otra clave ajena a ARTICULO.codigo. La acción a elegir, si es que utilizas algún asistente como el «diseñador» de phpMyAdmin será «NO ACTION» o «RESTRICT»
Ten en cuenta que, una vez hecho esto, deberás insertar datos a las tablas, y que fallen o funcionen correctamente depende de la definición de las tablas y las primeras inserciones.
2. Inserta los registros a las tablas
Para especificar que se quiere almacenar un NULO en una orden insert, o bien no se utiliza esa columna o se escribe la palabra NULL sin comillas de ningún tipo.
Si utilizas el editor SQL, recuerda que unos tipos de datos necesitan comillas y otros no. En algunos casos, MySQL hará el trabajo de «traducir» al formato correcto, pero es mejor que te acostumbres a utilizar las comillas simples cuando se debe.
No obstante, si utilizas alguno de los asistentes de phpMyAdmin NO debes utilizar las comillas en ningún caso, phpMyAdmin ya sabe qué tipo de datos y formato es el correcto.
- Inserta en COMPRA (12,A002,NULL,NULL,NULL) – si te falla esta orden, aparte de errores de sintaxis, solo puede ser porque te has olvidado de permitir nulos en COMPRA.precio o COMPRA.fecha.
- Inserta en COMPRA (23,A002, NULL, NULL,NULL)
- Inserta en COMPRA (22,A191, NULL, NULL,NULL)
- Inserta en COMPRA (22,A005, NULL,NULL,NULL)
- Modifica la fila de COMPRA que has insertado en 1) poniendo las unidades igual a 3, el precio igual a 300 y la fecha igual a 2012-09-10
- Borra al cliente 22
- Borra al cliente 19
- Borra el artículo A001
- Borra la compra (22,A001)
- Modifica el identificador del cliente 12 y haz que sea igual 32
- Modifica el valor de COMPRA.codigo a A001 en la fila identificada por (22,A005)
- Inserta un cliente (56, LUCÍA GARCÍA GARCÍA de BAÑUELOS, Sevilla)
Ejercicio 6. Borra la base de datos del ejercicio anterior desde el prompt de MySQL y hazlo de nuevo pero desde phpMyAdmin.
NOTA: InnoDB es un mecanismo de almacenamiento de datos de código abierto para la base de datos MySQL,
13. Referencias
http://mysql.conclase.net/
