MANUAL DE COMANDOS

para MySQL

Cristian Menjivar.
 Introducción a MySQL

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

DDL (Data Definition Lenguage) 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;

SELECTED * 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.
COMANDOS PRINCIPALES DE MYSQL.
• Crear una base de datos.
Desde el punto de vista de SQL, una base de datos es solo un conjunto de
relaciones (o tablas). A nivel del sistema operativo, cada base de datos se
guarda en un directorio diferente.
Por tanto, para crear una base de datos es una tarea muy simple. 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
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)

• Crear una tabla

CREATE TABLE

Veamos ahora la sentencia CREATE TABLE que sirve para crear tablas.
La sintaxis de esta sentencia es muy compleja, pero empezaremos con
ejemplos sencillos.
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> USE prueba
Database changed
mysql>CREATE TABLE gente (nombre VARCHAR(40), fecha DATE);
Query OK, 0 rows affected (0.53 sec)
Hemos creado una tabla llamada "gente" con dos columnas: "nombre" que
puede contener cadenas de hasta 40 caracteres y "fecha" de tipo fecha.
Al final de este documento puedes ver algunos de los tipos de datos en
MySQL.
(Pincha aquí → Diferentes tipos de dato con formato string).

• Borrar una tabla

DROP TABLE …

Para borrar una tabla usamos DROP TABLE de manera sencilla:

mysql> show tables; +-------------

----+
| Tables_in_mundo |
+-----------------+
| lista |
| naciones |
| prueba |
| telef |
+-----------------+
4 rows in set (0.00 sec)

mysql> DROP TABLE telef;

Query OK, 0 rows affected
(0.32 sec)

mysql> show tables; +-------------

----+
| Tables_in_mundo |
+-----------------+
| lista |
| naciones |
| prueba |
+-----------------+
3 rows in set (0.00 sec)
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.

• Inserción de Filas

INSERT INTO… VALUES(…);

INSERT INTO… SET…

La forma más directa de insertar una fila nueva en una tabla es mediante
una sentencia INSERT. En la forma más simple de esta sentencia debemos
indicar la tabla a la que queremos añadir filas, y los valores de cada
columna. Las columnas de tipo cadena o fechas deben estar entre comillas
sencillas o dobles, para las columnas númericas esto no es imprescindible,
aunque también pueden estar entrecomilladas.
mysql>INSERT INTO granciudad VALUES (1, 1,
“barcelona”, “barcino”, “524-1-5”);
Query OK, 1 row affected (0.07 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.

• Actualizar Filas
UPDATE … SET …
UPDATE … SET … WHERE …

Con la sentencia UPDATE podemos actualizar los valores de las filas. Los
cambios se aplicarán a las filas y columnas que especifiquemos.
mysql>UPDATE granciudad SET origen='ciudad_iberica';
Query OK, 5 rows affected (0.09
sec) Rows matched: 5 Changed: 5
Warnings: 0

mysql> SELECT * FROM granciudad;

+----+----------+----------------+------------+
| id | nombre | origen | fecha |
+----+----------+----------------+------------+
| 2 | madrid | ciudad_iberica | 1111-01-02 |
| 3 | valencia | ciudad_iberica | 3214-01-03 |
| 4 | zaragoza | ciudad_iberica | NULL |
| 5 | Bilbao | ciudad_iberica | NULL |
| 6 | malaga | ciudad_iberica | NULL |
+----+----------+----------------+------------+
5 rows in set (0.00 sec)

Como observamos, se han modificado todas las filas. Pero podemos usar
la cláusula WHERE para establecer un filtro de columnas donde queremos
que se realicen los cambios. Ejemplo:
mysql>UPDATE granciudad SET origen='caesaraugusta' WHERE nombre =
Zaragoza'; 234
Query OK, 1 row affected (0.09 sec)
Rows matched: 1 Changed: 1 Warnings: 0

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)
En este ejemplo el UPDATE solo ha afectado a la fila de Zaragoza tal y
como le hemos especificado en la cláusula WHERE.

• 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’.

• Vaciar una tabla

TRUNCATE …
Cuando queremos eliminar todas la filas de una tabla, vimos en el punto
anterior que podíamos usar una sentencia DELETE sin condiciones. Sin
embargo, existe una sentencia alternativa, TRUNCATE, que realiza la
misma tarea de una forma mucho más rápida.
La diferencia es que DELETE hace un borrado secuencial de la tabla, fila a
fila. Pero TRUCATE borra la tabla y la vuelve a crear vacía, lo que es mucho
más eficiente.

