Lenguaje Estructurado de Consultas

El lenguaje SQL (Structured Query Language) permite la comunicación con el SGBD. Actualmente es el lenguaje estándar para la gestión de Bases de Datos relacionales para ANSI (American National Standard Institute) e ISO (International Standarization Organization). Entre las principales características de este lenguaje destaca que es un lenguaje para todo tipo de usuarios ya que quién lo utiliza especifica qué quiere, pero no dónde ni cómo, de manera que permite realizar cualquier consulta de datos por muy complicada que parezca.

En el lenguaje SQL, dependiendo de las tareas que se quieran realizar, se distinguen dos tipos de sentencias. Sentencias DDL (Data Definition Language) que sirven para especificar y gestionar estructuras de datos, y las sentencias DML (Data Manipulation Language) que sirven para trabajar con los datos almacenados en dichas estructuras.

Puesto que por ahora abordaremos aquellas sentencias que nos van a permitir crear nuestras Bases de Datos en un SGBD relacional, comenzaremos por ver el grupo de sentencias DDL, que son las que se citan en este bloque:

• CREATE: crear una base de datos y sus objetos(tablas, índices, vistas, procedimiento, funciones y triggers)
• ALTER: modificar la estructura de los objetos de una base de datos
• DROP: eliminar objetos de una base de datos
• RENAME: renombrar objetos de una base de datos

Son las sentencias con las que trabajabamos con los datos de una base de datos. Se trabajan a fondo en el siguiente bloque y se pueden resumir en:

• INSERT INTO: inserción de registros
• UPDATE: modificación de datos
• DELETE: eliminación de registros
• SELECT: consulta de datos y registros

MySQL es un SGBD desarrollado bajo una licencia dual: GPL y Licencia Comercial. Esto se debe a que en 2009 MySQL SGBD de código abierto fue adquirido por la empresa Oracle. Actualmente Oracle distribuye MySQL Community con licencia pública GPL, y otras versiones Enterprise para empresa que lo quieran incorporar en proyectos propietarios.

Además los creadores originales de MySQL, han continuado su desarrollo bajo el nombre MariaDB teniendo una compatibilidad casi completa con MySQL pero incluyendo nuevos desarrollos.

Por lo tanto podemos trabajar con MySQL o MariaDB indistintamente.

Xampp es un paquete de software libre multiplataforma que agrupa una serie de servidores, permitiendo su manejo de una forma sencilla y sin que requiera grandes configuraciones. Este paquete incluye:

• Apache: servidor web
• Mysql/MariaDB: servidor de bases de datos y SGBD
• Php: lenguaje web de servidor
• Perl: lenguaje de programación

Desde la versión 5.6, xampp incluye MariaDB en lugar de MySQL debido a la adquisición de este último por parte de Oracle.

Xampp ofrece un panel de control de fácil manejo con el que controlamos el arranque de todos los servidores.

MySQL funciona únicamente bajo la arquitectura cliente-servidor. Esto quiero decir que una vez iniciado MySQL la única forma de gestionarlo es realizando una conexión desde un cliente. Para ello necesitamos unos datos de conexion, principalmente 4:

• Dirección IP del servidor: si trabajamos en local, indicaremos localhost o 127.0.0.1
• Puerto de conexión: el puerto habitual de funcionamiento de MySQL es 3306
• Usuario: siempre necesitamos un usuario para conectarnos. Para pruebas podemos usar root
• Contraseña: como xampp ofrece servidores para entorno de pruebas el usuario root no tiene contraseña

Como hemos comentado en el punto anterior, para trabajar con MySQL necesitamos realizar una conexión a su servidor desde un cliente. Aparte del cliente de línea de comandos que incluye cualquier distribución de MySQL, podemos usar cualquiera de los dos más utilizados: phpMyAdmin y MySQL Workbench.

Es un cliente web, por lo tanto funciona a través de un servidor web. El paquete xampp lo incluye por defecto, y podemos acceder a él arrancando el servidor web apache incluido en el paquete, y accediendo a la url: localhost/phpmyadmin.

