En la sección anterior justificamos el uso de la versión MySQL para crear bases de datos relacionales. También hicimos una intro a los comandos CREATE DATABASE, CREATE TABLE, entre otros. Ahora seguimos con restricciones de datos y más sintaxis de MySQL.
Antes de eso, revisemos comunes errores que podemos generar al codificar (según lo revisado hasta ahora) en MYSQL:
En MySQL
-- ERROR! 'create' es sintaxis para abrir base de datos (paréntesis es incorrecto)
create database Ejercicio (
-- ERROR! Primary key no va con guion bajo
-- ERROR! Lo correcto es primary key (singular)
ejer_id INT AUTO_INCREMENT PRIMARY_KEYSS,
-- ERROR! Ninguna declaración de columna termina con punto y coma, solo con coma (excepto la última declaración)
nombre varchar(10);
-- ERROR! El último elemento NO termina en coma
ciudad varchar(10),
);
-- ====== ====== ====== ======
-- LO CORRECTO ES:
create database Ejercicio;
use Ejercicio;
create table trote (
-- También es correcto declararlo separado de la columna, más abajo...
-- ...por ejemplo PRIMARY KEY (trote_id)
trote_id INT AUTO_INCREMENT PRIMARY KEY,
hora date,
lugar varchar(10)
-- PRIMARY KEY (trote_id)
);
-- Lo que se genera como diagrama será:
-- TABLA trote
-- Columnas
-- trote_id | hora | lugar
-- fila.. | fila.. | fila..
-- dato.. | dato.. | dato..
RESTRICCIONES O CONSTRAINS
Son reglas desde la sintaxis MySQL para evitar datos repetidos (Silva, 2019). Como veremos, la restricción de clave primaria (donde nunca se permitirá que ingresen dos o más datos iguales) es un concepto importante a entender.
CLAVES PRIMARIAS (PRIMARY KEYS)
¿Qué resuelven las restricciones tipo claves primarias?
Las claves primarias son atributos artificiales de cada registro (Grippa, Kuzmichev, 2021, p. 109). Son artificiales porque no son parte natural de los elementos de la tabla de datos; de hecho, las agregamos nosotros, externamente, en forma de número secuencial irrepetible.
Una clave primaria es número o dato alfanumérico único. Gracias a esa unicidad las claves primarias permiten ubicar filas de datos y así tener respuestas precisas a preguntas precisas. Sin las claves primarias, no hallaríamos la ubicación precisa de datos en un conjunto extenso de filas y tablas. Y sin las claves primarias no podríamos vincular un conjunto de datos con otro conjunto de datos.
En el ejemplo de abajo hay tres tablas desconectadas entre sí. Allí he indicado a cada clave primaria como un 'dato único' para cada fila. Por ejemplo, el número 01 de la tabla gato solo identifica a un tipo de gato. Y el número 01, pero de la tabla Nombres, solo identifica a Yumi. Cada dato único esta emparejado con su tabla y su dato.
En resumen, las tres tablas contienen información de dos gatos, su color de pelaje y sus nombres. Sin embargo, ya que las tablas no tienen algún tipo de conexión, será complicado que cada tabla nos dé por sí misma la respuesta a cada una de estas preguntas:

Como vemos, cada tabla contiene un dato único para cada fila de información. Por ejemplo, en la tabla 'gato' el dato único 01 corresponde solo y únicamente a un gato. Y en la tabla 'nombres', el dato único 02 corresponde solo y únicamente al nombre Lola. En bases de datos relacionales, a ese dato único le llamaremos claves primarias, o primary keys.
Esa desconexión entre tablas no permite que las respuestas a esas preguntas sean precisas. Por lo que necesitamos de las claves foráneas.
Las claves foráneas son claves primarias que inician en una tabla padre y son insertadas en una nueva tabla hija, con el objetivo de que ambas tablas se alimenten de la información que cada una tiene por separado. Es decir, las claves foráneas o externas conectan tablas entre sí .

