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á lleno de signos de puntuación. Los paréntesis () delimitan argumentos de funciones y agrupan 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, la distinción entre mayúsculas y minúsculas en los nombres de bases de datos y tablas depende del sistema operativo y de la configuración del servidor. 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 SQL, el punto y coma ; termina una sentencia. Las herramientas interactivas como psql, el cliente de MySQL y la consola de SQLite suelen esperar este carácter antes de ejecutarla. En psql también puedes enviar la consulta actual con \g. Si aparece una indicación para introducir más texto en lugar de un resultado, comprueba si has terminado la sentencia.

Consultas SELECT y joins

Escribir consultas suele significar escribir joins. PostgreSQL usa INNER JOIN, LEFT JOIN y RIGHT JOIN. En el ejemplo siguiente, la condición del join aparece después de ON. También existen joins con USING o NATURAL. 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 = para asignar valores y comas para separar las asignaciones. 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, SQLite y SQL Server también admiten CTE. Comprueba que cada paréntesis de apertura tenga su correspondiente paréntesis de cierre.

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 admiten funciones de ventana. El ejemplo siguiente usa la sintaxis de PostgreSQL.

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

Parámetros y placeholders

En las aplicaciones, los marcadores de parámetros dependen tanto de la base de datos como del controlador. Las sentencias preparadas nativas de PostgreSQL usan $1, $2, las sentencias preparadas de MySQL y las consultas de SQLite pueden usar ?, y los parámetros de SQL Server tienen nombres como @p1. Un controlador puede exigir otra sintaxis, como %s en Psycopg. Consulta su documentación, porque estos símbolos pequeños son fáciles de escribir mal.

-- 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. PostgreSQL convierte en minúsculas los identificadores sin comillas dobles; las reglas varían en otros sistemas. 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.