mysql>TRUNCATE granciudad;
Query OK, 0 rows affected (0.44 sec)

mysql> SELECT * FROM granciudad; Empty set (0.00 sec)

Como podemos observar hemos vaciado la tabla ‘granciudad’ de registros.

• Consultar una tabla

SELECT * FROM …
SELECT … FROM …
SELECT … AS … FROM…
SELECT DISTINCT … FROM …
SELECT … FROM … WHERE…
SELECT … FROM … WHERE … AND …
SELECT … FROM … LIMIT … , … ;

Si queremos mostrar todos los registros de una tabla usaremos SELECT *

FROM y el nombre de la tabla. Por ejemplo:

mysql>SELECT * from granciudad;

+----+-----------+-----------+
| id | nombre | poblacion |
+----+-----------+-----------+
| 1 | madrid | 4000000 |
| 30 | barcelona | 2000000 |
| 31 | valencia | 1500000 |
+----+-----------+-----------+
3 rows in set (0.00 sec)

En esta instrucción la expresión * (asterisco) significa “todas las

columnas”.
Podemos realizar una consulta donde se nos muestre solo las columnas
que nos interesa. Para ello usaremos SELECT más las columnas que
queremos separadas por coma:

mysql>SELECT id, nombre FROM granciudad;

+----+-----------+
| id | nombre |
+----+-----------+
| 1 | madrid |
| 30 | barcelona |
| 31 | valencia |
+----+-----------+
3 rows in set (0.00 sec)
• Agrupar Filas
SELECT … FROM … GROUP BY…
SELECT … COUNT(*) FROM … GROUP BY…
SELECT … COUNT(*) AS … FROM … GROUP BY…
SELECT … MAX(…) FROM … GROUP BY … HAVING MAX(…) …

Es posible agrupar filas en la salida de una sentencia SELECT según los

distintos valores de una columna, usando la cláusula GROUP BY. Esto, en
principio, puede parecer redundante, ya que podíamos hacer lo mismo
usando la opción DISTINCT. Sin embargo, la cláusula GROUP BY es más
potente.

Por ejemplo, partimos de la siguiente tabla:

mysql> CREATE TABLE muestras (

-> ciudad VARCHAR(40),
-> fecha DATE,
-> temperatura TINYINT );
Query OK, 0 rows affected (0.28 sec)

mysql> INSERT INTO muestras (ciudad,fecha,temperatura) VALUES

->('Madrid', '2005-03-17', 23),
-> ('París', '2005-03-17', 16),
-> ('Berlín', '2005-03-17', 15),
-> ('Madrid', '2005-03-18', 25),
-> ('Madrid', '2005-03-19', 24),
 -> ('Berlín', '2005-03-19', 18);
Query OK, 6 rows affected (0.08 sec)
Records: 6 Duplicates: 0 Warnings: 0

mysql> SELECT * FROM muestras;

+---------+------------+-------------+
| ciudad | fecha | temperatura |
+---------+------------+-------------+
| Madrid | 2005-03-17 | 23 |
| París | 2005-03-17 | 16 |
| Berlín | 2005-03-17 | 15 |
| Madrid | 2005-03-18 | 25 |
| Madrid | 2005-03-19 | 24 |
| Berlín | 2005-03-19 | 18 |
+---------+------------+-------------+
6 rows in set (0.00 sec)
• Claves ajenas
CREATE TABLE … ( …
FOREIGN KEY … REFERENCES …(…)
ON DELETE RESTRICT | CASCADE | SET NULL | NO ACTION | SET
DEFAULT ON UPDATE RESTRICT | CASCADE | SET NULL | NO ACTION |
SET DEFAULT ) ENGINE=InnoDB;

En MySQL solo existe soporte para claves ajenas en tablas de tipo InnoDB.
Es decir, si no creamos la tabla como “InnoDB”, las claves ajenas solo
figurarán como documentación pero no se aplicarán.
Las claves ajenas en tablas tipo “InnoDB” se define la clave ajena después
de definir todas las columnas.

Un ejemplo usando tablas InnoDB sería el siguiente:

