Blog de SQL Arena
Tutoriales de SQL
Fundamentos: SELECT y filtrado
4 artículos¿Qué es SELECT … FROM en SQL? Leer de una tabla para principiantes
SELECT es el corazón de SQL. Toda consulta empieza aquí. Cubrimos la sintaxis, la elección de columnas concretas, los alias, los campos calculados, los errores comunes y tres ejercicios prácticos.
¿Qué es WHERE en SQL? Filtrado de filas para principiantes
WHERE es el filtro de filas en SQL. En lenguaje llano y con muchos ejemplos: =, IN, BETWEEN, LIKE, IS NULL y AND/OR. Tablas antes y después, trampas para principiantes y una práctica rápida al final.
¿Qué es LIMIT en SQL? Limitar el número de filas para principiantes
LIMIT limita el resultado de una consulta a N filas. Esencial para la paginación, las consultas top-N y las vistas previas. Cubrimos la sintaxis, OFFSET, las diferencias entre PostgreSQL y MySQL, los errores comunes y tres ejercicios prácticos.
¿Qué es ORDER BY en SQL? Ordenar los resultados de una consulta para principiantes
ORDER BY ordena el resultado de una consulta SQL. Cubrimos ASC y DESC, la ordenación por varias columnas, los NULL en el orden y el clásico ORDER BY + LIMIT para el top-N. Muchos ejemplos y tres ejercicios.
Unión de tablas (JOIN)
7 artículos¿Qué es INNER JOIN en SQL? Unir tablas para principiantes
INNER JOIN combina filas de dos tablas por una clave compartida. El JOIN más sencillo y más común. Cubrimos la sintaxis, la cláusula ON, las uniones de varias tablas, los errores comunes y tres ejercicios prácticos.
¿Qué es LEFT JOIN en SQL? Guía para principiantes
LEFT JOIN conserva todas las filas de la tabla izquierda; las coincidencias que faltan a la derecha se vuelven NULL. Cubrimos la sintaxis, la diferencia con INNER JOIN, la búsqueda de huérfanos y tres ejercicios.
Alias (AS) en SQL: alias de tablas y columnas para principiantes
Los alias son nombres cortos para tablas y columnas en SQL. Hacen las consultas legibles y se vuelven obligatorios al hacer JOIN de tablas con nombres de columna compartidos. Sintaxis, casos imprescindibles, errores comunes y tres ejercicios.
SQL FULL OUTER JOIN: conciliar datos y emularlo en MySQL
Una mirada práctica al FULL OUTER JOIN: obtener todas las filas de ambos lados, dónde aparecen los NULL, por qué es perfecto para la conciliación y cómo emularlo en MySQL.
SQL CROSS JOIN: productos cartesianos, generación de combinaciones y calendarios
Una mirada práctica al CROSS JOIN: productos cartesianos, generación de todas las combinaciones y calendarios sin huecos, además de cómo detectar cross joins accidentales.
Self-joins en SQL: unir una tabla consigo misma
Usa alias de tabla para unir una tabla consigo misma: jerarquías empleado→jefe, comparar filas dentro de una sola tabla y generar pares sin duplicados.
Anti-joins en SQL: encontrar filas sin coincidencia
Tres formas de encontrar filas sin coincidencia — LEFT JOIN / IS NULL, NOT EXISTS y NOT IN — y por qué NOT IN falla con NULL.
Agregación y agrupación
25 artículos¿Qué son COUNT, SUM, AVG, MIN, MAX en SQL? Funciones de agregación para principiantes
Las funciones de agregación son herramientas para "calcular algo sobre un grupo de filas". COUNT — cuántas filas, SUM — el total, AVG — el promedio, MIN/MAX — el menor y el mayor. En palabras sencillas: la diferencia entre COUNT(*) y COUNT(columna), cómo afecta NULL a los agregados, escenarios comunes y errores frecuentes.
¿Qué es GROUP BY en SQL? Agrupar filas para principiantes
GROUP BY es el comando de SQL para "colapsar filas en grupos y agregar". En palabras sencillas: cómo obtener "cuántos pedidos tiene cada cliente" en una sola consulta. Qué puedes y qué no puedes poner en SELECT, la diferencia con DISTINCT, GROUP BY sobre varias columnas y los errores más comunes.
¿Qué es HAVING en SQL? Filtrar grupos para principiantes
HAVING es el filtro que se ejecuta después de GROUP BY y se aplica a los agregados. En palabras sencillas: WHERE filtra las filas de entrada, HAVING filtra los grupos de salida. Veremos la diferencia, los patrones típicos (top-N, anomalías) y por qué se confunden WHERE y HAVING.
STRING_AGG en SQL: concatenar filas agrupadas con un delimitador y ORDER BY
Cómo convertir muchas filas en una sola cadena delimitada y en el orden correcto, usando STRING_AGG de PostgreSQL, GROUP_CONCAT de MySQL y arrayStringConcat(groupArray()) de ClickHouse.
COUNT(*) FILTER (WHERE ...): agregados condicionales en una sola pasada
Como la clausula FILTER calcula varias metricas segmentadas en una sola pasada y reemplaza al CASE dentro del agregado.
ARRAY_AGG en PostgreSQL: agrupar valores en un array con ORDER BY y FILTER
Convierte las filas de un grupo en un array ordenado con ARRAY_AGG, filtralo y quita duplicados, vuelve a filas y conoce la alternativa en MySQL.
GROUPING SETS en SQL: subtotales y totales en una sola consulta
Usa GROUPING SETS para calcular varios niveles de agrupacion en una sola pasada y distinguir subtotales de NULL reales.
ROLLUP en SQL: subtotales jerarquicos y un total general en una sola consulta
Como GROUP BY ROLLUP anade subtotales y una fila de total general a la agregacion normal, y como leer los NULL finales con GROUPING().
PERCENTILE_CONT en PostgreSQL: mediana y percentiles con WITHIN GROUP
Calcula la mediana y el p95 con una sola agregacion PERCENTILE_CONT, con interpolacion, comparala con PERCENTILE_DISC y mira por que supera al AVG.
UNNEST en PostgreSQL: expandir un array en filas, WITH ORDINALITY y ARRAY_AGG
Expande un array en filas con UNNEST, obten un indice con WITH ORDINALITY, desanida varios arrays en paralelo y vuelve a agrupar con ARRAY_AGG.
COUNT(DISTINCT) en SQL: contar valores unicos y su coste
Como contar valores unicos con COUNT(DISTINCT), por que es caro a gran escala y cuando usar alternativas aproximadas con HLL.
BOOL_AND y BOOL_OR en PostgreSQL: agregados booleanos por grupo
Comprueba "todas las filas del grupo son verdaderas" con BOOL_AND y "al menos una" con BOOL_OR, mira como se tratan los NULL y como emularlo en MySQL y ClickHouse.
EVERY en SQL: comprobar una condicion en todo el grupo
EVERY es el sinonimo estandar de BOOL_AND: true cuando la condicion se cumple en cada fila contada, NULL sobre un grupo vacio.
STDDEV en SQL: STDDEV_SAMP vs STDDEV_POP y deteccion de outliers
En que se diferencian STDDEV_SAMP y STDDEV_POP, por que STDDEV a secas es muestral, como calcular media +/- sd y detectar outliers.
VARIANCE en SQL: VAR_SAMP frente a VAR_POP y su relacion con STDDEV
Como funcionan VAR_SAMP y VAR_POP en PostgreSQL, por que VARIANCE equivale a VAR_SAMP y como la varianza se relaciona con la desviacion estandar.
MODE() WITHIN GROUP en SQL: el valor mas frecuente en una sola expresion
Como encontrar el valor mas frecuente con MODE() WITHIN GROUP, como se resuelven los empates y por que es mejor que GROUP BY + COUNT + LIMIT 1.
PERCENTILE_DISC en SQL: percentiles discretos sin interpolacion
Como PERCENTILE_DISC devuelve un valor real de tus datos sin interpolacion, en que se diferencia de PERCENTILE_CONT y cuando elegir la variante discreta.
BIT_OR y BIT_AND en PostgreSQL: agregados bit a bit sobre mascaras de flags
Como BIT_OR reune todos los bits activos de un grupo, BIT_AND encuentra los comunes a todas las filas y como leer el resultado con & en mascaras de permisos.
JSON_AGG y JSONB_AGG en PostgreSQL: armar un array JSON para una respuesta de API
Convierte filas en un array JSON con JSON_AGG y JSONB_AGG, ordena el agregado, arma una respuesta de API anidada en una consulta y omite los NULL.
JSONB_OBJECT_AGG en PostgreSQL: convierte filas clave-valor en un solo objeto JSON
Convierte filas clave-valor en un solo objeto JSON con JSONB_OBJECT_AGG, conoce el comportamiento ante claves duplicadas y la diferencia con JSONB_AGG.
CORR en SQL: el coeficiente de correlacion de Pearson en una consulta
Como CORR(y, x) calcula la correlacion de Pearson, que significan su signo y magnitud, como se tratan los NULL y como anadir una recta de tendencia con REGR_*.
REGR_SLOPE y REGR_INTERCEPT en PostgreSQL: linea de tendencia y prediccion en una consulta
Construye una linea de minimos cuadrados en SQL con REGR_SLOPE y REGR_INTERCEPT, cuida el orden (y, x), revisa REGR_COUNT y predice sin un paquete estadistico externo.
REGR_R2 en SQL: R-cuadrado y bondad de ajuste de la regresion
Como REGR_R2 mide la calidad de una regresion lineal en SQL y por que conviene leerlo junto a REGR_SLOPE.
Pivotar filas a columnas con MAX/SUM FILTER en SQL
Convierte una tabla larga en una tabla cruzada ancha con un solo GROUP BY usando agregados y la clausula FILTER.
CUBE en SQL: todas las combinaciones de agrupacion en una pasada para informes cross-tab
Como GROUP BY CUBE calcula todas las combinaciones de columnas a la vez, por dimension y total general, y como leer subtotales NULL con GROUPING() y distinguir CUBE de ROLLUP.
Subconsultas y DISTINCT
4 artículos¿Qué es DISTINCT en SQL? Valores únicos para principiantes
DISTINCT significa "eliminar duplicados". En palabras sencillas: valores únicos de una columna o de una combinación de columnas, la diferencia con GROUP BY, el manejo de NULL y el DISTINCT ON específico de PostgreSQL para "una fila por grupo". Con tablas de antes/después y errores comunes.
¿Qué es IN con una subconsulta en SQL? Comprobación de pertenencia para principiantes
IN con una subconsulta filtra «filas donde el valor de una columna aparece en el resultado de otra consulta». En palabras sencillas: filtrar por una lista dinámica, la diferencia con una lista literal, la trampa de NOT IN con NULL y la comparación con EXISTS. Con tablas y errores comunes.
¿Qué es EXISTS en SQL? Comprobación de existencia para principiantes
EXISTS pregunta «¿hay al menos una fila que cumpla la condición?». En palabras sencillas: un filtro sobre la presencia de un registro relacionado (por ejemplo, «clientes con al menos un pedido»), la diferencia con IN con una subconsulta, NOT EXISTS y el comportamiento con NULL.
¿Qué es una subconsulta escalar en SQL? Un único valor en SELECT para principiantes
Una subconsulta escalar es un SELECT que devuelve exactamente un valor y encaja en la posición de una columna o en una expresión WHERE. En palabras sencillas: extraer un campo de una tabla relacionada, añadir un número de resumen a cada fila de un informe, usarla como constante en una condición. Con tablas y errores comunes.
Funciones de ventana
10 artículos¿Qué es ROW_NUMBER en SQL? Numeración de filas para principiantes
ROW_NUMBER asigna «un número secuencial a cada fila». En pocas palabras: la primera función de ventana que vale la pena aprender. Numeración descendente, numeración dentro de grupos con PARTITION BY, el patrón clásico top-N por grupo y la eliminación de duplicados. Con tablas y errores comunes.
¿Qué son RANK y DENSE_RANK en SQL? Clasificación con empates para principiantes
RANK y DENSE_RANK son funciones de clasificación en las que los valores iguales reciben la misma posición. En pocas palabras: la diferencia entre ROW_NUMBER (siempre único), RANK (los empates reciben la misma posición y luego dejan huecos) y DENSE_RANK (la misma posición sin huecos). Con tablas, un ejemplo de estilo olímpico y errores comunes.
¿Qué es PARTITION BY en SQL? Grupos dentro de una ventana para principiantes
PARTITION BY es la parte de OVER que divide las filas en grupos para las funciones de ventana. En pocas palabras: es como GROUP BY, pero las filas no se colapsan: cada fila se conserva, con el agregado de su grupo añadido. La diferencia con GROUP BY, los patrones típicos y el comportamiento de los agregados dentro de las ventanas.
¿Qué son LAG y LEAD en SQL? Filas vecinas en una ventana para principiantes
LAG y LEAD devuelven el valor de la fila **anterior** o **siguiente** de una ventana. En pocas palabras: variación día a día, tiempo hasta el siguiente evento, cambio de precio: tareas que antes requerían unir una tabla consigo misma. Con tablas y errores comunes.
Marcos de ventana en SQL: ROWS/RANGE, totales acumulados y la trampa de LAST_VALUE
Entiende cómo funcionan los marcos ROWS y RANGE BETWEEN, crea totales acumulados y medias móviles, y evita la clásica trampa del marco por defecto de LAST_VALUE.
Funciones de ventana en SQL: ROW_NUMBER, RANK, LAG/LEAD en la práctica
Las funciones de ventana son la herramienta que más usa un analista en SQL. Desglosaremos ROW_NUMBER, RANK, LAG/LEAD y PARTITION BY a través de casos reales: top-N por grupo, métricas día a día, sumas acumuladas.
NTILE en SQL: cuartiles, deciles y cohortes en cubos iguales
Como NTILE(n) divide filas ordenadas en n cubos casi iguales, donde cae el resto y en que se diferencia de WIDTH_BUCKET.
FIRST_VALUE y LAST_VALUE en PostgreSQL: primer y ultimo valor por particion y la trampa del frame
Obten el primer y ultimo valor de una particion con FIRST_VALUE y LAST_VALUE, y descubre por que LAST_VALUE devuelve la fila actual sin un frame amplio.
PERCENT_RANK y CUME_DIST: percentiles de un ranking en SQL
Como calcular la posicion relativa de una fila en el rango 0..1 con PERCENT_RANK y CUME_DIST de forma determinista.
NTH_VALUE en PostgreSQL: el n-esimo valor de la ventana y el segundo maximo por grupo
Toma el n-esimo valor del marco con NTH_VALUE, amplia el marco como en LAST_VALUE, aprende donde funcionan de verdad FROM LAST e IGNORE NULLS y calcula el segundo maximo por grupo.
CTE (WITH)
5 artículos¿Qué es WITH … AS (CTE) en SQL? Expresiones de tabla común para principiantes
WITH … AS es un "resultado intermedio con nombre", también conocido como CTE (Common Table Expression). En palabras sencillas: una forma de dividir consultas complejas en pasos legibles, reutilizar valores calculados y escribir SQL que de verdad querrás volver a leer más adelante. Con tablas y errores comunes.
Varias CTE en una sola consulta: cadenas de WITH para principiantes
Varias CTE separadas por comas te permiten construir una consulta como una cadena de pasos: calculas una cosa, construyes la siguiente sobre ella y luego ensamblas el resultado final. En palabras sencillas: CTE encadenadas, reutilización de resultados intermedios y CTE recursivas para jerarquías.
CTE recursivas en SQL: WITH RECURSIVE para árboles, grafos y series numéricas
Cómo funciona WITH RECURSIVE: un ancla más un paso recursivo unidos por UNION ALL, para recorrer organigramas y grafos, generar series numéricas y mantenerse a salvo de los bucles infinitos.
LATERAL JOIN en PostgreSQL: top-N por grupo y subconsultas correlacionadas en el FROM
Como LATERAL permite que una subconsulta referencie columnas de tablas previas del FROM, resuelve el top-N por grupo y por que LEFT JOIN LATERAL ... ON true conserva las filas externas.
generate_series en SQL: calendarios, rangos numericos y rellenar huecos con ceros
Como generate_series construye una serie continua de enteros, fechas y timestamps y por que es la mejor forma de obtener un eje sin huecos.
Modificación de datos (DML)
10 artículos¿Qué es INSERT en SQL? Añadir filas para principiantes
INSERT es el comando de SQL para «añadir una fila nueva». En palabras sencillas: sintaxis básica, inserciones por lotes de varias filas de una sola vez, INSERT FROM SELECT, RETURNING para recuperar los IDs generados y UPSERT mediante ON CONFLICT para operaciones idempotentes. Con tablas de antes/después y errores comunes.
¿Qué es UPDATE en SQL? Modificar filas para principiantes
UPDATE es el comando de SQL para «cambiar datos en filas existentes». En palabras sencillas: qué cambiar, por qué WHERE es innegociable y cómo actualizar varias columnas a la vez. Tablas de antes/después, errores típicos de principiante, un repaso rápido y tres ejercicios prácticos al final.
¿Qué es DELETE en SQL? Eliminar filas para principiantes
DELETE es el comando de SQL para «eliminar filas de la tabla». En palabras sencillas: qué eliminar, por qué WHERE es innegociable, soft-delete frente a hard-delete, la diferencia con TRUNCATE y ON DELETE CASCADE. Tablas de antes/después, errores comunes, un repaso rápido y tres ejercicios prácticos.
UPSERT en PostgreSQL: INSERT ... ON CONFLICT en la práctica
Cómo insertar o actualizar en una sola sentencia con INSERT ... ON CONFLICT, usar EXCLUDED, escribir inserciones idempotentes y construir contadores atómicos.
MERGE en PostgreSQL 15+: MATCHED / NOT MATCHED, upserts y sincronización de tablas
Una mirada práctica a MERGE en PostgreSQL 15+: las ramas MATCHED y NOT MATCHED, los patrones de upsert y sincronización, y cuándo usarlo en lugar de ON CONFLICT.
INSERT ... ON CONFLICT DO NOTHING en PostgreSQL: inserciones idempotentes sin errores
Como ON CONFLICT DO NOTHING vuelve idempotente un INSERT, en que se diferencia un conflict target del nombre de una restriccion, por que RETURNING calla las filas omitidas y como sembrar datos por lotes.
RETURNING en PostgreSQL: obtener ids y filas modificadas sin un segundo viaje
Como la clausula RETURNING en INSERT/UPDATE/DELETE devuelve los ids generados y las columnas modificadas en un solo viaje, sin un SELECT extra.
DELETE ... USING en SQL: borrados con JOIN sin subconsulta
Como DELETE ... USING filtra filas contra otra tabla con un join, por que supera a WHERE IN con subconsulta y la forma multitabla de MySQL.
UPDATE ... FROM: actualizaciones masivas con join y subconsulta
Actualiza una tabla con datos de otra o de un agregado, evitando la trampa del WHERE ausente.
CTE + DELETE ... RETURNING: mover filas en una sola sentencia
Archiva y mueve filas de forma atomica con CTE que modifican datos, sin ventana de carrera entre DELETE e INSERT.
Estructura (DDL)
10 artículos¿Qué es CREATE TABLE en SQL? Crear una tabla para principiantes
CREATE TABLE es el comando de SQL para «crear una tabla nueva». En palabras sencillas: qué columnas y de qué tipos, qué hacen NOT NULL, DEFAULT, PRIMARY KEY y FOREIGN KEY, y por qué pensar en el esquema desde el principio merece la pena. Con tablas de antes/después, errores típicos de principiante y tres ejercicios.
¿Qué es ALTER TABLE en SQL? Cambiar la estructura de una tabla para principiantes
ALTER TABLE es el comando SQL para «cambiar la estructura de una tabla existente». En pocas palabras: añadir una columna, eliminarla, renombrarla, cambiar un tipo, añadir y quitar restricciones. Además, el principal dolor de cabeza en producción: los bloqueos prolongados de tablas y el patrón añadir → rellenar → eliminar para migraciones seguras.
Restricciones CHECK en SQL: invariantes en la base de datos
Usa CHECK para fijar reglas de negocio en el esquema: importes positivos, estados validos, rangos de fechas y validaciones multicolumna.
FOREIGN KEY ON DELETE: CASCADE, SET NULL y RESTRICT en la practica
Que ocurre con las filas hijas al borrar un padre y como elegir entre CASCADE, SET NULL, RESTRICT y NO ACTION sin perder datos.
NOT VALID + VALIDATE: anadir restricciones sin bloqueos largos
Anade una clave foranea o un CHECK a una tabla grande en dos pasos, sin detener las escrituras.
Columnas generadas en PostgreSQL: GENERATED ALWAYS AS STORED
Como mantener un valor derivado en un solo lugar con GENERATED ALWAYS AS (...) STORED, indexarlo y elegirlo frente a un trigger o una vista.
Indices UNIQUE parciales: unicidad sobre un subconjunto de filas
Impon unicidad solo sobre algunas filas: un registro activo por clave, re-registro tras un soft-delete y un unico default por grupo.
Particionado por rango en PostgreSQL: tablas de series temporales
Divide una tabla enorme por rango de fechas, elimina datos viejos en milisegundos y deja que el planificador lea solo las particiones necesarias.
Triggers en SQL: BEFORE/AFTER, NEW/OLD y el patron updated_at
Como funcionan los triggers BEFORE/AFTER y ROW/STATEMENT, que devuelve la funcion, el patron auto-updated_at, el log de auditoria y cuando estorban.
Vistas materializadas en SQL: cachear consultas costosas
Como una vista materializada cachea el resultado de una consulta pesada, como funciona REFRESH y cuando conviene una vista normal o una tabla resumen.
Cadenas y fechas
41 artículos¿Qué son LOWER, UPPER y LENGTH en SQL? Funciones de cadena para principiantes
Las funciones de cadena son una herramienta diaria de SQL: normalización de mayúsculas y minúsculas (LOWER, UPPER), longitud (LENGTH), recorte de espacios (TRIM), subcadenas (SUBSTRING), reemplazo (REPLACE). En pocas palabras: búsqueda insensible a mayúsculas, limpieza de datos y trampas con Unicode.
¿Qué es CONCAT en SQL? Concatenación de cadenas para principiantes
CONCAT significa «unir cadenas». En pocas palabras: tres formas (||, CONCAT, CONCAT_WS), cómo cada una trata el valor NULL de forma distinta y por qué CONCAT_WS es la mejor opción para direcciones y nombres. Con tablas y errores comunes.
¿Qué es EXTRACT en SQL? Año, mes y día de una fecha para principiantes
EXTRACT saca una parte de una fecha: año, mes, día, hora, día de la semana. En pocas palabras: cómo agrupar por año/mes, filtrar por día de la semana y contar segundos con EPOCH. Comparado con DATE_TRUNC y las diferencias entre PostgreSQL y MySQL.
DATE_TRUNC en SQL: redondear fechas a periodos para series temporales
Como DATE_TRUNC redondea una marca de tiempo hacia abajo a hora, dia, semana, mes o ano para agrupar series temporales.
NOW, CURRENT_DATE y aritmetica con INTERVAL en SQL
Como filtrar filas de los ultimos 7 dias y del mes actual con NOW(), CURRENT_DATE y aritmetica de INTERVAL en PostgreSQL, MySQL y ClickHouse.
Conversion de tipos en SQL: CAST y el operador :: en PostgreSQL
Como convertir tipos en SQL con CAST y el atajo ::, redondear numeric con cuidado, evitar errores de conversion y manejar las diferencias entre PostgreSQL, MySQL y ClickHouse.
TRIM, SUBSTRING y REPLACE: limpieza de cadenas en SQL
Como recortar espacios, extraer subcadenas y sustituir caracteres para construir claves normalizadas y quitar formato.
SPLIT_PART en PostgreSQL: dividir una cadena y tomar el campo N
Extrae el dominio de un email, un segmento de una ruta o un codigo de un SKU con una sola llamada a SPLIT_PART, y sus equivalentes en MySQL y ClickHouse.
ILIKE en PostgreSQL: busqueda sin distincion de mayusculas
Como funciona ILIKE en PostgreSQL, por que supera a lower(col) LIKE lower(...) y como acelerarlo con indices pg_trgm.
LEFT y RIGHT en SQL: primeros y ultimos caracteres de una cadena en PostgreSQL
Como LEFT y RIGHT toman los primeros o ultimos N caracteres de una cadena en PostgreSQL: enmascarar tarjetas, prefijos, longitud negativa y comparacion con SUBSTRING.
POSITION y STRPOS en SQL: encontrar el indice de una subcadena
Como encontrar la posicion de una subcadena en SQL con POSITION y STRPOS, por que el resultado empieza en 1, que significa 0 y como cortar con SUBSTRING.
LPAD y RPAD en SQL: rellenar cadenas hasta un ancho fijo
Como usar LPAD y RPAD para rellenar cadenas a un ancho fijo, hacer zero-padding de ids y numeros de factura, y construir columnas de ancho fijo para exportaciones.
INITCAP en PostgreSQL: poner en mayuscula cada palabra
Como INITCAP pone en mayuscula la primera letra de cada palabra en PostgreSQL, donde falla con apostrofos y guiones, y como imitarlo en MySQL.
REPEAT en SQL: repetir cadenas para separadores, placeholders y graficos de barras
Como REPEAT(str, n) repite una cadena n veces y por que es una herramienta util para separadores, placeholders y graficos de barras en SQL.
REVERSE en PostgreSQL: invertir cadenas, busqueda por sufijo y palindromos
Como REVERSE invierte una cadena caracter a caracter, habilita la busqueda por sufijo con indice, comprueba palindromos y maneja el multibyte.
char_length en SQL: contar caracteres, no bytes
char_length devuelve el numero de caracteres de una cadena, octet_length su tamano en bytes, y LENGTH cuenta caracteres o bytes segun PostgreSQL, MySQL o ClickHouse.
REGEXP_REPLACE en SQL: limpiar cadenas con expresiones regulares y los flags g e i
Como REGEXP_REPLACE sustituye subcadenas por patron, que hacen los flags g e i, como usar retroreferencias y donde difieren POSIX y PCRE.
REGEXP_MATCHES en PostgreSQL: grupos de captura y el flag g
Como REGEXP_MATCHES devuelve grupos de captura en un array, que hace el flag g y por que sin coincidencia se pierde la fila.
REGEXP_SPLIT_TO_ARRAY: dividir cadenas por un delimitador regex
Como dividir cadenas con una regex en un array o en filas, y por que supera a SPLIT_PART con datos sucios.
TRANSLATE en SQL: mapeo de caracteres, borrado y transliteracion
Como TRANSLATE asigna un conjunto de caracteres a otro, elimina los sobrantes y por que difiere de REPLACE.
BTRIM, LTRIM y RTRIM en SQL: recortar espacios y cualquier caracter
Como recortar espacios y caracteres arbitrarios en los bordes de una cadena con BTRIM, LTRIM y RTRIM y su relacion con TRIM.
La funcion FORMAT en SQL: plantillas de cadenas con %s, %I y %L en PostgreSQL
Como construir cadenas a partir de una plantilla con FORMAT en PostgreSQL: los especificadores %s, %I y %L, SQL dinamico seguro y por que supera a la concatenacion.
STARTS_WITH en PostgreSQL: una prueba de prefijo legible en vez de LIKE
Por que STARTS_WITH se lee mejor que LIKE 'x%', como trata mayusculas e indices, y como emularlo en MySQL y ClickHouse.
ascii y chr en SQL: codigos y caracteres
ascii() devuelve el punto de codigo del primer caracter y chr() arma un caracter a partir de un codigo; en PostgreSQL ambos manejan Unicode completo, mientras MySQL y ClickHouse difieren.
to_hex en PostgreSQL: convertir un entero en una cadena hexadecimal
Como to_hex(int) convierte un numero en cadena hex para colores, mascaras de bits y depuracion de flags, como invertirlo y como difieren MySQL y ClickHouse.
AGE en SQL: diferencias de fechas como intervalos y edad en anos
La funcion AGE de PostgreSQL devuelve la diferencia entre fechas como anos, meses y dias, no como dias sueltos.
DATE_PART en SQL: partes numericas de fecha, dia de la semana y campo dinamico
Como DATE_PART devuelve una parte numerica de la fecha, en que se diferencia de EXTRACT y por que dow numera el domingo como 0.
EXTRACT(EPOCH FROM ...) en SQL: duraciones en segundos y tiempo Unix
Como EXTRACT(EPOCH FROM ...) convierte un intervalo en segundos totales y una marca de tiempo en tiempo Unix, por que ambos casos difieren y como volver con to_timestamp.
TO_CHAR en SQL: formatear fechas y numeros como texto con plantillas
Como TO_CHAR convierte una fecha o un numero en texto con una plantilla: YYYY-MM-DD, HH24:MI, nombres de mes, separadores de miles y las diferencias con MySQL.
TO_DATE en PostgreSQL: convertir una cadena en fecha con plantilla
Como convertir una cadena en fecha con TO_DATE y una plantilla explicita, por que es mas fiable que un cast ::date, como cambio la validacion de rangos en PostgreSQL 16 y la trampa del ano de dos digitos.
TO_TIMESTAMP en SQL: parsear cadenas y construir timestamps desde el epoch Unix
Dos modos de TO_TIMESTAMP: parsear una cadena por plantilla a timestamptz o construir un momento desde segundos del epoch Unix, con sus matices de zona horaria.
CURRENT_TIMESTAMP y LOCALTIMESTAMP en SQL
En que se diferencian CURRENT_TIMESTAMP y LOCALTIMESTAMP, por que se congelan en la transaccion y cuando usar clock_timestamp().
CURRENT_DATE y CURRENT_TIME en SQL: la fecha de hoy y la hora actual
CURRENT_DATE y CURRENT_TIME son valores especiales de SQL sin parentesis: la fecha de hoy y la hora con su zona.
Aritmetica de fechas en SQL: sumar dias, restar fechas e intervalos
Como sumar enteros a fechas, restar fechas en dias y sumar intervalos a timestamps en PostgreSQL, MySQL y ClickHouse.
make_date y make_time en SQL: construir fechas y horas desde partes enteras
Como construir una fecha u hora desde columnas enteras separadas sin cadenas de formato y por que make_date valida partes fuera de rango.
make_timestamp y make_interval en SQL: construir fechas e intervalos por partes
make_timestamp arma una fecha a partir de numeros y make_interval construye un intervalo con argumentos con nombre en lugar de concatenar cadenas.
AT TIME ZONE en SQL: convertir UTC almacenado a la hora local del usuario
El doble comportamiento de AT TIME ZONE: sobre timestamptz devuelve la hora de pared local, sobre un timestamp naive lo interpreta en esa zona y devuelve timestamptz.
JUSTIFY_INTERVAL en PostgreSQL: normalizar intervalos en dias y meses
JUSTIFY_HOURS, JUSTIFY_DAYS y JUSTIFY_INTERVAL convierten un intervalo crudo en dias y meses legibles.
DATE_BIN en PostgreSQL: cubos de tiempo de ancho arbitrario para metricas
Como DATE_BIN de PostgreSQL 14 redondea una marca de tiempo al inicio de un cubo de ancho arbitrario desde un origen, y cuando gana a DATE_TRUNC.
El operador OVERLAPS en SQL: cruce de periodos y deteccion de conflictos
Como usar OVERLAPS para comprobar si dos periodos de tiempo se cruzan y detectar conflictos de reservas y turnos en PostgreSQL.
timestamptz frente a timestamp en SQL: guardar la hora bien
Por que los eventos casi siempre deben ser timestamptz, en que se diferencia del timestamp ingenuo y como evitar perder la zona en silencio al mezclarlos.
CASE y NULL
4 artículos¿Qué es CASE WHEN en SQL? Lógica condicional para principiantes
CASE WHEN es el "if/else dentro de SQL". En palabras sencillas: cómo poner condiciones directamente en SELECT, la diferencia entre el CASE de búsqueda y el CASE simple, agrupar números en categorías, pivotar con una sola fórmula y los agregados condicionales. Con tablas y errores comunes.
¿Qué es COALESCE en SQL? Manejar NULL para principiantes
COALESCE devuelve el primer valor no NULL de una lista. En palabras sencillas: valores por defecto para datos ausentes, cadenas de respaldo (apodo → nombre → 'Invitado'), aritmética segura y su combinación con NULLIF. Con tablas y errores comunes.
¿Qué es NULLIF en SQL? División segura y limpieza de datos para principiantes
NULLIF devuelve NULL si dos valores son iguales. En palabras sencillas: división segura mediante NULLIF(x, 0), limpieza de valores marcadores como '' o 'unknown', y su combinación con COALESCE para un manejo limpio de los datos. Con tablas y errores comunes.
NULL e IS DISTINCT FROM: comparacion segura con NULL en SQL
Por que = NULL nunca es verdadero y como IS DISTINCT FROM ofrece igualdad segura con NULL.
Otros
53 artículosEl operador JSONB @> en PostgreSQL: contencion de documentos y aceleracion con GIN
Como el operador @> comprueba si un documento JSONB contiene un fragmento, coincide objetos anidados y miembros de arrays, usa un indice GIN y se diferencia de ->>.
ROUND(x, n) en SQL: redondear a decimales, n negativo y formatear moneda
Como ROUND(x, n) redondea a n decimales, que hace un n negativo y por que PostgreSQL exige numeric en lugar de double precision en la forma de dos argumentos.
Indexar JSONB con GIN: jsonb_ops frente a jsonb_path_ops
Como acelerar los filtros sobre JSONB en PostgreSQL con indices GIN y cuando elegir jsonb_path_ops en lugar de la clase por defecto.
Indices compuestos en SQL: regla del prefijo izquierdo y orden de columnas
Como funciona un indice compuesto con la regla del prefijo izquierdo, como ordenar columnas para filtro, orden y rango, y cuando supera a dos indices simples.
Predicados sargables: como escribir un WHERE amigable con los indices
Por que envolver una columna en una funcion anula el indice y como reescribir el WHERE en rangos para que PostgreSQL lo use.
ROUND en SQL: redondear al entero mas cercano, redondeo bancario y dinero
Como ROUND redondea al entero mas cercano, por que half-away-from-zero difiere del redondeo bancario y por que numeric supera a double para dinero.
CEIL y CEILING en SQL: redondear hacia arriba al entero
Como CEIL/CEILING redondea hacia arriba, calcula paginas de paginacion y crea buckets, y en que se diferencia de FLOOR y ROUND.
Borrar en JSONB en PostgreSQL: los operadores - y #-
Como los operadores - y #- eliminan claves, elementos de array y valores anidados de un JSONB.
JSONB_BUILD_OBJECT en PostgreSQL: construir un objeto JSON a partir de columnas con tipos
Construye un objeto JSON a partir de pares clave/valor con tipos preservados, da forma a payloads por fila, anida objetos y arrays y compara con to_jsonb.
jsonb_build_array en PostgreSQL: arrays JSON con valores de tipos mixtos
Como armar arrays JSON con argumentos de cualquier tipo, anidarlos con jsonb_build_object y no confundirlos con to_jsonb de un array SQL.
Operadores flecha de JSONB: -> y ->> en PostgreSQL
Como funcionan -> y ->>: leer campos de objeto y elementos de array, descender por estructuras anidadas encadenando y convertir el resultado al tipo correcto.
ABS en SQL: valor absoluto, diferencias y comprobaciones con tolerancia
Como ABS calcula la magnitud, mide la diferencia entre dos valores, sirve en WHERE con tolerancia y se combina con SIGN.
jsonb_array_length en PostgreSQL: contar elementos de un array JSON sin errores
Como jsonb_array_length cuenta elementos de un array JSON, por que lanza el error non-array, como protegerlo con jsonb_typeof y filtrar filas por tamano.
jsonb_array_elements: expandir un array JSON en filas en PostgreSQL
Como expandir un array JSON en una fila por elemento, filtrar y unir por elementos, obtener el indice con WITH ORDINALITY y cuando usar la variante _text.
EXP y LN en SQL: exponencial, logaritmo natural y medias geometricas
Como EXP y LN calculan e^x y el logaritmo natural, por que el par log/exp sirve para medias geometricas y tasas de crecimiento, y por que LN(0) falla.
JSONB_AGG en PostgreSQL: agrupar filas en un array JSON para tus JSON APIs
Convierte las filas de un grupo en un array JSON con ORDER BY y FILTER, anida un documento con una subconsulta correlacionada y reemplaza el grupo vacio por '[]'.
FLOOR en SQL: redondear hacia abajo al entero anterior y agrupar en buckets
Como FLOOR redondea un numero hacia abajo al entero anterior, por que los negativos se alejan de cero y en que se diferencia de TRUNC.
UNION y UNION ALL en SQL: combinar resultados de consultas
En que se diferencian UNION y UNION ALL, que reglas de compatibilidad de columnas debes seguir y como ordenar el resultado combinado.
GREATEST y LEAST en SQL: maximo y minimo por fila entre columnas
Como GREATEST y LEAST devuelven el maximo y el minimo dentro de una fila, acotan un valor a un rango y tratan los NULL de forma distinta en PostgreSQL, MySQL y ClickHouse.
Division entera en SQL: DIV, MOD y la trampa del casting
Como funciona la division entera en PostgreSQL y MySQL, cuando usar DIV y como combinarla con MOD para obtener cociente y resto a la vez.
INTERSECT en SQL: filas presentes en ambas consultas
Como el operador INTERSECT encuentra filas comunes a dos consultas, en que se diferencia de INTERSECT ALL y cuando conviene un JOIN o EXISTS.
EXCEPT en SQL: diferencia de conjuntos y el equivalente MINUS de Oracle
Como EXCEPT devuelve las filas de la primera consulta que no estan en la segunda, en que se diferencia de EXCEPT ALL y cuando conviene NOT EXISTS.
Extraer JSONB como texto: el operador ->> en PostgreSQL
Como obtener un campo escalar de JSONB como texto con ->>, en que se diferencia de ->, como convertir el resultado y filtrar por campos JSON.
CREATE INDEX CONCURRENTLY: indexar sin downtime en PostgreSQL
Como construir un indice sobre una tabla caliente sin un bloqueo de escritura pesado y que hacer con el indice INVALID que deja una construccion fallida.
EXPLAIN (ANALYZE, BUFFERS) en PostgreSQL: leer el plan real de la consulta
Como leer EXPLAIN (ANALYZE, BUFFERS): filas y tiempo reales frente a estimados, loops, y la brecha que delata estadisticas obsoletas o un indice ausente.
SELECT ... FOR UPDATE: bloqueo pesimista de filas en SQL
Como bloquear filas con SELECT ... FOR UPDATE, evitar interbloqueos y construir una transferencia de dinero correcta.
UPDATE condicional en SQL: comprobacion y escritura atomica con WHERE
Codifica una precondicion en el WHERE de un solo UPDATE, detecta el fallo por el numero de filas afectadas y evita perdidas de actualizaciones: compare-and-swap en SQL.
Contador atomico: UPDATE SET n = n + 1 sin perder actualizaciones
Por que read-modify-write pierde incrementos bajo carga y como un solo UPDATE SET n = n + 1 mantiene el contador correcto en concurrencia.
GRANT en SQL: privilegios sobre tablas, esquemas y columnas con minimo privilegio
Como otorgar privilegios sobre tablas, esquemas y columnas con GRANT, la diferencia entre privilegios de objeto y pertenencia a rol, y como disenar acceso con minimo privilegio.
REVOKE en SQL: revocar privilegios concedidos de forma segura
Como usar REVOKE para retirar privilegios concedidos, manejar CASCADE y RESTRICT y no olvidar el acceso via PUBLIC y roles.
CREATE ROLE en PostgreSQL: usuarios, grupos y herencia de permisos
Como una sola sentencia CREATE ROLE modela personas y grupos: LOGIN frente a NOLOGIN, pertenencia a roles, herencia y atributos como CREATEDB.
Rol de solo lectura en PostgreSQL: permisos correctos para analitica y BI
Como crear un rol de solo lectura para analistas: USAGE sobre el esquema, SELECT sobre las tablas y ALTER DEFAULT PRIVILEGES para las tablas futuras.
WIDTH_BUCKET en SQL: histogramas de ancho fijo y distribuciones
Como WIDTH_BUCKET reparte valores en intervalos de ancho fijo, gestiona los bordes y construye distribuciones con GROUP BY.
TRUNC en SQL: descartar la parte decimal hacia cero sin redondear
Como TRUNC descarta la parte decimal hacia cero, como TRUNC(x, n) recorta a un numero de decimales y por que difiere de FLOOR en negativos.
to_jsonb en PostgreSQL: convertir una fila entera en un objeto JSON
Como to_jsonb convierte cualquier valor, fila o array en jsonb conservando los tipos, y en que se diferencia de json_build_object y row_to_json.
SQRT en SQL: raiz cuadrada, distancia euclidea y desviacion estandar
Como se comporta SQRT en PostgreSQL, por que un argumento negativo falla y como calcular distancia euclidea y desviacion estandar a mano.
SIGN en SQL: el signo de un numero y ramificar por direccion
Como SIGN devuelve -1/0/1, como ramificar por direccion del cambio y por que combinar SIGN con ABS.
La funcion POWER en SQL: potencias, raices y crecimiento compuesto
Como usar POWER para potencias, raices fraccionarias y calculos de crecimiento compuesto en PostgreSQL, MySQL y ClickHouse.
MOD y el operador % en SQL: el resto de la division en la practica
Como MOD y el operador % calculan el resto: par/impar, cada N-esima fila, sharding por id y la regla del signo con negativos.
LOG en SQL: logaritmo en base 10 y base arbitraria, y la trampa de MySQL
Como funcionan LOG(x) en base 10 y LOG(b, x) en base arbitraria en PostgreSQL, por que LOG en MySQL es una trampa y donde sirven en la practica.
JSONB_TYPEOF en PostgreSQL: trabajar con JSON dinamico sin romper
Como jsonb_typeof devuelve el tipo de un valor JSON como texto y protege jsonb_array_length, la aritmetica y la validacion de datos.
JSONB_SET en PostgreSQL: actualizar un campo dentro de un documento JSON
Reemplaza un valor por ruta en JSONB, anade una clave ausente con create_missing, actualiza un campo anidado con UPDATE y elimina claves con el operador menos.
jsonb_pretty en PostgreSQL: salida JSONB legible
Como formatear JSONB con sangria usando jsonb_pretty para depurar en psql y cuando no hacerlo.
Operadores de ruta JSONB en PostgreSQL: #> y #>> para valores anidados
Como leer valores JSONB profundamente anidados en PostgreSQL con los operadores de ruta #> y #>>, mezclar claves e indices y cuando usar jsonb_path_query.
JSONB_OBJECT_KEYS en PostgreSQL: obtener las claves de un objeto JSON como filas
Expande las claves de nivel superior de un objeto JSONB en filas, descubre la forma de tus datos, comprueba que campos existen y reunelos con array_agg.
Operadores de existencia de claves JSONB en PostgreSQL: ?, ?| y ?&
Como comprobar claves en JSONB con ?, ?| y ?&, acelerarlo con un indice GIN y evitar la trampa de los marcadores de posicion.
JSONB_EACH en PostgreSQL: expande un objeto JSON en filas clave-valor
Usa jsonb_each para expandir un objeto JSON en filas (clave, valor), recorrer claves dinamicas, filtrar y agregar entradas, y saber cuando usar la variante _text.
El operador JSONB || en PostgreSQL: fusionar documentos y aplicar parches
Como el operador || hace una fusion superficial de JSONB donde ganan las claves de la derecha, anade a un array y aplica un parche parcial en una sola expresion.
RANDOM() en SQL: muestreo aleatorio, enteros y semillas
Como funciona RANDOM() en PostgreSQL, por que ORDER BY RANDOM() es lento a gran escala y con que sustituirlo.
NOT EXISTS frente a NOT IN: la trampa de NULL y los anti-joins
Por que NOT IN devuelve vacio en silencio cuando el subconsulta tiene un NULL, y cuando elegir NOT EXISTS o LEFT JOIN ... IS NULL.
Índices parciales en PostgreSQL: indexar solo las filas calientes
Cómo CREATE INDEX ... WHERE te permite cubrir solo las filas activas para lograr un índice más pequeño y rápido, además de un UNIQUE parcial que convive bien con los borrados lógicos.
Cómo leer planes de consulta: EXPLAIN y EXPLAIN (ANALYZE, BUFFERS)
Una guía práctica sobre los planes de consulta de PostgreSQL: Seq Scan frente a Index Scan, filas estimadas frente a reales y cómo detectar un índice ausente.
Colas de tareas en SQL: SELECT ... FOR UPDATE SKIP LOCKED
Cómo hacer que una decena de workers extraigan tareas de una tabla de cola sin bloquearse entre sí, usando FOR UPDATE SKIP LOCKED en PostgreSQL.