Introducción a las Bases de Datos Relacionales con MySQL, Esquemas y mapas conceptuales de Química

¡Descarga Introducción a las Bases de Datos Relacionales con MySQL y más Esquemas y mapas conceptuales en PDF de Química solo en Docsity!

MANUAL DE COMANDOS

para MySQL

“Para entender este manual se debe tener una idea base y

mínima sobre las Bases de Datos Relacionales”

Xema Aceituno

ÍNDICE

1. Introducción a MySQL……………………………………. 4

2. Crear una base de datos…………………………………. 5

3. Crear una tabla……………………………………………... 6

Valores nulos

Valores por defecto

Claves primarias

Claves primarias compuestas

Columnas autoincrementadas

Comentarios

4. Borrar una tabla…………………………………………... 12

5. Modificar estructura de una tabla…………………... 13

6. Inserción de Filas…………………………………………. 15

7. Reemplazar Filas…………………………………………... 17

8. Actualizar Filas……………………………………………... 18

9. Eliminar Filas……………………………………………….. 19

10. Vaciar una tabla………………………………………….. 21

11. Consultar una tabla……………………………………... 22

12. Agrupar Filas……………………………………………... 27

13. Claves ajenas………………………………………………. 30

14. Operadores……………………………….……………….. 32

Asignación

Lógicos

Comparación

Aritméticos

Precedencia

15. Consultas multitabla……………………...…………….. 50

Composiciones internas

Composiciones externas

16. Subconsultas………………………………...…………….. 57

17. ANEXO……………………………………….………………. 60

18. BIBLIOGRAFÍA……………………………..………..…... 65

Introducción a MySQL

A nivel teórico, existen 3 lenguajes para el manejo de bases de datos:

DDL (Data Definition Language) Que es el lenguaje de definición de datos. Es el lenguaje

que se usa para crear bases de datos y tablas, y para modificar sus estructuras, así como los

permisos y privilegios.

Este lenguaje trabaja sobre unas tablas especiales llamadas diccionario de datos.

DML (Data Manipulation Language) que es el lenguaje de manipulación de datos. Es el

que se usa para modificar y obtener datos desde las bases de datos.

DCL (Data Control Language) que es el lenguaje de control de datos, que incluye una serie

de comandos que permiten al administrador controlar el acceso a los datos contenidos en

la base de datos.

A continuación vamos a ver las instrucciones más básicas en MySQL divididas en

secciones. Pero antes de empezar te enseñaremos 2 auxiliares que te vendrán bien para

comprobar los resultados de lo que vayas haciendo;

SELECT * FROM nombretabla;

se usa para ver el resultado de una tabla con todos sus registros.

DESCRIBE nombretabla;

se usa para ver la estructura de una tabla.

Crear una base de datos

CREATE DATABASE;

SHOW DATABASES;

USE prueba;

Desde el punto de vista de SQL, una base de datos es sólo un conjunto de relaciones (o

tablas). A nivel de sistema operativo, cada base de datos se guarda en un directorio

diferente.

Por tanto, crear una base de datos es una tarea muy simple. Claro que, en el momento de

crearla, la base de datos estará vacía, es decir, no contendrá ninguna tabla.

Para crear una base de datos se usa una sentencia CREATE DATABASE:

mysql>CREATE DATABASE prueba; Query OK, 1 row affected (0.03 sec)

Para saber cuántas bases de datos existen en nuestro sistema usamos la sentencia SHOW

DATABASES:

mysql>SHOW DATABASES; +--------------------+ | Database | +--------------------+ | mysql | | prueba | | test | +--------------------+ 3 rows in set (0.00 sec)

A partir de ahora, en los próximos capítulos, trabajaremos con esta base de

datos, por lo tanto la seleccionaremos como base de datos por defecto.. Para

seleccionar una base de datos concreta se usa el comando USE que no es

exactamente una sentencia SQL, sino más bien de una opción de MySQL. Esto