mysql> CREATE TABLE personas (
-> id INT AUTO_INCREMENT PRIMARY KEY,
-> nombre VARCHAR(40),
-> fecha DATE)
-> ENGINE=InnoDB;
Query OK, 0 rows affected (0.13 sec)

mysql> CREATE TABLE telefonos ( ->

numero CHAR(12),
-> id INT NOT NULL,

-> KEY (id),

-> FOREIGN KEY (id) REFERENCES personas (id) -> ON DELETE CASCADE ON
UPDATE CASCADE) -> ENGINE=InnoDB; InnoDB: ENGINE ; 78
Query OK, 0 rows affected (0.13 sec) mysql>

Esta forma define una clave foránea en la columna 'id', que hace referencia
a la columna 'id' de la tabla 'personas'. La definición incluye las tareas a
realizar en el caso de que se elimine una fila en la tabla 'personas'.
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
ajena.

• 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 ajena o modificar los valores de
esas claves ajenas.

• 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 ajenas con el mismo valor.
 • NO ACTION: las claves ajenas 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 ajenas con el mismo valor.

• Operadores

MySQL dispone de varios tipos de operadores:

- operadores de asignación
- operadores lógicos
- operadores de comparaciones
- operadores aritméticos
-operadores de flujo de control
- operadores para cadenas

Los operadores se suelen usar en expresiones con cláusulas como ORDER

BY / HAVING, en cláusulas WHERE y en sentencias SET.

• Consultas multitabla

Hasta el momento hemos visto como hacer consultas en una sola tabla.
También es posible realizar consultas en varias tablas. Para ello SQL
dispone de diversas formas de hacer consultas multitabla que explicamos
a continuación.

- Composiciones internas

- Composiciones externas

Las Composiciones internas son aquellas que parten de un producto

cartesiano entre dos tablas, es decir, la combinación de todas las filas de
una tabla con las filas de la otra tabla. A partir de ese producto cartesiano
de tablas, se pueden hacer filtros o restricciones al resultado.
Las Composiciones externas no se originan de un producto cartesiano sino
que se toma un registro de una tabla y se busca registros de otra tabla que
coincidan en el atributo indicado.

INFORMACIÓN ADICIONAL - Producto Cartesiano

En matematicas, un producto cartesiano sobre 2 conjuntos es el conjunto

resultante de la combinación de todos los elementos del primer conjunto
emparejados con cada uno de los
elementos del segundo conjunto.

Imagen de un gráfico con la

Producto cartesiano de AxB

A =(3,4)

B (5,6,7)

AxB = (3,5) , (3,6) , (3,7) ,

(4,5) , (4,6) , (4,7)

• Subconsultas

SELECT … FROM … WHERE … [NOT] IN (SELECT … FROM … WHERE …)

;
SELECT … FROM … WHERE … >= ANY (SELECT … FROM … WHERE …) ;
SELECT … FROM … WHERE … >= ALL (SELECT … FROM … WHERE …) ;
SELECT … FROM … WHERE … >= (SELECT … FROM … WHERE …) ;

Una subconsulta es una consulta dentro de otra consulta (a esta segunda

la llamamos la principal). Se suelen colocar en la cláusula WHERE de la
consulta principal, pero también pueden añadirse en el SELECT o en el
FROM.

Para una subconsulta situada en la cláusula WHERE puede usarse los

operadores de comparación (> , >=, <, <=, !=, =). Cuando esto ocurre se
realiza una comparación entre el valor indicado de la consulta principal y
el valor resultante de la subconsulta. Y como es normal en las
comparaciones, ambos tipos de datos deben ser iguales.

En el modo sencillo, cuando se usa operadores de comparación, la

consulta interna (osea la subconsulta) devuelve 1 solo registro y 1 sola
columna.

Si el resultado de la subconsulta devuelve más de un registro, se usan

comandos especiales que se escriben entre el operador de comparación y
la subconsulta.

ANY : compara cada registro de la consulta principal con los de la

subconsulta. Si la comparación entre un registro de la consulta principal
con otro de la subconsulta se valida, el registro de la principal pasará el
filtro.

ALL : en este caso un registro debe validarse para todos los registros de la
subconsulta.

IN : En este caso no se usa el comparador. Se comprueba si cada registro

de la consulta principal está o no contenido en la tabla resultante de la
subconsulta.

NOT IN : lo opuesto al IN.