Finalmente, en la imagen 2 se aprecia que juntar (o conectar) los datos primarios de cada tabla permite ahora sí vincular los datos y obtener respuestas más precisas a las preguntas.
En resumen, conectar tablas mediante claves primarias y claves foráneas es similar a juntar todas las tablas en forma horizontal. Con el sencillo ejemplo de arriba fue posible juntarlas o conectarlas. ¿Qué sucedería si habría una cantidad mayor de tablas? cien o mil?. Es por eso que las bases de datos y las claves primarias existen.
Restricciones: Primary Key (PK) o clave primaria (CP)
El primary key (PK, en siglas en inglés, o clave primaria en español) es una restricción adjuntada a cada declaración de dato de cada columna dentro de una tabla. El primary key evita que ingresen datos repetidos a las columnas con esa restricción. Invocar el primary key en una columna otorga un índice único para cada dato de fila, muy similar a lo que es el índice de páginas para un libro cualquiera, donde nunca habrá una página con un número de página repetido.
Es decir, la restricción primary key indica qué columna rechazará todo dato repetido ingresado, incluso alertará de que una celda no ha sido llenada. A ese criterio (permitir o no datos y alertar del tipo de dato incorrecto) se lo conoce como integridad de datos (Silva, 2019, p. 43).
El emoji ✏️ indica la nueva porción de código, añadido en el ejemplo:
En SQL
CREATE DATABASE rock_Guayaco;
-- Insertar tabla en esta base de datos
USE rock_Guayaco;
-- Esta será una tabla (con un nombre único) pero vacía
CREATE TABLE Bandas (
-- Columna, Identificador único: tipo dato INT (entero), auto incrementado
bandas_id int,
-- Columna, tipo de dato varchar con máximo 20 caracteres
nombre varchar(20),
-- Columna, tipo de dato varchar con máximo 20 caracteres
ciudad varchar(15),
-- ✏️ Solo la columna bandas_id tendrá valores irrepetibles
-- ✏️ Es decir, solo la columna aceptará números en secuencia pero irrepetibles y por cada fila creada.
primary key (bandas_id)
-- ✏️ Pero si deseamos que dos columnas eviten aceptar datos repetidos, solo debemos reemplazar la línea anterior con esta:
-- primary key (bandas_id, nombre)
);
Alerta: El diseño estándart de una base de datos simplifica (por convención) su estructura con un diagrama similar a la Imagen 1, abajo.
Sin embargo, allí las columnass bandas_id, nombre y ciudad están mostradas como filas. Eso generaría confusión. En realidad, bandas_id, nombre y ciudad son columnas cuyas filas receptarán datos.
Estructura
ESTRUCTURA TABLA_BANDAS
COLUMNAS
bandas_id | nombre | ciudad
Fila --> Datos... | Datos... | Datos...
Fila --> Datos... | Datos... | Datos...
... | ... | ...

¿Cómo añadimos (en la tabla Bandas) otra clave primaria a otra columna, cuando ya hemos creado solo una clave primaria en la columna bandas_ID? Primero debemos borrar la anterior clave primaria; y finalmente con el comando ALTER TABLE, insertar las claves primarias a las columnas que deseamos:
En MySQL
-- PK: Primary Key o clave primaria
-- A) Alterar la tabla Bandas, borrando su PK
ALTER TABLE Bandas DROP PRIMARY KEY;
-- B) Alterar la tabla Bandas añadiendo como PK las columnas bandas_id y nombre
ALTER TABLE Bandas ADD PRIMARY KEY (bandas_id, nombre);

Entonces, ¿Cómo determinamos que una columna deba tener Primary Keys?; o lo que es lo mismo, ¿Con qué criterios damos por hecho que una columna nunca deba aceptar datos repetidos?.
Una o más columnas podrán ser candidatas a Primary Key cuando:
- En esa columna deseamos evitar datos repetidos, o celdas sin datos (o nulos).
- En esa columna los datos nunca serán alterados a lo largo del tiempo
- En esa columna los datos nunca se ingresarán repetidos. Una tabla de Nombres y otra de Apellidos podría tener más de un 'Julio' y más de un 'Jaramillo'; y una tabla de Edad podría tener más de una persona con 50 años de edad. Por lo que habría de considerar si esas tablas deberían ser Primary Key.
- En esa columna deseamos una secuencia numérica que funcione como una índice que permita ubicar un solo dato exclusivo.
Restricciones: Foreign Keys (FK) o claves foráneas o externas (CF)
Alerta con el singular de la oración claves foráneas. Eso nos permite entender que 'claves foráneas' quiere decir conjunto de claves que vinculan dos tablas. Paso a explicar eso.
¿Qué contienen las claves foráneas? Contienen las claves primarias de una primera tabla (tabla padre), que a su vez serán vinculadas (esas claves foráneas) a una siguiente tabla (tabla hija), con el objetivo de vincular datos.
Es por eso que decimos que hay relación entre dos tablas gracias a las claves foráneas, pues estas alimentan a la otra con datos (coherentes, relacionados). Recordemos: las claves primarias se activan cuando en una columna nunca serán aceptados datos duplicados o repetidos. Por ejemplo, una columna que recibirá los datos del número de cédula de cada guayaquileño tendrá activada la restricción de Primary Key (clave primaria).