nos permitirá obviar el nombre de la base de datos en consultas:

mysql>USE prueba; Database changed

Valores nulos

… NOT NULL / NULL …

Al definir cada columna/atributo podemos decidir si podrá o no contener valores nulos.

Recordemos que aquellas columnas que son o forman parte de una clave primaria no

pueden contener valores nulos.

Después 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.

Cuando creamos una tabla la opción por defecto es que se permitan los valores nulos

( NULL ) y para que no se permitan, se especifica con NOT NULL. Por ejemplo:

mysql>CREATE TABLE ciudad1 (nombre CHAR(20) NOT NULL, poblacion INT NULL); Query OK, 0 rows affected (0.98 sec) Valores por defecto

… DEFAULT …

Para cada columna/atributo también se puede definir, opcionalmente, un valor por

defecto. El valor por defecto se asignará de forma automática a un atributo cuando no se

especifique un valor determinado al añadir filas. Para ello usamos el comando DEFAULT

dentro de la sentencia CREATE TABLE.

Si a un atributo se le declara que puede ser 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

poblacion es NULL.

Por ejemplo, si queremos que el valor por defecto para poblacion 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)

Claves Primarias

… PRIMARY KEY…

Para claves primarias t ambién se puede definir una clave primaria sobre un atributo, usando la palabra clave KEY o PRIMARY KEY. Sólo puede existir una clave primaria en cada tabla, y el atributo sobre el que se define una clave primaria no puede tener valores NULL. Si esto no se especifica de forma explícita, MySQL lo hará de forma automática. Por ejemplo, si queremos asignar la clave primaria a “ 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) Usar NOT NULL PRIMARY KEY equivale a PRIMARY KEY , NOT NULL KEY o sencillamente KEY. Existe una sintaxis alternativa para crear claves primarias, que en general es preferible, ya que es más potente. De hecho, la anterior es un alias para la forma general, que no admite todas las funciones (como por ejemplo, crear claves primarias sobre varias columnas). Veremos esta otra alternativa más adelante.

Columnas Autoincrementadas

… AUTO_INCREMENT …

Para 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) Para establecer un número específico del que partiren el auto_increment hay que crear la tabla de la siguiente manera:

mysql> create table prueba (id int key auto_increment, name

varchar(20)) auto_increment=20;

Query OK, 0 rows affected (0.28 sec) mysql> describe prueba; +-------+-------------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +-------+-------------+------+-----+---------+----------------+ | id | int(11) | NO | PRI | NULL | auto_increment | | name | varchar(20) | YES | | NULL | | +-------+-------------+------+-----+---------+----------------+ 2 rows in set (0.00 sec)

Comentarios

… COMMENT…

Para los comentarios , adicionalmente, al crear la tabla, podemos añadir un comentario a

cada columna. Este comentario sirve como información adicional sobre alguna

característica especial de la columna, y entra en el apartado de documentación de la base

de datos:

mysql>CREATE TABLE ciudad -> (clave INT AUTO_INCREMENT PRIMARY KEY COMMENT 'Clave principal', -> nombre CHAR(50) NOT NULL, -> poblacion INT NULL DEFAULT 5000); Query OK, 0 rows affected (0.08 sec)

Modificar estructura de una tabla

ALTER TABLE … RENAME…

ALTER TABLE … DROP COLUMN…

ALTER TABLE … DROP PRIMARY KEY…

ALTER TABLE … ADD…

ALTER TABLE … ADD…AFTER…

ALTER TABLE … ADD…FIRST;

ALTER TABLE … ADD…PRIMARY KEY…

ALTER TABLE … MODIFY COLUMN…

Para modificar una tabla podemos usar el comando ALTER TABLE:

Por ejemplo, si queremos cambiar el nombre de la tabla:

mysql>ALTER TABLE ciudad6 RENAME granciudad; Query OK, 0 rows affected (0.03 sec)

Para eliminar una columna de una tabla:

mysql>ALTER TABLE granciudad DROP COLUMN poblacion; Query OK, 0 rows affected (1.28 sec) Records: 0 Duplicates: 0 Warnings: 0

Para eliminar varias columnas seguiríamos la misma sintaxis separando cada columna con

una coma: ALTER TABLE nombre_tabla DROP COLUMN nombre1, DROP COLUMN

nombre2;

Para eliminar la clave primaria de una columna:

mysql>ALTER TABLE granciudad DROP PRIMARY KEY; Query OK, 1 row affected (1.20 sec) Records: 1 Duplicates: 0 Warnings: 0

Para insertar una nueva columna al final de una tabla:

mysql>ALTER TABLE granciudad ADD fecha date; Query OK, 1 row affected (1.20 sec) Records: 1 Duplicates: 0 Warnings: 0

Para añadir una nueva columna después de otra:

mysql>ALTER TABLE granciudad ADD origen VARCHAR(50) AFTER nombre; Query OK, 0 rows affected (0.70 sec) Records: 0 Duplicates: 0 Warnings: 0

Para añadir una nueva columna en la primera posición de la tabla:

mysql>ALTER TABLE granciudad ADD id INT FIRST; Query OK, 0 rows affected (0.72 sec) Records: 0 Duplicates: 0 Warnings: 0

Asignar como clave primaria a una columna:

mysql>ALTER TABLE granciudad ADD PRIMARY KEY(id);

También podemos reestructurar una columna:

mysql>ALTER TABLE granciudad MODIFY COLUMN id INT auto_increment;

En este caso le hemos dotado a la columna id de la propiedad de autoincrementarse

automáticamente.

En este caso le hemos dotado a la columna id de la propiedad de autoincrementarse

automáticamente. Cuando se añade una columna AUTO_INCREMENT, los valores de

columna se llenan con una secuencia numérica automáticamente.

Se puede establecer el auto_increment usando ALTER TABLE de la siguiente manera:

mysql> alter table granciudad auto_increment = 40;

Query OK, 0 rows affected (0.08 sec)

O también con la opción SET INSERT_ID =value

mysql> set insert_ID=50;

Query OK, 0 rows affected (0.00 sec)

Además existe una alternativa que consiste en indicar un valor para cada columna:

mysql> INSERT INTO granciudad SET

-> id = 5,

->nombre = "Bilbao";

Query OK, 1 row affected (0.08 sec) mysql> select * from granciudad; +------+------+-----------+----------+------------+ | id2 | id | nombre | origen | fecha | +------+------+-----------+----------+------------+ | 1 | 1 | barcelona | barcino | 2011-01-01 | | 2 | 2 | madrid | madrilus | 1111-01-02 | | 3 | 3 | valencia | valentia | 3214-01-03 | | NULL | 4 | zaragoza | NULL | NULL | | NULL | 5 | Bilbao | NULL | NULL | +------+------+-----------+----------+------------+ 5 rows in set (0.01 sec)

Reemplazar Filas

REPLACE INTO … VALUES(…);

Con la sentencia REPLACE podemos modificar un registro anterior. Realizamos un ejemplo, si

partimos de esta tabla: mysql> select * from granciudad; +----+----------+----------+------------+ | id | nombre | origen | fecha | +----+----------+----------+------------+ | 2 | madrid | madrilus | 1111-01-02 | | 3 | valencia | valentia | 3214-01-03 | | 4 | zaragoza | NULL | NULL | | 5 | Bilbao | NULL | NULL | +----+----------+----------+------------+ 4 rows in set (0.00 sec) Siendo “id” la PRIMARY KEY, queremos reemplazar la columna ‘origen’ de Zaragoza de NULL a ‘caesaraugusta’: mysql> REPLACE INTO granciudad (id, nombre, origen) VALUES (4,'zaragoza','caesaraugusta'); Query OK, 2 rows affected (0.03 sec) mysql> SELECT * FROM granciudad; +----+----------+---------------+------------+ | id | nombre | origen | fecha | +----+----------+---------------+------------+ | 2 | madrid | madrilus | 1111-01-02 | | 3 | valencia | valentia | 3214-01-03 | | 4 | zaragoza | caesaraugusta | NULL | | 5 | Bilbao | NULL | NULL | +----+----------+---------------+------------+ 4 rows in set (0.00 sec)