Es un cliente para MySQL desarrollado por Oracle, aunque también nos permite conectarnos al SGBD MariaDB. Podemos descargar la versión Community desde el sitio oficial.

Es un cliente para MySQL/MariaDB de código abierto que permite gestionar nuestro servidor de bases de datos. Podemos descargarlo desde la sección de software necesario de esta wiki.

Cuando trabajamos en sistemas que no disponen de interfaz gráfica de usuario, por ejemplo, cuando nos conectamos desde un terminal de comandos remoto, podemos usar el cliente mysql. A continuación vemos las operaciones principales para poder conectarnos:

# Conectarnos al servidor Mysql
mysql -u miusuario -p micontrasena

# Mostrar las bases de datos del servidor
SHOW DATABASES;

# Crear una base de datos
CREATE DATABASE mi_Base_Datos;

# Conectarse a una base de datos
USE mi_Base_Datos;

# Mostrar las tablas de mi base de datos
SHOW TABLES;

# Mostrar las propiedades de una tabla
DESCRIBE mi_tabla;

A continuación se indica cómo realizar un diseño físico de la estructura de las bases de datos en MySQL/MariaDB.

En el lenguaje SQL, dependiendo de las tareas que se quieran realizar, se distinguen dos tipos de sentencias. Sentencias DDL (Data Definition Language) que sirven para especificar y gestionar estructuras de datos, y las sentencias DML (Data Manipulation Language) que sirven para trabajar con los datos almacenados en dichas estructuras.

Puesto que por ahora abordaremos aquellas sentencias que nos van a permitir crear nuestras Bases de Datos en un SGBD relacional, comenzaremos por ver el grupo de sentencias DDL, que son las que se citan a continuación:

Es la sentencia utilizada para la creación de un objeto (base de datos, tabla, usuario, vista, procedimiento, . . .) en una Base de Datos.

Para crear una Base de Datos:

CREATE DATABASE [IF NOT EXISTS] <nombre_base_de_datos>

Para crear una Tabla:

CREATE TABLE [IF NOT EXISTS] <nombre_tabla>
(
   <nombre_columna1>  <tipo_dato>  <restricciones>,
   <nombre_columna2>  <tipo_dato>  <restricciones>,
   ................................
)

Para crear tablas o cualquier otro elemento en una base de datos ya creada, es necesario conectarse a ella primero:

    USE <nombre_base_de_datos>

Ejemplo completo:

-- Crear una base de datos
CREATE DATABASE colegio;
 
-- Conectarse a la base de datos
USE colegio;
 
-- Crear una tabla
CREATE TABLE asignaturas(
   id INT PRIMARY KEY,
   nombre VARCHAR(20),
   departamento VARCHAR(20),
   id_curso INT,
   FOREIGN KEY (id_curso) REFERENCES cursos(id)
);

Es la sentencia utilizada para eliminar objetos (tabla, usuario, vista, procedimiento, . . .) en una Base de Datos.

La sintaxis para la eliminación de tablas es la siguiente:

DROP TABLE [IF EXISTS] <nombre_tabla>

Y para eliminar una Base de Datos:

DROP DATABASE [IF EXISTS] <nombre_base_de_datos>

Es la sentencia utilizada para modificar objetos (tabla, usuario, vista, procedimiento, . . .) en una Base de Datos.

La sintaxis para modificar una tabla es la siguiente:

    ALTER TABLE <nombre_tabla>
        [ ADD <definicion_columna> ]
        [ MODIFY <nombre_columna> <definicion_columna> ]
        [ DROP COLUMN <nombre_columna> ]
        [ ADD CONSTRAINT <restriccion> ]
        [ CHANGE <nombre_columna> <nuevo_nombre> <definicion_nueva_columna>]
        [ AUTO_INCREMENT = <valor> ]

Ejemplos:

-- Añadir o eliminar columna
ALTER TABLE alumnos ADD COLUMN edad INT DEFAULT 18;
ALTER TABLE alumnos DROP COLUMN edad;
 
