Bases de datos Relacionales MySQL

MANUAL DE COMANDOS
para MySQL

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

mínima sobre las Bases de Datos Relacionales”
Bases de datos Relacionales MySQL

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.
Bases de datos Relacionales MySQL

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
Bases de datos Relacionales MySQL

Crear una tabla

CREATE TABLE …
SHOW TABLES;

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.

Podemos consultar cuántas tablas y qué nombres tienen en una base de datos, usando la
sentencia SHOW TABLES:

mysql>SHOW TABLES;
+------------------+

| Tables_in_prueba |
+------------------+
| gente |
+------------------+
1 row in set (0.01 sec)

Además del tipo y el nombre, podemos definir valores por defecto, permitir o no que
contengan valores nulos, crear una clave primaria, indexar...
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]

Veamos cada una de las opciones por separado…

Bases de datos Relacionales MySQL

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)
Bases de datos Relacionales MySQL

Claves Primarias
… PRIMARY KEY…

Para claves primarias tambié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.
Bases de datos Relacionales MySQL

Claves Primarias Compuestas

… PRIMARY KEY (clave1, clave2, ….)

Las claves primarias compuestas se usan cuando no hay ningún atributo en la tabla que identifique
cada registro de manera única. Es posible que un conjunto de atributos pueda identificar cada registro
de manera única, en estos casos utilizamos claves primarias compuestas.

En MySQL para establecer que una tabla tenga una clave compuesta, lo indicamos al final del create
table:

mysql>mysql> create table ButacaCine (

-> sala int not null,
-> num_butaca int not null,
-> color varchar(50),
-> primary key(sala, num_butaca)
-> );

Query OK, 0 rows affected (0.11 sec)

mysql> describe ButacaCine;

+-----------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------------+-------------+------+-----+---------+-------+
| sala | int(11) | NO | PRI | NULL | |
| num_butaca | int(11) | NO | PRI | NULL | |
| nombre_pelicula | varchar(50) | YES | | NULL | |
+-----------------+-------------+------+-----+---------+-------+
3 rows in set (0.04 sec)

En este ejemplo formamos la clave primaria con el número de sala y el número de butaca para
identificar un asiento concreto en un cine.

En las claves primarias, solo 1 de las columnas puede tener la propiedad auto_increment.
Bases de datos Relacionales MySQL

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)
Bases de datos Relacionales MySQL

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 ciudad6

-> (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)
Bases de datos Relacionales MySQL

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)
Bases de datos Relacionales MySQL

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
Bases de datos Relacionales MySQL
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)
Bases de datos Relacionales MySQL

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)

Introducir más de una fila a la vez:

mysql>INSERT INTO granciudad VALUES

→ (1, 1, “barcelona”, “barcino”, “524-1-5”),
→(2,2, “madrid”, “madrilus”, 1210-3-4”);
Query OK, 2 rows affected (0.09 sec)
Records: 2 Duplicates: 0 Warnings: 0

También es posible especificar la lista de columnas/atributos donde deseamos ingresar ciertos

valores. La ventaja de esta forma es que no precisamos de conocer el orden exacto de los atributos
en la tabla:

mysql>INSERT INTO granciudad (id, nombre) VALUES (4, "zaragoza");

Query OK, 1 row affected (0.13 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 |
+------+------+-----------+----------+------------+
4 rows in set (0.00 sec)
Bases de datos Relacionales MySQL

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)
Bases de datos Relacionales MySQL

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.
Bases de datos Relacionales MySQL

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';
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.
Bases de datos Relacionales MySQL

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’
Bases de datos Relacionales MySQL

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’.
Bases de datos Relacionales MySQL

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.

Bases de datos Relacionales MySQL

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)
Bases de datos Relacionales MySQL

También podemos operar con los valores de una columna, por ejemplo si queremos que nos
devuelvan la población en miles pondríamos lo siguiente:

mysql>SELECT nombre, poblacion/1000000 FROM granciudad;

+-----------+-------------------+
| nombre | poblacion/1000000 |
+-----------+-------------------+
| madrid | 4.0000 |
| barcelona | 2.0000 |
| valencia | 1.5000 |
+-----------+-------------------+
3 rows in set (0.00 sec)

Recuerda que la información en la tabla no se modifica. Lo único que pedimos es mostrar un valor
calculado a partir de la información de la tabla.

También podríamos mostrar la misma información pero cambiando el encabezado de la columna

