¿Qué es SQL? In­tro­du­c­ción con ejemplos

La sintaxis del lenguaje de pro­gra­ma­ción SQL se basa en el álgebra re­la­cio­nal y, por tanto, se distingue de otros lenguajes de pro­gra­ma­ción. Para aprender a usar SQL, se requiere tener co­no­ci­mie­n­tos de la sintaxis del lenguaje y con ejemplos ilu­s­tra­ti­vos se vuelve más fácil.

Conceptos básicos de la sintaxis SQL

En general, la sintaxis es la “notación” de un lenguaje de pro­gra­ma­ción. La sintaxis determina qué tipos de es­tru­c­tu­ras básicas de código existen y cómo pueden unirse entre sí. Entender la sintaxis es un requisito fu­n­da­me­n­tal para poder leer y escribir código en el re­s­pe­c­ti­vo lenguaje de pro­gra­ma­ción.

Las es­tru­c­tu­ras si­n­tá­c­ti­cas más im­po­r­ta­n­tes de SQL son las se­n­te­n­cias SQL con las re­s­pe­c­ti­vas cláusulas que estas puedan contener. Aunque té­c­ni­ca­me­n­te no es del todo correcto, ambas se denominan ge­ne­ra­l­me­n­te “comandos SQL”. Además, hay otras co­n­s­tru­c­cio­nes si­n­tá­c­ti­cas que pre­se­n­ta­mos para una mayor claridad:

¿Cómo se ejecuta el código SQL?

El código SQL existe como código fuente dentro de un archivo de texto, y solo puede cobrar vida en un entorno de ejecución adecuado. Un in­té­r­pre­te de SQL lee el código fuente y lo convierte en acciones de un RDBMS. Hay dos enfoques pri­n­ci­pa­les al respecto:

1. Ejecutar código SQL en una sesión in­ter­ac­ti­va

Con este enfoque, el código SQL se introduce o se copia y pega di­re­c­ta­me­n­te en una ventana de texto. Entonces, se ejecuta el código SQL y se muestra el resultado. Ahí, el usuario tiene la opo­r­tu­ni­dad de modificar el código y volver a eje­cu­tar­lo. La rápida secuencia de ma­ni­pu­la­ción del código y vi­sua­li­za­ción de los re­su­l­ta­dos hace que este enfoque sea el más adecuado para aprender y crear consultas complejas.

2. Ejecutar el código SQL como script

Con este enfoque, se ejecuta línea por línea todo un archivo con código SQL. El feedback solo se transmite al usuario al final de la ejecución. Este enfoque es el más adecuado para au­to­ma­ti­zar procesos e importar copias de seguridad de bases de datos MySQL con MySQL Dump.

Utilizar SQL como ejemplo para co­n­fi­gu­rar la gestión de productos

La forma más fácil de aprender un lenguaje de pro­gra­ma­ción es escribir y ejecutar el código uno mismo. Para ello, primero debemos crear una minibase de datos para poder ejecutar consultas en ella. Después, uti­li­za­re­mos el Online SQL in­te­r­pre­ter del sitio web sql.js. Accede al enlace del sitio web y sustituye el código SQL ya in­tro­du­ci­do por el código de nuestros ejemplos. Ejecuta el código fragmento a fragmento para obtener los re­su­l­ta­dos mostrados.

Pro­ce­di­mie­n­to básico para co­n­fi­gu­rar una base de datos SQL

A modo de ejemplo, vamos a crear un sistema de gestión de productos co­me­r­cia­les, tal y como se uti­li­za­ría en una tienda física u online. Para ello, vamos a definir los re­qui­si­tos a grandes rasgos:

• Hay una serie de productos de los que tenemos un número de­te­r­mi­na­do de exi­s­te­n­cias en todo momento.
• Nuestra cartera consta de varios clientes.
• Un cliente realiza un pedido que puede contener varios productos.
• Guardamos la fecha y la persona que realiza cada pedido, además de los productos y la cantidad que se ha pedido de cada uno.

Primero co­n­ve­r­ti­mos estos re­qui­si­tos en una de­s­cri­p­ción abstracta y luego en código SQL. Seguimos el siguiente guion:

1. Crear el modelo
2. Definir el esquema
3. In­tro­du­cir los registros de datos
4. Definir las consultas

Crear un modelo de entidades y re­la­cio­nes

El primer paso se realiza en papel o con he­rra­mie­n­tas es­pe­cí­fi­cas de modelado. Recogemos in­fo­r­ma­ción sobre el sistema que vamos a modelar y extraemos sus entidades y re­la­cio­nes de él. Esto suele hacerse con un diagrama de Entity Re­la­tio­n­ship (ER).

¿Qué entidades hay y cómo se re­la­cio­nan? Las entidades son clases de cosas. En nuestro ejemplo de gestión de productos existen las entidades producto, cliente y pedido. Cada entidad requiere una tabla. Debido a las ca­ra­c­te­rí­s­ti­cas es­pe­cia­les del modelo re­la­cio­nal, pueden añadirse otras tablas para modelar las re­la­cio­nes. Para entender todo esto bien y aplicarlo co­rre­c­ta­me­n­te, hace falta ex­pe­rie­n­cia.

Una cuestión fu­n­da­me­n­tal es cómo se re­la­cio­nan las entidades entre sí. Para ello, han de co­n­si­de­rar­se los dos sentidos de una relación y di­s­ti­n­guir entre singular y plural. Uti­li­za­n­do el ejemplo de la relación pro­pie­ta­rio-coche:

1. “Un pro­pie­ta­rio es po­te­n­cia­l­me­n­te dueño de varios coches”
2. “Un coche pertenece úni­ca­me­n­te a un pro­pie­ta­rio”