-- Modifica la definición de la columna
ALTER TABLE alumnos MODIFY nombre VARCHAR(30) NOT NULL;
-- Modifica el nombre y la definición de la columna
ALTER TABLE alumnos CHANGE nombre nick VARCHAR(30) NOT NULL;
 
-- Añadir o quitar claves primarias o ajenas
ALTER TABLE alumnos ADD PRIMARY KEY(id);
ALTER TABLE alumnos DROP PRIMARY KEY;
 
ALTER TABLE alumnos ADD FOREIGN KEY (id_curso) REFERENCES cursos(id);
-- Igual a la anterior pero indicando el nombre de la restricción
ALTER TABLE alumnos ADD CONSTRAINT nombre_fk_1 FOREIGN KEY (id_curso) REFERENCES cursos(id);
ALTER TABLE alumnos DROP FOREIGN KEY nombre_fk;
 
-- Renombar tabla
ALTER TABLE alumnos RENAME estudiantes;

En la documentación oficial tenemos más ejemplos de uso.

Este tipo de datos permite almacenar cadenas de texto fijas (CHAR) o variables (VARCHAR).

El tipo CHAR permite almacenar cadenas de caracteres de longitud fija entre 1 y 255 caracteres. La longitud de la cadena se debe especificar entre paréntesis en el momento de la declaración (cadena CHAR(25)).

Por otro lado, el tipo VARCHAR permite almacenar cadenas de caracteres variables. La declaración del tipo VARCHAR es similar a la de un tipo CHAR (cadena VARCHAR(25)). La principal y única diferencia entre estos dos tipos, es que el tipo CHAR declara una cadena fija de la longitud que se especifica mientras que en la declaración de un tipo VARCHAR lo que se especifica es un tamaño máximo, la cadena sólo ocupará el tamaño necesario para almacenar el dato que contenga (hasta llegar al máximo). En cualquier caso, no es posible almacenar cadenas de mayor tamaño al especificado en su declaración, puesto que el SGBD truncará el valor almacenándose sólo hasta la longitud establecida.

El tipo TEXT permite almacenar cadenas de caracteres de hasta varios GB de longitud. Sólo se recomienda su uso para almacenar textos realmente grandes, puesto que presenta ciertas restricciones, aunque algunas pueden variar dependiendo del SGBD que se utiliza:

• Sólo se puede definir una columna TEXT por tabla
• No se pueden establecer restricciones en columnas de este tipo
• No se permite su utilización en ciertas cláusulas

Para la representación de tipos de datos numéricos. Los tipos más utilizados son BIT, TINYINT, INT, BIGINT, para la representación de números enteros de menor o mayor tamaño.

Para número decimales tenemos los tipos FLOAT y DOUBLE, números en coma flotante de menor o mayor precisión, respectivamente. En este caso conviene tener en cuenta los problemas de precisión ¹⁾ que existen con estos tipos de datos. Si necesitamos almacenar valores en los que es muy importante la precisión decimal, podemos utilizar DECIMAL(d,n), d representa la cantidad de digitos del valor, y n la cantidad de decimales después de la coma.

En ocasiones el rango de los valores negativos resultará prescindible (claves numéricas, valores de dinero, cantidades, . . .) por lo que será posible ampliar el rango positivo de un tipo numérico añadiendo la restricción UNSIGNED tras definir el tipo de éste.

        id INT UNSIGNED

Los tipos más utilizado para almacenar valores de fechas (DATE) o fechas con hora (DATETIME). Por defecto el formato utilizado es YYYY-MM-DD y YYYY-MM-DD HH:MM:SS respectivamente.

También se puede usar el tipo TIMESTAMP para almacenar una marca de tiempo (fecha y hora YYYY-MM-DD HH:MM:SS). Además, permite el uso de la constante CURRENT_TIMESTAMP en la definición de la columna al definirle un valor por defecto cuando se crea la tabla.

La diferencia entre TIMESTAMP frente a DATETIME, es que a pesar de mostrar el mismo formato, TIMESTAMP almacena también la zona horaria, y devuelve el valor modificado si cambiamos la zona horaria del servidor.

