Ejercicio de mecanografía: Programación en lenguaje SQL

Aprender SQL y practicar mecanografía se complementan de manera natural. Las consultas SQL están llenas de paréntesis, comas, operadores y comillas. Pequeños errores, como escribir mal una comilla o olvidar un punto y coma, pueden hacer que toda la consulta falle. Al escribir en SQL, conviene saber qué partes de la sintaxis son comunes entre diferentes bases de datos y cuáles son específicas de cada sistema. Este artículo se centra principalmente en PostgreSQL, pero también menciona MySQL, SQLite y SQL Server donde la sintaxis varía.

¿Qué es característico de la sintaxis SQL?

SQL (Structured Query Language) es un lenguaje declarativo. En lugar de describir paso a paso cómo obtener los datos, declaras qué datos quieres. Casi todas las sentencias empiezan con una palabra clave como SELECT, INSERT o UPDATE. El orden de las cláusulas es fijo: SELECT ... FROM ... WHERE ... GROUP BY ... HAVING ... ORDER BY .... PostgreSQL y MySQL comparten este orden, así que si lo aprendes en uno, lo podrás aplicar en el otro.

SELECT id, name
FROM customers
WHERE active = true
ORDER BY created_at DESC;

Caracteres especiales que se usan con frecuencia

SQL está llena de signos de puntuación. Los paréntesis () rodean funciones y condiciones. Las comas , separan columnas. El punto . se usa para esquemas y nombres de tablas, como public.users. Las comillas simples '...' delimitan literales de texto. PostgreSQL utiliza comillas dobles "..." para identificadores, mientras que MySQL usa acentos graves `...`. En SQL Server también se ven corchetes [...]. Practicar estos símbolos ayuda a escribir consultas correctas sin romperlas por error.

-- Literal de cadena
SELECT * FROM books WHERE title = 'War and Peace';

-- Identificadores con espacios (PostgreSQL)
SELECT "Order ID", "Customer Name" FROM orders;

Mayúsculas y minúsculas

Por convención, las palabras clave SQL suelen escribirse en mayúsculas: SELECT, FROM, WHERE. Esto facilita su reconocimiento en las consultas, pero no es obligatorio. En PostgreSQL, los identificadores no entrecomillados se convierten automáticamente en minúsculas, así que MyTable y mytable se tratan igual. En MySQL el comportamiento depende del sistema operativo. Para practicar, usar mayúsculas en las palabras clave es habitual, porque resalta la estructura de la consulta.

Puntos y coma y fin de sentencias

En PostgreSQL, cada sentencia normalmente termina con un punto y coma ;. Olvidarlo puede impedir la ejecución en herramientas como psql. MySQL y SQLite son más permisivos en modo interactivo, pero el punto y coma sigue siendo buena práctica. Este pequeño carácter es a menudo la causa de errores en consultas rápidas.

Consultas SELECT y joins

Escribir consultas suele significar escribir joins. PostgreSQL usa INNER JOIN, LEFT JOIN y RIGHT JOIN. Cada join necesita la palabra clave ON seguida de una condición. Un espacio mal colocado o una condición mal escrita rompe la consulta. Practicar joins ayuda a ganar precisión con símbolos como = y ..

SELECT c.id, c.name, o.amount
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id
WHERE o.amount > 100;

Funciones y expresiones

PostgreSQL tiene muchas funciones como COUNT(), SUM() y AVG(). Siempre requieren paréntesis. Funciones de fecha y hora como NOW() o DATE_TRUNC() son propias de PostgreSQL. MySQL tiene equivalentes como CURDATE() o DATE_FORMAT(). Escribirlas bien requiere atención a guiones bajos, comas y paréntesis.

SELECT DATE_TRUNC('month', created_at) AS month,
       COUNT(*) AS orders
FROM orders
GROUP BY month
ORDER BY month;

INSERT, UPDATE, DELETE

Las sentencias que modifican datos contienen muchos signos de puntuación. INSERT usa paréntesis y comas para columnas y valores. UPDATE usa = separados por comas. DELETE combina palabras clave con condiciones. Estas estructuras son casi idénticas en PostgreSQL, MySQL, SQLite y SQL Server, aunque las reglas de comillas pueden variar.

INSERT INTO users (id, name, email)
VALUES (1, 'Alice', 'a@example.com');

UPDATE users
SET name = 'Bob', email = 'bob@example.com'
WHERE id = 1;

DELETE FROM users WHERE id = 2;

Common Table Expressions (CTE)

PostgreSQL usa con frecuencia las CTE introducidas con WITH. Estas implican muchos paréntesis y comas, por lo que son un buen ejercicio de mecanografía. MySQL y SQLite las soportan en versiones recientes, y SQL Server también. Colocar bien los paréntesis es el error más habitual.

WITH recent_orders AS (
  SELECT * FROM orders WHERE created_at > NOW() - INTERVAL '30 days'
)
SELECT customer_id, COUNT(*) AS order_count
FROM recent_orders
GROUP BY customer_id;

Funciones de ventana

PostgreSQL es conocido por sus funciones de ventana. La sintaxis típica OVER (PARTITION BY ... ORDER BY ...) requiere precisión en los paréntesis y palabras clave. MySQL y SQL Server también las soportan, pero PostgreSQL suele tomarse como referencia.

SELECT customer_id,
       SUM(amount) OVER (PARTITION BY customer_id ORDER BY created_at) AS running_total
FROM payments;

Parámetros y placeholders

En aplicaciones, los placeholders varían según la base de datos. PostgreSQL usa $1, $2, MySQL y SQLite usan ?, y SQL Server @p1. Son símbolos pequeños, fáciles de escribir mal, pero críticos para que la consulta funcione.

-- PostgreSQL
SELECT * FROM users WHERE id = $1;

-- MySQL
SELECT * FROM users WHERE id = ?;

Resumen

Por convención, las palabras clave SQL suelen escribirse en mayúsculas, mientras que los identificadores se mantienen en minúsculas a menos que se entrecomillen. PostgreSQL añade comillas dobles para identificadores, placeholders $n, CTE y funciones de ventana. MySQL usa acentos graves y placeholders ?. SQL Server introduce corchetes y parámetros @. SQLite mantiene la sintaxis simple, pero requiere precisión. Practicar consultas SQL mejora la exactitud al escribir signos de puntuación, palabras clave y símbolos, y centrarse en PostgreSQL da práctica con una de las bases de datos modernas más utilizadas.