Surgen tres posibles modelos de relación entre dos entidades:

Im­ple­me­n­tar productos

El primer paso es im­ple­me­n­tar la tabla de productos. Para ello, hay que definir un esquema, in­tro­du­cir los registros de datos y ejecutar algunas consultas sencillas a modo de prueba. Entremos en detalle para cada uno de los pasos.

Definir el esquema

El principal comando SQL utilizado para definir las tablas de la base de datos es CREATE TABLE. Este comando crea una tabla, le asigna un nombre y define las pro­pie­da­des de las columnas. Al mismo tiempo, se definen los tipos de datos y, si es necesario, las li­mi­ta­cio­nes de los valores que se van a almacenar:

DROP TABLE IF EXISTS Products;
CREATE TABLE Products ( product_id int, product_name text, stocked int, price int );

In­tro­du­cir registros de datos

Crea varios registros de prueba y luego utiliza tanto el comando SQL INSERT INTO como la función VALUES para rellenar los campos:

INSERT INTO Products VALUES (10, 'ABC Product', 74, 1050);
INSERT INTO Products VALUES (20, 'KLM Product', 23, 750);
INSERT INTO Products VALUES (30, 'XYZ Product', 104, 350);

Definir las consultas

Redacta una consulta sencilla para comprobar el estado de la tabla de productos. Usa el comando SELECT FROM y emite la tabla completa:

SELECT * FROM Products;

Haz también una consulta algo más compleja que calcule el valor total de los productos al­ma­ce­na­dos:

SELECT product_name AS 'Name', (stocked * price) AS 'Value' FROM Products;

Im­ple­me­n­tar el resto de tablas

En la siguiente sección tendrás que crear el resto de tablas ne­ce­sa­rias. Procede de la misma manera que para la tabla de productos. Primero, hay que crear la tabla de clientes:

DROP TABLE IF EXISTS Customers;
CREATE TABLE Customers ( customer_id int, customer_name text, contact text );

Guarda los registros de datos de los clientes. En este ejemplo, guardamos los de dos clientes:

INSERT INTO Customers VALUES (100, 'EDC Customer', 'ED@example.com');
INSERT INTO Customers VALUES (200, 'WVU Customer', 'WV@example.com');

Para ve­ri­fi­car­lo, emite la tabla de clientes:

SELECT * FROM Customers;

El siguiente paso es crear la tabla de pedidos:

DROP TABLE IF EXISTS Orders;
CREATE TABLE Orders ( order_id int, customer_id int, order_date text );

Aquí, in­tro­du­ci­mos tres pedidos a modo de ejemplo. Fíjate que asignamos un ide­n­ti­fi­ca­dor de clave primaria como primer valor de los registros. Sin embargo, el segundo valor es el ide­n­ti­fi­ca­dor de clientes ya exi­s­te­n­tes a modo de claves externas. Además, también al­ma­ce­na­mos la fecha del pedido:

INSERT INTO Orders VALUES (1000, 100, '2022-05-03');
INSERT INTO Orders VALUES (1001, 100, '2022-05-04');
INSERT INTO Orders VALUES (1002, 200, '2022-05-08');

Emite los pedidos para comprobar:

SELECT * FROM Orders;

Por último, hace falta una tabla para los productos co­n­te­ni­dos en un pedido y su número. Se trata de una relación m:n ya que un pedido puede contener varios productos y un producto puede aparecer en varios pedidos. Define una tabla que contenga los ide­n­ti­fi­ca­do­res de los pedidos y los productos como claves externas:

DROP TABLE IF EXISTS OrderItems;
CREATE TABLE OrderItems ( orderitem_id int, order_id int, product_id int, count int );

Introduce algunos productos pedidos. Se­le­c­cio­na los ide­n­ti­fi­ca­do­res (ID) de los pedidos y los productos para que haya un pedido con dos productos y otro con un solo producto:

INSERT INTO OrderItems VALUES (10001, 1000, 10, 3);
INSERT INTO OrderItems VALUES (10002, 1000, 20, 2);
INSERT INTO OrderItems VALUES (10003, 1002, 30, 12);

Emite los productos pedidos a modo de co­m­pro­ba­ción:

SELECT * FROM OrderItems;

Realizar consultas complejas

Si has ejecutado todos los fra­g­me­n­tos de código mostrados hasta el momento, deberías ser capaz de entender la es­tru­c­tu­ra de nuestra base de datos de prueba. Pasemos ahora a consultas más complejas que de­mue­s­tran el potencial del lenguaje SQL. Primero, haremos una consulta que unifique datos re­pa­r­ti­dos por varias tablas. Uti­li­za­re­mos un comando SQL JOIN para unir los datos de la tabla de clientes con la de pedidos. Al hacerlo, nombramos algunas de las columnas y es­ta­ble­ce­mos que el ide­n­ti­fi­ca­dor del cliente coincida como una condición JOIN. Ten en cuenta que uti­li­za­mos ide­n­ti­fi­ca­do­res cua­li­fi­ca­dos para di­s­ti­n­guir las columnas de las dos tablas:

SELECT customers.customer_name as 'Customer', customers.customer_id, orders.order_id, orders.order_date AS 'Date' FROM Customers JOIN Orders ON Orders.customer_id = Customers.customer_id ORDER BY Customers.customer_id;

Por último, pero no por ello menos im­po­r­ta­n­te, uti­li­za­mos otro comando JOIN para calcular el coste total de los productos pedidos:

SELECT OrderItems.order_id, OrderItems.orderitem_id AS 'Order Item', Products.product_name AS 'Product', Products.price AS 'Unit Price', OrderItems.count AS 'Count', (OrderItems.count * Products.price) AS 'Total' FROM OrderItems JOIN Products ON OrderItems.product_id = Products.product_id;