En decir, en sintaxis MySQL el código para activar la base de datos, las tablas y las columnas (pero aún sin insertar datos) y según el diagrama de la imagen 3, la sintaxis se vería asi:
En SQL
CREATE DATABASE rock_Guayaco;
-- Insertar tabla en esta base de datos
USE rock_Guayaco;
-- Para crear tablas foráneas entre dos tablas
-- Crear la tabla padre Bandas con una clave primaria
CREATE TABLE Bandas (
-- Columna bandas_id
-- Decimos que acepta dato INT, autoincremental y PK
-- Ojo tenemos que identificar SOLO EL NOMBRE de esta columna PK
bandas_id INT AUTO_INCREMENT PRIMARY KEY,
-- Columna nombre
-- Acepta dato varchar de hasta 20 caracteres
nombre VARCHAR(20),
-- Columna ciudad
-- Acepta dato varchar de hasta 15 caracteres
ciudad VARCHAR(15)
);
-- Crear la tabla hija Albums con una clave foránea que referencia a Bandas
CREATE TABLE Albums (
album_id INT AUTO_INCREMENT PRIMARY KEY,
-- NOT NULL: No acepta celda vacia
titulo VARCHAR(50) NOT NULL,
bandas_id INT,
-- Activa clave foránea
-- Dice: columna bandas_id de ESTA tabla Albums conecta con tabla Bandas y con columna bandas_id.
FOREIGN KEY (bandas_id) REFERENCES Bandas (bandas_id)
-- Si se elimina un registro en la tabla Bandas, también se eliminarán automáticamente los registros relacionados en Albums.
ON DELETE CASCADE
-- Si se actualiza el valor de la clave primaria en Bandas, los valores correspondientes en Albums se actualizarán automáticamente.
ON UPDATE CASCADE
);
Verbalizando la línea de código FOREIGN KEY (bandas_id) REFERENCES Bandas (bandas_id)
que genera la columna de claves foráneas en la tabla hijo, podemos expresarlo así:
- Inicio
- Desde la tabla hijo 'Albums'...
- ...habiendo declarado en la tabla hija 'Albums' una columna con idéntico nombre de la clave primaria de la tabla padre 'Bandas'...
- ...será Foreign key la columna 'bandas_id' de la tabla hijo 'Albums'...
- ...vinculada a la tabla padre 'Bandas, conectada a la columna de clave primaria 'bandas_id'
- Fin

Cada única tabla puede tener solo una columna de claves primarias. Pero esa misma tabla puede tener varias claves foráneas. (Es sencillo armar tablas con la app web drawsql)

El gráfico de arriba es necesario para entender el concepto de claves foráneas. Pero su utilidad será comprensible cuando ya insertemos datos en las columnas. Las consecuencias de vincular una columna clave (de valores nunca repetidos) desde una tabla padre a una tabla hijo las veremos dentro de poco.
Adelanto aquí un par de conceptos: Ya vimos que el objetivo de una ordenada base de datos y su tablas es evitar datos inconexos o incompletos. A ese buen criterio se lo llama integridad de datos. Por otro lado, a la correcta y lógica vinculación entre tablas se la conoce como integridad referencial. Esta sirve, por ejemplo, para acceder desde una sola consulta a datos contenidos en más de una tabla (Silva, Silva, p. 47).
Recordemos que por ahora nuestras filas no cuentan con datos. Apenas hemos creado tablas, indicado tipos de datos, agregados restricciones. Pero nada más. Ahora veremos una acción importante: la de insertar datos en columnas de tablas.
INSERTAR DATOS A COLUMNAS CON INSERT INTO ... VALUES (..., ...)
Una vez definidas nuestras tablas con sus nombres identificadores y sus tipos de datos, insertaremos datos según corresponda al tipo de columna y al tipo de dato. Es decir, si una columna es de tipo varchar (dato caracter), no podremos insertar números, etc.
Luego de haber declarado la tabla y sus columnas, la sintaxis básica para insertarle datos es la siguiente:
En MySQL
INSERT INTO nombreTABLA1 VALUES ('dato', 'dato', 'dato');
INSERT INTO nombreTABLA2 VALUES ('dato', 'dato', 'dato');
En sintaxis MySQL es:
En MySQL
create database colores;
use colores;
create table frios (
-- Solo tiene clave primaria
frio_id INT AUTO_INCREMENT PRIMARY KEY,
-- Solo un nombre
nombre_frio varchar(10)
);
create table calientes (
-- Solo tiene clave primaria
caliente_id INT AUTO_INCREMENT PRIMARY KEY,
-- Solo un nombre
nombre_caliente varchar(10)
);
-- Llenar filas en tabla frios
INSERT INTO frios VALUES ('01', 'celeste');
INSERT INTO frios VALUES ('02', 'azul');
-- Llenar filas en tabla calientes
INSERT INTO calientes VALUES ('001', 'amarillo');
INSERT INTO calientes VALUES ('002', 'verde');
En la siguiente sección se revisará sintaxis de recuperación de datos y otras sintaxis.
BIBLIOGRAFÍA
Vinicius M. Grippa, Sergey Kuzmichev (2021). Learning MySQL, 2da. ed.Beaulieu, Alan (2019). Learning SQL, 3ra Ed., O’Reilly Media.
Silva, Rick (2019). MYSQL CRASH COURSE, A Hands-on Introduction to Database Development. No Starch Press, Inc.
IBM Informix (2021). Standard SQL. Informix® 12.10.