afectada con el comando AS:

SELECT nombre, poblacion/1000000 AS poblacion_en_millones FROM

granciudad;
+-----------+-----------------------+
| nombre | poblacion_en_millones |
+-----------+-----------------------+
| madrid | 4.0000 |
| barcelona | 2.0000 |
| valencia | 1.5000 |
+-----------+-----------------------+
3 rows in set (0.02 sec)

Puedes conocer todos las funciones numéricas en MySQL con el comando:

mysql>HELP NUMERIC FUNCTIONS

O de cualquier tipo de función con:

mysql>HELP FUNCTIONS
Bases de datos Relacionales MySQL

En una consulta podría haber registros repetidos, si quisiéramos evitar mostrar las filas repetidas
usaríamos el comando DISTINCT.

Por ejemplo, imaginemos que en la tabla anterior insertamos otro registro que también se llame
madrid, tenga 4 millones de habitantes aunque su id sea otro.

Si consultamos la tabla mostrando los campos nombre y población podremos observar 2 filas
idénticas:

mysql> SELECT nombre, poblacion FROM granciudad;

+-----------+-----------+
| nombre | poblacion |
+-----------+-----------+
| madrid | 4000000 |
| barcelona | 2000000 |
| valencia | 1500000 |
| madrid | 4000000 |
+-----------+-----------+
4 rows in set (0.00 sec)

Sin embargo, si usamos DISTINCT solo se nos mostrarán las líneas no repetidas:

idénticas:

mysql>SELECT DISTINCT nombre, poblacion FROM granciudad;

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

Recuerda que aunque se muestren 3 registros, en la tabla hay 4 registros dado que “Madrid
4000000” está repetido.
Bases de datos Relacionales MySQL

Si queremos filtrar las filas que aparecen en la consulta podemos usar la sentencia WHERE, por
ejemplo, partiendo de la tabla siguiente, queremos mostrar solo las ciudades que tienen 2 o más
millones de población:

mysql>SELECT * from granciudad;

+----+-----------+-----------+
| id | nombre | poblacion |
+----+-----------+-----------+
| 1 | madrid | 4000000 |
| 30 | barcelona | 2000000 |
| 31 | valencia | 1500000 |
| 3 | sevilla | 1000000 |
+----+-----------+-----------+
4 rows in set (0.00 sec)
mysql>SELECT * from granciudad WHERE poblacion >= 2000000;
+----+-----------+-----------+
| id | nombre | poblacion |
+----+-----------+-----------+
| 1 | madrid | 4000000 |
| 30 | barcelona | 2000000 |
+----+-----------+-----------+
2 rows in set (0.00 sec)

Incluso anidar 2 condiciones usando el comando AND:

mysql>SELECT * from granciudad WHERE poblacion >= 2000000 AND id > 10;
+----+-----------+-----------+
| id | nombre | poblacion |
+----+-----------+-----------+
| 30 | barcelona | 2000000 |
+----+-----------+-----------+
1 row in set (0.03 sec)

Además de AND, podríamos usar otros operadores boobleanos como OR, XOR o NOT

Recuerda que puedes ver e informarte sobre los operadores booleanos disponibles con el comando:
HELP LOGICAL OPERATORS

En una cláusula WHERE se puede usar cualquier función disponible en MySQL, excluyendo sólo
las de resumen o reunión, que veremos en el siguiente punto. Esas funciones están diseñadas
específicamente para usarse en cláusulas GROUP BY.
Bases de datos Relacionales MySQL

La cláusula LIMIT puede usarse con 2 parámetros. Cuando se usan ambos, el primero muestra
la fila a partir de la que debemos empezar a mostrar registros, y el segundo parámetro muestra
el número de filas a mostrar (contando desde la primera):

mysql> select * from lista;

+------+---------+
| id | nombre |
+------+---------+
| 1 | paco |
| 2 | alfonso |
| 3 | Ana |
| 4 | yasmina |
| 5 | Babet |
+------+---------+
5 rows in set (0.00 sec)

mysql> select * from lista limit 1,2;

+------+---------+
| id | nombre |
+------+---------+
| 2 | alfonso |
| 3 | Ana |
+------+---------+
2 rows in set (0.00 sec)

mysql> select * from lista limit 2,2;

+------+---------+
| id | nombre |
+------+---------+
| 3 | Ana |
| 4 | yasmina |
+------+---------+
2 rows in set (0.00 sec)
Bases de datos Relacionales MySQL

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)
Bases de datos Relacionales MySQL