Observamos que se hemos cambiado el valor deseado en la fila con id=4. Has de tener presente

que el comando REPLACE puede realizar una inserción de fila del mismo modo que lo hace el

comando INSERT INTO.

Eliminar Filas

DELETE FROM…

DELETE FROM … WHERE…

DELETE FROM … WHERE…ORDER BY … ASC/DESC;

DELETE FROM … ORDER BY … ASC/DESC… LIMIT…;

Con la sentencia DELETE podemos eliminar filas de la tabla:

mysql> DELETE FROM ciudad3;

Query OK, 5 rows affected (0.05 sec) En este caso se han eliminado TODAS las filas de la tabla ‘ciudades’. Si deseamos eliminar solo determinadas filas usamos la cláusula WHERE: filas. mysql> SELECT * FROM granciudad; +----+----------+----------------+------------+ | id | nombre | origen | fecha | +----+----------+----------------+------------+ | 2 | madrid | ciudad_iberica | 1111-01-02 | | 3 | valencia | ciudad_iberica | 3214-01-03 | | 4 | zaragoza | caesaraugusta | NULL | | 5 | Bilbao | ciudad_iberica | NULL | | 6 | malaga | ciudad_iberica | NULL | +----+----------+----------------+------------+ 5 rows in set (0.00 sec) mysql> DELETE FROM granciudad WHERE id=6; Query OK, 1 row affected (0.08 sec) mysql> SELECT * FROM granciudad; +----+----------+----------------+------------+ | id | nombre | origen | fecha | +----+----------+----------------+------------+ | 2 | madrid | ciudad_iberica | 1111-01-02 | | 3 | valencia | ciudad_iberica | 3214-01-03 | | 4 | zaragoza | caesaraugusta | NULL | | 5 | Bilbao | ciudad_iberica | NULL | +----+----------+----------------+------------+ 4 rows in set (0.00 sec) Como podemos observar solo se eliminó la fila cuyo id era 6, es decir, la de ‘malaga’

También podemos usar las cláusulas LIMIT y ORDER BY en la sentencia DELETE , por ejemplo, para eliminar los últimos o primeros registros de una tabla. Por ejemplo , si queremos eliminar las dos primeras ciudades que aparecen en la tabla ordenando alfabéticamente por su nombre realizaríamos lo siguiente: mysql> select * from granciudad; +----+----------+----------------+------------+ | id | nombre | origen | fecha | +----+----------+----------------+------------+ | 2 | madrid | ciudad_iberica | 1111-01-02 | | 3 | valencia | ciudad_iberica | 3214-01-03 | | 4 | zaragoza | caesaraugusta | NULL | | 5 | Bilbao | ciudad_iberica | NULL | +----+----------+----------------+------------+ 4 rows in set (0.00 sec) mysql> DELETE FROM granciudad ORDER BY nombre ASC LIMIT 2; Query OK, 2 rows affected (0.27 sec) mysql> SELECT * from granciudad; +----+----------+----------------+------------+ | id | nombre | origen | fecha | +----+----------+----------------+------------+ | 3 | valencia | ciudad_iberica | 3214-01-03 | | 4 | zaragoza | caesaraugusta | NULL | +----+----------+----------------+------------+ 2 rows in set (0.00 sec) mysql> Como podemos observar ha eliminado ‘madrid’ y ‘bilbao’ que son las dos primeras ciudades si ordenamos la lista alfabéticamente por el campo ‘nombre’. Si en LIMIT hubiésemos puesto 1 solo habría eliminado Bilbao. Si hubiésemos puesto 3 habría eliminado ‘bilbao’ ‘madrid’ y ‘valencia’.