Permite almacenar valores lógicos Verdadero/Falso o Sí/No. Cuando usamos el tipo BOOLEAN para definir un campo MySQL define internamente la columna como del tipo TINYINT, utilizando los valores 0 y 1 para indicar los valores lógicos Verdadero y Falso, respectivamente. Así, podremos utilizar los valores TRUE ó FALSE o directamente asignar 1 ó 0 para asignar valor.

Las restricciones se pueden establecer, o no, a las columnas de cada tabla para forzar a que los datos almacenados en ellas cumplan una serie de condiciones, con la finalidad de que la información sea más correcta. Por ejemplo, podemos obligar a que un campo donde almacenamos el DNI de una persona tenga una longitud mínima, un campo donde almacenamos la categoría de un equipo de fútbol, sólo pueda tomar unos determinados valores predefinidos (benjamín, juvenil, cadete, . . .) o bien podemos hacer que un campo no pueda repetirse, por tratarse de un valor único (DNI, NSS, teléfono, email, . . .).

Hay que tener en cuenta que, por lo general, las restricciones se definen en línea con la definición del campo (tal y como se muestra en la sintaxis de la sentencia de CREATE TABLE, pero de forma opcional también pueden ser definidas por separado justo debajo de la definición de todos los campos de la tabla.

Una clave primaria dentro de una tabla, es una columna o conjunto de columnas cuyo valor identifica unívocamente a cada fila. Debe ser única, no nula y es obligatoria. Como máximo podremos definir una clave primaria por tabla y es muy recomendable definirla.

Para definir una clave primaria utilizamos la restricción PRIMARY KEY.

CREATE TABLE personas(
   dni VARCHAR(9) PRIMARY KEY,
   ...
);

Y si lo hacemos al final de la definición de las columnas, quedaría así:

CREATE TABLE personas(
   dni VARCHAR(9),
   nombre VARCHAR(10),
   PRIMARY KEY (dni)
);

Hay que tener en cuenta que a la hora de definir claves primarias compuestas (dos ó más columnas), ésta deberá ser definida forzosamente tras la definición de los campos involucrados, siguiendo esta sintaxis

CREATE TABLE personas(
   dni VARCHAR(9),
   nombre VARCHAR(10),
   apellidos VARCHAR(20),
   PRIMARY KEY (nombre, apellidos)
);

Es una propiedad que solo se puede aplicar a claves primarias de tipo entero. Hace que en cada inserción de nuevos registros en esa tabla, la clave primaria se genere automáticamente de forma secuencial. Es realmente útil ya que nos evita tener que dar valor a esa columna, siendo el motor de la base de datos el encargado de que sea siempre distinta.

La forma de definirlo es añadiendo la restricción AUTO_INCREMENT en la definición de la columna que se ha definido como clave primaria:

id INT PRIMARY KEY AUTO_INCREMENT

Como detalle, cualquier inserción fallida en la tabla seguirá incrementando el índice autonumérico aunque no se inserten los datos. Podemos resetearlo:

ALTER TABLE mitabla AUTO_INCREMENT = 1;

Si la tabla no está vacía, debe ser mayor que el último valor de esa columna.

Una clave ajena está formada por una o varias columnas cuya finalidad es almacenar valores que existen en la columna/s clave primaria de otra tabla (o la misma) a la que hace referencia. De este modo los sistemas relacionales aseguran que las relaciones entre tablas tienen significado.

Al definir una columna como clave ajena FOREIGN KEY el motor de la base de datos nos obliga a que todos los valores que contenga esa columna existen siempre en la columna de la clave primaria de la tabla con la que se relaciona. Este concepto se conoce como Integridad Referencial.

Las claves ajenas se deben definir después de la definición de los campos de la tabla:

CREATE TABLE asignaturas(
   id INT PRIMARY KEY AUTO_INCREMENT,
   nombre VARCHAR(20),
   departamento VARCHAR(20),
   id_curso INT,
 
   FOREIGN KEY (id_curso) REFERENCES cursos (id)
 
   -- También se puede crear indicandole un nombre concreto a la restricción:
   CONSTRAINT 'fk_cursos' FOREIGN KEY (id_curso) REFERENCES cursos (id)
);

El ejemplo anterior haría referencia tabla cursos:

CREATE TABLE cursos(
   id INT PRIMARY KEY AUTO_INCREMENT,
   horario VARCHAR(20),
   . . .
);

Si una tabla tiene diferentes claves ajenas, se definen del mismo modo:

   id_curso INT,
   id_profesor INT,
 
   FOREIGN KEY (id_curso) REFERENCES cursos (id),
   FOREIGN KEY (id_profesor) REFERENCES profesores (id)

Si la clave ajena hace referencia a una clave primaria compuesta:

FOREIGN KEY (id_curso, id_aula) REFERENCES cursos(id_curso, id_aula)

Las definiciónes de la columna y de la restricción de clave ajena se hacen de forma independiente, pero debemos tener en cuenta que para crear la restricción de clave ajena sobre una columna, su tipo de datos debe ser exactamente igual al de la clave primaria a la que hace referencia.

Habrá que tener en cuenta que mientras que un campo definido como clave ajena haga referencia a un campo definido como clave primaria, la fila de la segunda tabla no podrá ser eliminada hasta que no lo haga la fila que le hace referencia (integridad referencial). Para evitar estos problemas (aunque no siempre es un problema) es posible definir la restricción de clave ajena añadiendo la cláusula ON DELETE o bien ON UPDATE para el caso de una actualización. De esa manera, cuando se vaya a eliminar o actualizar una fila a cuya clave primaria se haga referencia, podremos indicar a MySQL que operación queremos realizar con las filas que le hacen referencia:

• RESTRICT: Se rechaza la operación de eliminación/actualización
• CASCADE: Realiza la operación y se elimina o actualiza en cascada en las filas que hacen referencia
• SET NULL: Realiza la operación y fija a NULL el valor en las filas que hacen referencia
• NO ACTION: Se rechaza la operación de eliminación/actualización, como ocurre con la opción RESTRICT

Si no especifico ningun tipo de acción, se tomará NO ACTION por defecto para ambas operaciones (UPDATE y DELETE); se restringe el borrado o actualización de valores de claves primarias si tiene claves ajenas referenciando.

-- No podré eliminar cursos si hay asignaturas referenciandolos:
FOREIGN KEY (id_curso) REFERENCES cursos (id) ON DELETE RESTRICT
 
-- Si modifico el valor de la clave primaria de un curso, se actualiza la clave ajena
-- Si elimino un curso, se pondrá a NULL el valor de la clave ajena de las asignaturas
FOREIGN KEY (id_curso) REFERENCES cursos (id) ON UPDATE CASCADE ON DELETE SET NULL

Para definir claves ajenas en MySQL habrá que tener en cuenta algunas consideraciones:

• Una columna clave ajena nunca podrá ser AUTO_INCREMENT, ya que rompería el propósito de la relación.
• La columna/s clave ajena debe ser del mismo tipo de datos que la columna clave primaria a las que se referencia.
• La columna deberá ser un índice. A partir de Mysql 8 y versiones compatibles de MAriaDB, se hace automáticamente.
• Si la columna se define como obligatoria (NOT NULL) no podrá contener la claúsula (SET NULL) para los casos de borrado (ON DELETE) o actualización (ON UPDATE).
• Toda restricción de clave ajena tiene un nombre. Para ver el nombre de las restricciones de una tabla: SHOW CREATE TABLE <nombre_tabla>

Esta restricción obliga a que se le tenga que dar valor obligatoriamente a una columna. Por tanto, no podrá tener el valor NULL. Se utiliza la palabra reservada NOT NULL.

    apellidos VARCHAR(250) NOT NULL

Se puede definir el valor que una columna tomará por defecto, es decir, si al introducir una fila no se especifica valor para dicha columna. Se utiliza la palabra reservada DEFAULT.

fecha  TIMESTAMP DEFAULT CURRENT_TIMESTAMP  
nombre VARCHAR(250) DEFAULT 'Sin nombre'

De forma más genérica, podemos forzar a que los valores de determinados campos de la tabla cumplan una ciertas condiciones.

Lo habitual es definir una columna como de tipo enumeración (ENUM en MySQL) si queremos indicar que solamente una serie de valores (definidos) son válidos:

curso   ENUM ('0', '1', '2'),
horario ENUM ('mañana', 'tarde', 'noche'),

La restricción UNIQUE evita valores repetidos en una misma columna. Al contrario que ocurre con la restricción PRIMARY KEY, UNIQUE sí admite el valor NULL. Con respecto a esta última consideración, conviene saber que si una columna se define como UNIQUE, sólo una de sus filas podrá contener el valor NULL. Del mismo modo que la clave primaria, esta restricción se puede aplicar a una columna o a un conjunto de columnas.

email VARCHAR(100) UNIQUE
 
// o para varias columnas
. . .
email VARCHAR(100),
login VARCHAR(50),
UNIQUE (email, login)

Los índices se utilizan para obtener datos de las tablas de una forma más rápida. En definitiva, lo que el SGBD hace es asociar el valor de una columna (sobre la que definimos el índice) con su posición en la tabla. De esa manera será más rápido buscar sobre esa columna puesto que al encontrar el valor, el SGBD conocerá su posición en la tabla.

Se recomienda su uso en aquellas columnas sobre las que se vayan a realizar búsquedas en una tabla. Por ejemplo, si tenemos una tabla donde almacenamos información sobre Libros, nos podría interesar crear un índice en el campo autor, puesto que puede ser muy común buscar qué libros ha escrito un autor determinado. Además, será un valor que contendrá pocos valores repetidos, por lo que maximizará el beneficio de usar un índice.

CREATE TABLE libro(
id INT ...,
titulo ...,
autor VARCHAR(20),
INDEX autor_index (autor)
);
 
-- También puedo añadirlo cuando la tabla ya se ha creado
CREATE INDEX indice_autor ON libro(autor);

Por otra parte, los índices presentan algún inconveniente como puede ser el hecho de que ocupan espacio en la tabla, y dependiendo del caso podría llegar a ocupar más espacio que la propia tabla, por lo que hay que tener cuidado a la hora de escoger una columna como índice. También hay que tener en cuenta que hay que actualizar el índice cada vez que se modifica la columna en la tabla por lo que no resulta conveniente elegir como índices aquellas columnas que creamos que van a escribirse con mucha frecuencia.

La forma más habitual de trabajo a la hora de lanzar órdenes en SQL sobre un SGBD relacional como MySQL es crear ficheros por lotes de órdenes SQL, lo que se conoce como scripts SQL, donde podemos escribir todas las sentencias SQL que queremos ejecutar una detrás de otra separadas por el carácter ;.

Existe la posibilidad de añadir comentarios al código según la siguiente sintaxis:

    -- Esto es un comentario y MySQL no lo ejecuta
    /* Esto también es un comentario y 
       tampoco se ejecuta */

Por ejemplo, para la creación de una nueva Base de Datos y sus tablas podríamos preparar un script SQL como el siguiente:

CREATE DATABASE IF NOT EXISTS pagina_web;
USE pagina_web;
 
CREATE TABLE IF NOT EXISTS usuarios (
    id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    . . .
    . . .
);
CREATE TABLE IF NOT EXISTS productos (
    . . .
    . . .
);
. . .
. . .

Una vez creado el script podremos lanzar su ejecución sobre MySQL y se ejecutarán todas las sentencias contenidas en él de forma secuencial. Es una forma muy útil de crear scripts para la creación de una Base de Datos y todas sus tablas y restricciones y también para crear scripts de actualización o parcheo de una Base de Datos existentes de forma que se incluyan todas las sentencias SQL que actualicen o arreglen los problemas que actualmente pueda haber (añadir una nueva tabla, eliminar un campo, añadir una nueva restricción, . . .).

Para estos casos a veces resulta útil desactivar las claves ajenas, realizar algunas operaciones sobre tablas que puedan tener relaciones con otras y volver a activarlas. De esa manera es posible realizar ciertas operaciones sin que las reglas de validación de la integridad referencial lancen ningún error.

-- Desactivar claves ajenas
SET FOREIGN_KEY_CHECKS = 0;
. . .
// Realizar algunos cambios en la estructura y datos de la Base de Datos
. . .
-- Activar claves ajenas
SET FOREIGN_KEY_CHECKS = 1;

1. Utilizar notación snake_case para todos los identificadores (nombre de la base de datos, nombres de tablas, nombres de columnas, . . .). Y siempre en minúscula
2. No utilizar acentos, el caracter ñ ni otros caracteres extraños (|@#…) para nombres de bases de datos, tablas, columnas o cualquier otro elemento
3. Escribir las palabras reservadas del lenguaje SQL en mayúsculas
4. Todas las tablas tendrán un campo clave primaria cuyo nombre será id (definir como id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT)
5. Las claves ajenas indicarán la tabla a la que hacen referencia (en singular) como parte de su nombre. Por ejemplo: id_usuario si es una clave ajena de una tabla usuarios. Si en una tabla hay dos claves ajenas que apuntan a la misma tabla, añadiremos algo al nombre para distinguirla (id_usuario_emisor e id_usuario_receptor, por ejemplo)
6. Se recomienda que los nombres de las tablas sean en plural (users mejor que user, orders mejor que order)
7. Antes de definir un tipo de dato como numérico, comprobar si realmente voy a operar con él como tal
8. Cuidado con los campos contraseña. Realmente nunca se guarda tal cual sino como un hash utilizando algún algoritmo, por lo que la longitud real es mayor (la longitud de un hash creado con SHA1 es de 40 caracteres y con SHA2 hasta 128)

• Crear el script a partir del modelo relacional

• Cómo crear un script en SQL

Para poder trabajar con una base de datos es necesario que esta contenga datos, cuanta más cantidad y variedad, mejor.

Para insertar datos en una tabla usamos la sentencia INSERT INTO. Esta sentencia junto a otras, se trabajan en el bloque 5 de esta wiki, aunque podemos ver su estructura a continuación:

INSERT INTO nombre_tabla [ '('columnas')' ] 
{ VALUES '(' { valores } ')',} | consulta

Indicar las columnas en las que inserta datos es opcional. Si no se indican, se debe dar valor a todas las columnas en el órden en que están creadas en la tabla. Si se indican las columnas, se da solamente valor a esos campos.

Veamos algunos ejemplos:

• Para insertar una fila con todos los campos de la tabla

-- La tabla pistas tiene los campos: (id, codigo, tipo, precio, id_polideportivo)
INSERT INTO pistas
VALUES (1 , 'A34565', 'tenis', '7.34', '12');

• Para insertar una fila en una tabla dando valor a ciertas columnas

INSERT INTO usuarios (dni, nombre, apellidos, email, fecha_nacimiento)
VALUES ('123456789A', 'Antonio', 'García', 'agarcia@gmail.com', '1990-12-12');

• Para insertar varias filas en una tabla

INSERT INTO usuarios (dni, nombre, apellidos, email, fecha_nacimiento)
VALUES ('123456789A', 'Pepe', 'Sanz', 'psanz@gmail.com', '1990-12-12'),
       ('987654321Z', 'Luis', 'Peréz', 'lperez@gmail.com', '1988-01-03');

Existen programas que tienen sus propias bases de datos con datos de ejemplo y nos permiten generar datos adaptados a los campos de nuestras tablas. En la sección Software Necesario de esta wiki tenemos distintos generadores, de los que tratamos en el siguiente video:

Generadores de datos

Estos programas nos generan el código SQL para insertar grandes cantidades de datos a través de sentencias INSERT INTO.

© 2024 Santi Faci y Fernando Valdeón