Podríamos agrupar el resultado de la consulta con el comando GROUP BY de modo que nos
agrupara los registros de la tabla por ciudades:

mysql>SELECT ciudad FROM muestras GROUP BY ciudad;

+---------+
| ciudad |
+---------+
| Berlín |
| Madrid |
| París |
+---------+
3 rows in set (0.00 sec)

Observamos que con GROUP BY la salida se ordena según los valores de la columna indicada. En
este caso se ordenan alfabéticamente por el atributo ”nombre”.

Pero la diferencia principal es que el uso de la cláusula GROUP BY permite usar funciones de
resumen o reunión. Por ejemplo, la función COUNT(),que sirve para contar las filas de cada
grupo:

mysql>SELECT ciudad, COUNT(*) AS cuenta FROM muestras GROUP BY ciudad;

+---------+--------+
| ciudad | cuenta |
+---------+--------+
| Berlín | 2 |
| Madrid | 3 |
| París | 1 |
+---------+--------+
3 rows in set (0.05 sec)

El asterisco de COUNT(*) significa TODAS las filas. Si indicase el nombre de un atributo contaría el
número de registros que no son NULL en ese mismo atributo.

Además de COUNT disponemos de otros operadores como: AVG(), COUNT_DISTINCT(), MAX(),

MIN(), STD(), SUM(), VARIANCE(), …

Al final de este documento hay un anexo con la explicación de los distintos comandos asociados a
GROUP BY.

En cualquier caso, para conocer e informarte de todos los operadores de GROUP BY puedes
consultar aquí:
mysql>HELP Functions and Modifiers for Use with GROUP BY
Bases de datos Relacionales MySQL

La cláusula HAVING() permite hacer selecciones con GROUP BY en columnas calculadas

con funciones de grupo, como MAX(), MIN(),AVG(),COUNT()… Se podría entender como un
WHERE para usar junto a GROUP BY()
Veamos un ejemplo:

mysql> CREATE TABLE muestras (

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

mysql> 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.03 sec)
Records: 6 Duplicates: 0 Warnings: 0

mysql> SELECT ciudad, MAX(temperatura) FROM muestras

-> GROUP BY ciudad HAVING MAX(temperatura)>16;
+--------+------------------+
| ciudad | MAX(temperatura) |
+--------+------------------+
| Berlín | 18 |
| Madrid | 25 |
+--------+------------------+
2 rows in set (0.00 sec)

mysql>
Bases de datos Relacionales MySQL

ANEXO
Por medio del comando “help” de la terminal de MySQL se pueden consultar toda la
información sobre la sintaxis y uso de los comandos MySQL, tales como tipos de
datos, funciones, operadores, seleccionadores, etcétera

Para ver todos los comandos del 'help' de su terminal escriba:

“HELP contents”

No obstante en este anexo exponemos algunos de ellos.

Tipos de dato en una base de datos MySQL

Al crear una tabla la elección correcta de un formato de dato para cada columna de la tabla
hará que nuestra BBDD tenga un rendimiento óptimo a medio largo plazo.
Podemos dividir en 3 grandes grupos estos datos:
• Numéricos
• Fecha
• String
Bases de datos Relacionales MySQL

Tipos de dato numéricos

Tipos de dato numéricos en MySQL, su ocupación en disco y valores:

INT (INTEGER): Ocupación de 4 bytes con valores entre -2147483648 y

2147483647 o entre 0 y 4294967295.
• SMALLINT: Ocupación de 2 bytes con valores entre -32768 y 32767 o entre 0 y
65535.
• TINYINT: Ocupación de 1 bytes con valores entre -128 y 127 o entre 0 y 255.
• MEDIUMINT: Ocupación de 3 bytes con valores entre -8388608 y 8388607 o
entre 0 y 16777215.
• BIGINT: Ocupación de 8 bytes con valores entre -8388608 y 8388607 o entre 0 y
16777215.
• DECIMAL (NUMERIC): Almacena los números de coma flotante como cadenas o
string.
• FLOAT (m,d): Almacena números de coma flotante, donde ‘m’ es el número de
dígitos de la parte entera y ‘d’ el número de decimales.
• DOUBLE (REAL): Almacena número de coma flotante con precisión doble. Igual
que FLOAT, la diferencia es el rango de valores posibles.
• BIT (BOOL, BOOLEAN): Número entero con valor 0 o 1.
Bases de datos Relacionales MySQL

Tipos de dato con formato fecha

Listado de cada uno de los tipos de dato con formato fecha en MySQL, su ocupación en
disco y valores:

• DATE: Válido para almacenar una fecha con año, mes y día, su rango oscila entre
‘1000-01-01′ y ‘9999-12-31′.
• DATETIME: Almacena una fecha (año-mes-día) y una hora (horas-minutos-
segundos), su rango oscila entre ‘1000-01-01 00:00:00′ y ‘9999-12-31 23:59:59′.
• TIME: Válido para almacenar una hora (horas-minutos-segundos). Su rango de
horas oscila entre -838-59-59 y 838-59-59. El formato almacenado es ‘HH:MM:SS’.
• TIMESTAMP: Almacena una fecha y hora UTC. El rango de valores oscila entre
‘1970-01-01 00:00:01′ y ‘2038-01-19 03:14:07′.
• YEAR: Almacena un año dado con 2 o 4 dígitos de longitud, por defecto son 4. El
rango de valores oscila entre 1901 y 2155 con 4 dígitos. Mientras que con 2 dígitos el
rango es desde 1970 a 2069 (70-69).
Bases de datos Relacionales MySQL

Diferentes tipos de dato con formato string

Listado de cada uno de los tipos de dato con formato string en MySQL, su ocupación en
disco y valores:

• CHAR: Ocupación fija cuya longitud comprende de 1 a 255 caracteres.

• VARCHAR: Ocupación variable cuya longitud comprende de 1 a 255 caracteres.
• TINYBLOB: Una longitud máxima de 255 caracteres. Válido para objetos binarios
como son un fichero de texto, imágenes, ficheros de audio o vídeo. No distingue entre
minúculas y mayúsculas.
• BLOB: Una longitud máxima de 65.535 caracteres. Válido para objetos binarios
como son un fichero de texto, imágenes, ficheros de audio o vídeo. No distingue entre
minúculas y mayúsculas.
• MEDIUMBLOB: Una longitud máxima de 16.777.215 caracteres. Válido para
objetos binarios como son un fichero de texto, imágenes, ficheros de audio o vídeo.
No distingue entre minúculas y mayúsculas.
• LONGBLOB: Una longitud máxima de 4.294.967.298 caracteres. Válido para
objetos binarios como son un fichero de texto, imágenes, ficheros de audio o vídeo.
No distingue entre minúculas y mayúsculas.
• SET: Almacena 0, uno o varios valores una lista con un máximo de 64 posibles
valores.
• ENUM: Igual que SET pero solo puede almacenar un valor.
• TINYTEXT: Una longitud máxima de 255 caracteres. Sirve para almecenar texto
plano sin formato. Distingue entre minúculas y mayúsculas.
• TEXT:Una longitud máxima de 65.535 caracteres. Sirve para almecenar texto plano
sin formato. Distingue entre minúculas y mayúsculas.
• MEDIUMTEXT:Una longitud máxima de 16.777.215 caracteres. Sirve para
almecenar texto plano sin formato. Distingue entre minúculas y mayúsculas.
• LONGTEXT: Una longitud máxima de 4.294.967.298 caracteres. Sirve para
almecenar texto plano sin formato. Distingue entre minúculas y mayúsculas.
Bases de datos Relacionales MySQL

FUNCIONES DE GRUPOS
Listado de cada uno de los tipos de funciones que se pueden usar con GROUP BY:

• COUNT: Devuelve el número de valores distintos de NULL en las filas recuperadas por
una sentencia SELECT
• AVG: Devuelve el valor medio
• BIT_AND: Devuelve la operación de bits AND: para todos los bits de una expresión
• BIT_OR: Devuelve la operación de bits OR: para todos los bits de una expresión
• BIT_XOR: Devuelve la operación de bits XOR: para todos los bits de una expresión
• COUNT DISTINCT: Devuelve el número de valores diferentes, distintos de NULL
• GROUP_CONCAT: Devuelve una cadena con la concatenación de los valores de un
grupo
• MIN: Devuelve el valor mínimo de una expresión
• MAX: Devuelve el valor máximo de una expresión
• STD: o STDDEV Devuelve la desviación estándar de una expresión
• SUM: Devuelve la suma de una expresión
• VARIANCE: Devuelve la varianza estándar de una expresión