Las funciones de fecha y hora de SQL te permiten obtener la fecha actual, extraer partes como el año o el mes, sumar o restar tiempo, medir la distancia entre dos fechas y agrupar filas por día, semana o mes, pero los nombres de las funciones cambian entre PostgreSQL, MySQL, SQL Server y SQLite.
Casi todo conjunto de datos real tiene fechas: cuándo se hizo un pedido, cuándo se cerró un ticket, cuándo se registró un usuario. Preguntas como “¿cuántos pedidos tuvimos el mes pasado?” o “¿cuánto tarda el envío?” dependen de manejar bien las fechas. Esta guía es para principiantes y analistas que conocen lo básico de SELECT, WHERE y GROUP BY y quieren trabajar con seguridad con fechas. Cada sección muestra primero la idea, luego la sintaxis de las cuatro bases de datos más comunes, y una hoja de referencia cerca del final las pone lado a lado.
Cómo Guardan las Bases de Datos las Fechas y las Horas
La mayoría de las bases de datos tiene tipos separados para fechas y horas:
| Tipo | Guarda | Ejemplo |
|---|---|---|
DATE | Una fecha de calendario | 2026-03-15 |
TIME | Una hora del día | 14:30:00 |
TIMESTAMP / DATETIME | Una fecha y una hora | 2026-03-15 14:30:00 |
TIMESTAMP WITH TIME ZONE | Un momento en el tiempo, con manejo de zona horaria (el timestamptz de PostgreSQL) | 2026-03-15 14:30:00-08 |
Los nombres de los tipos y su comportamiento varían un poco. Por ejemplo, MySQL tiene DATETIME y TIMESTAMP, y SQLite no tiene un tipo de fecha real, así que guarda las fechas como texto, números o ambos.
Dos reglas te ahorran muchos problemas:
- Usa tipos de fecha reales, no texto. Una fecha guardada como
'03/15/2026'en una columna de texto se ordenará y comparará mal. Guarda las fechas en una columna de fecha o de marca de tiempo. - Escribe los valores de fecha en formato ISO:
AAAA-MM-DD(yAAAA-MM-DD HH:MM:SSpara marcas de tiempo). Es inequívoco y funciona en todas las bases de datos.04/05/2026podría significar 5 de abril o 4 de mayo.
Datos de Ejemplo para Esta Guía
Los ejemplos usan una pequeña tabla orders. En PostgreSQL puedes crearla así:
CREATE TABLE orders (
order_id INT,
customer_id INT,
order_date DATE,
shipped_at TIMESTAMP,
total DECIMAL(10,2)
);
INSERT INTO orders VALUES
(1, 10, '2026-01-05', '2026-01-07 10:00:00', 120.00),
(2, 11, '2026-01-20', '2026-01-23 16:30:00', 80.50),
(3, 10, '2026-02-02', '2026-02-03 09:15:00', 200.00),
(4, 12, '2026-02-28', '2026-03-02 11:00:00', 45.25),
(5, 11, '2026-03-01', '2026-03-04 14:45:00', 310.00),
(6, 10, '2026-03-15', NULL, 99.99);
El pedido 6 aún no se ha enviado, así que su shipped_at es NULL. Ese detalle importa más adelante. Para las otras bases de datos, la misma tabla funciona con pequeños cambios en los tipos, como DATETIME en MySQL y SQL Server, y columnas de texto en SQLite.
Hoja de Referencia: la Misma Tarea en Cuatro Bases de Datos
SQL tiene un estándar para fechas, pero cada base de datos agrega sus propias funciones. Ten esta tabla a la mano, y cada sección de abajo explica las piezas.
| Tarea | PostgreSQL | MySQL | SQL Server | SQLite |
|---|---|---|---|---|
| Fecha de hoy | CURRENT_DATE | CURDATE() | CAST(GETDATE() AS DATE) | date('now') |
| Fecha y hora actuales | NOW() | NOW() | GETDATE() o SYSDATETIME() | datetime('now') |
| Sumar 7 días | d + 7 o d + INTERVAL '7 days' | DATE_ADD(d, INTERVAL 7 DAY) | DATEADD(day, 7, d) | date(d, '+7 days') |
Días entre d1 y d2 | d2 - d1 | DATEDIFF(d2, d1) | DATEDIFF(day, d1, d2) | julianday(d2) - julianday(d1) |
| Obtener el año | EXTRACT(YEAR FROM d) | YEAR(d) | YEAR(d) | strftime('%Y', d) |
| Primer día del mes | DATE_TRUNC('month', d) | DATE_FORMAT(d, '%Y-%m-01') | DATETRUNC(month, d) (versiones recientes) o DATEFROMPARTS(YEAR(d), MONTH(d), 1) | date(d, 'start of month') |
| Último día del mes | (DATE_TRUNC('month', d) + INTERVAL '1 month' - INTERVAL '1 day')::date | LAST_DAY(d) | EOMONTH(d) | date(d, 'start of month', '+1 month', '-1 day') |
| Dar formato como texto | TO_CHAR(d, 'YYYY-MM-DD') | DATE_FORMAT(d, '%Y-%m-%d') | FORMAT(d, 'yyyy-MM-dd') | strftime('%Y-%m-%d', d) |
Los ejemplos de abajo usan primero la sintaxis de PostgreSQL y luego muestran las otras bases de datos donde difieren.
Obtener la Fecha y la Hora Actuales
-- PostgreSQL
SELECT CURRENT_DATE; -- fecha de hoy
SELECT NOW(); -- fecha y hora actuales
-- MySQL
SELECT CURDATE(), NOW();
-- SQL Server
SELECT CAST(GETDATE() AS DATE), GETDATE();
-- SQLite
SELECT date('now'), datetime('now');
Un uso común es un filtro como “pedidos de los últimos 30 días”:
SELECT order_id, order_date
FROM orders
WHERE order_date >= CURRENT_DATE - 30;
En PostgreSQL, restar un número entero a un DATE resta días. En otras bases de datos usa DATE_SUB, DATEADD o el date('now', '-30 days') de SQLite.
Una advertencia: “ahora” cambia cada vez que ejecutas la consulta. Si necesitas un informe repetible, usa una fecha fija en lugar de la fecha actual.
Extraer Partes de una Fecha
A menudo necesitas solo el año, el mes o el día:
SELECT
order_id,
EXTRACT(YEAR FROM order_date) AS order_year,
EXTRACT(MONTH FROM order_date) AS order_month,
EXTRACT(DAY FROM order_date) AS order_day
FROM orders;
Para 2026-03-15, las tres columnas devuelven 2026, 3 y 15. Otros campos que puedes extraer son el trimestre, la semana y el día de la semana (DOW en PostgreSQL, donde el domingo es 0).
En MySQL y SQL Server, YEAR(d), MONTH(d) y DAY(d) hacen lo mismo. SQL Server también tiene DATEPART(week, d) para otras partes. En SQLite usa strftime('%Y', d), strftime('%m', d) y así sucesivamente, y ten en cuenta que strftime devuelve texto.
Sumar y Restar Tiempo
-- PostgreSQL
SELECT DATE '2026-03-15' + 7; -- 2026-03-22
SELECT DATE '2026-03-15' + INTERVAL '7 days'; -- 2026-03-22 00:00:00
SELECT DATE '2026-03-15' - INTERVAL '1 month'; -- 2026-02-15 00:00:00
Sumar un entero a un DATE devuelve una fecha. Sumar un INTERVAL devuelve una marca de tiempo, así que convierte de nuevo con ::date si solo quieres la fecha.
-- MySQL
SELECT DATE_ADD('2026-03-15', INTERVAL 7 DAY);
SELECT DATE_SUB('2026-03-15', INTERVAL 1 MONTH);
-- SQL Server
SELECT DATEADD(day, 7, '2026-03-15');
SELECT DATEADD(month, -1, '2026-03-15');
-- SQLite
SELECT date('2026-03-15', '+7 days');
SELECT date('2026-03-15', '-1 month');
Las cuentas con meses pueden sorprenderte. ¿Qué fecha es un mes después del 31 de enero? Las bases de datos lo manejan de forma distinta, así que prueba las fechas de fin de mes cuando importe.
Calcular la Diferencia entre Dos Fechas
¿Cuántos días pasaron entre dos fechas? En PostgreSQL, restar dos valores DATE da un número entero de días:
SELECT DATE '2026-03-15' - DATE '2026-03-01'; -- 14
Para saber cuánto tardó cada pedido en enviarse, recuerda que shipped_at es una marca de tiempo y order_date es una fecha. Convierte primero la marca de tiempo a fecha:
SELECT
order_id,
shipped_at::date - order_date AS days_to_ship
FROM orders
WHERE shipped_at IS NOT NULL;
| order_id | days_to_ship |
|---|---|
| 1 | 2 |
| 2 | 3 |
| 3 | 1 |
| 4 | 2 |
| 5 | 3 |
Sin la conversión, restar una fecha a una marca de tiempo devuelve un intervalo (por ejemplo, 2 days 10:00:00), no un número simple de días.
Las otras bases de datos usan funciones:
-- MySQL: DATEDIFF(fin, inicio)
SELECT order_id, DATEDIFF(shipped_at, order_date) AS days_to_ship FROM orders;
-- SQL Server: DATEDIFF(unidad, inicio, fin)
SELECT order_id, DATEDIFF(day, order_date, shipped_at) AS days_to_ship FROM orders;
-- SQLite
SELECT order_id,
CAST(julianday(shipped_at) - julianday(order_date) AS INTEGER) AS days_to_ship
FROM orders;
Cuidado con el orden de los argumentos. El DATEDIFF(a, b) de MySQL es a - b, pero el DATEDIFF(day, a, b) de SQL Server es b - a. Intercambiarlos invierte el signo.
Para medir horas o minutos, trabaja con marcas de tiempo. En PostgreSQL:
SELECT EXTRACT(EPOCH FROM (TIMESTAMP '2026-03-15 14:30:00' - TIMESTAMP '2026-03-15 09:00:00')) / 3600;
-- 5.5 horas
PostgreSQL también tiene AGE(a, b), que devuelve un intervalo en años, meses y días. Por ejemplo, EXTRACT(YEAR FROM AGE(CURRENT_DATE, birth_date)) da la edad de una persona en años completos.
Agrupar por Mes, Semana o Año
Los informes suelen agrupar por un periodo. La herramienta para esto es “truncar” una fecha al inicio de su mes, semana o año.
-- PostgreSQL
SELECT
DATE_TRUNC('month', order_date)::date AS month,
SUM(total) AS revenue
FROM orders
GROUP BY 1
ORDER BY 1;
| month | revenue |
|---|---|
| 2026-01-01 | 200.50 |
| 2026-02-01 | 245.25 |
| 2026-03-01 | 409.99 |
DATE_TRUNC también acepta 'week', 'quarter', 'year', 'day' y 'hour'. Como el resultado es una fecha real, se ordena correctamente y funciona en gráficas.
En SQLite, strftime('%Y-%m', order_date) da 2026-01, 2026-02 y 2026-03. En MySQL, DATE_FORMAT(order_date, '%Y-%m-01') hace lo mismo. En SQL Server 2022 y posteriores está disponible DATETRUNC(month, order_date). En versiones anteriores, usa DATEFROMPARTS(YEAR(order_date), MONTH(order_date), 1).
Un error común es agrupar solo por el número del mes, EXTRACT(MONTH FROM order_date). Eso pone enero de 2025 y enero de 2026 en el mismo grupo. Agrupa por año y mes juntos, o trunca la fecha.
Cambio de un Mes al Siguiente
Combina el truncado de fechas con una función de ventana para comparar cada mes con el anterior. Consulta funciones de ventana en SQL para ver cómo funciona LAG.
WITH monthly AS (
SELECT
DATE_TRUNC('month', order_date)::date AS month,
SUM(total) AS revenue
FROM orders
GROUP BY 1
)
SELECT
month,
revenue,
LAG(revenue) OVER (ORDER BY month) AS previous_revenue,
ROUND(
100.0 * (revenue - LAG(revenue) OVER (ORDER BY month))
/ LAG(revenue) OVER (ORDER BY month), 1
) AS pct_change
FROM monthly
ORDER BY month;
| month | revenue | previous_revenue | pct_change |
|---|---|---|---|
| 2026-01-01 | 200.50 | ||
| 2026-02-01 | 245.25 | 200.50 | 22.3 |
| 2026-03-01 | 409.99 | 245.25 | 67.2 |
El primer mes no tiene mes anterior, así que esos valores son NULL.
Filtrar por Rango de Fechas
Los filtros de fechas son donde viven la mayoría de los errores con fechas. Usa este patrón: el inicio es inclusivo, el fin es exclusivo.
-- Pedidos hechos en febrero de 2026
SELECT order_id
FROM orders
WHERE order_date >= '2026-02-01'
AND order_date < '2026-03-01';
Esto devuelve los pedidos 3 y 4. El valor final es el primer día del mes siguiente, así que nunca tienes que averiguar si el mes tiene 28, 30 o 31 días.
Cuidado con BETWEEN y las Marcas de Tiempo
BETWEEN incluye ambos extremos, lo que funciona con fechas pero falla con marcas de tiempo. Una marca de tiempo escrita como '2026-03-04' significa la medianoche al inicio de ese día:
-- Parece "enviado del 1 al 4 de marzo", pero no lo es
SELECT order_id
FROM orders
WHERE shipped_at BETWEEN '2026-03-01' AND '2026-03-04';
Esto devuelve solo el pedido 4. El pedido 5 se envió el 2026-03-04 14:45, que es después de la medianoche del 4 de marzo, así que queda fuera. La versión segura usa el patrón de rango semiabierto:
SELECT order_id
FROM orders
WHERE shipped_at >= '2026-03-01'
AND shipped_at < '2026-03-05';
Esto devuelve los pedidos 4 y 5, como se quería.
No Envuelvas la Columna en una Función
Esto parece correcto, pero puede ser lento en una tabla grande:
-- Patrón lento: la función se ejecuta en cada fila y bloquea el uso del índice
SELECT order_id FROM orders WHERE EXTRACT(YEAR FROM order_date) = 2026;
Compara la columna tal cual con un rango, para que la base de datos pueda usar un índice:
SELECT order_id
FROM orders
WHERE order_date >= '2026-01-01'
AND order_date < '2027-01-01';
Para saber más sobre por qué se ralentizan las consultas y cómo arreglarlo, consulta por qué tu consulta SQL es lenta.
Dar Formato y Convertir Fechas
Usa el formato para mostrar y la conversión para pasar texto a fechas.
-- PostgreSQL
SELECT TO_CHAR(order_date, 'YYYY-MM-DD');
SELECT TO_CHAR(order_date, 'Month DD, YYYY');
SELECT TO_DATE('15/03/2026', 'DD/MM/YYYY');
-- MySQL
SELECT DATE_FORMAT(order_date, '%Y-%m-%d');
SELECT STR_TO_DATE('15/03/2026', '%d/%m/%Y');
-- SQL Server
SELECT FORMAT(order_date, 'yyyy-MM-dd');
SELECT CONVERT(date, '15/03/2026', 103);
-- SQLite
SELECT strftime('%Y-%m-%d', order_date);
Las cadenas de formato difieren en cada base de datos (YYYY frente a %Y frente a yyyy), así que búscalas para la tuya. Un buen hábito es hacer el análisis con fechas reales y dar formato solo al final, porque los valores con formato son texto y se ordenan alfabéticamente.
Cuando limpies texto de fechas desordenado, como formatos mezclados o fechas imposibles, consulta limpiar datos desordenados con SQL puro.
Zonas Horarias
Las zonas horarias son una fuente común de errores de un día.
- Guarda las marcas de tiempo en UTC y conviértelas a hora local cuando las muestres o agrupes. En PostgreSQL,
timestamptzlleva ese control por ti. - Agrupa por la zona horaria que usa tu negocio. Un pedido hecho a las 11 PM hora del Pacífico el 31 de marzo es el 1 de abril en UTC. Si agrupas por fecha UTC, cae en el mes equivocado para un negocio de California.
- Conoce la zona horaria de tu servidor.
NOW()devuelve la idea que tiene el servidor de la base de datos de la hora, que puede no ser la tuya.
En PostgreSQL, AT TIME ZONE convierte una marca de tiempo:
SELECT shipped_at AT TIME ZONE 'UTC' AT TIME ZONE 'America/Los_Angeles' FROM orders;
El comportamiento exacto depende de si la columna es timestamp o timestamptz, así que lee la documentación de tu base de datos antes de confiar en las conversiones.
Fechas NULL
Una fecha NULL significa “desconocida” o “todavía no”. Cualquier operación aritmética con NULL devuelve NULL, y las comparaciones con NULL nunca son verdaderas:
-- Pedidos que aún no se han enviado
SELECT order_id FROM orders WHERE shipped_at IS NULL;
Usa IS NULL e IS NOT NULL, no = NULL. Usa COALESCE(shipped_at, NOW()) si quieres tratar los pedidos sin enviar como “aún en tránsito a esta hora”, por ejemplo al medir el tiempo de espera.
Errores Comunes que Debes Evitar
- Guardar fechas como texto. Pierdes las cuentas con fechas y el orden correcto.
- Usar
BETWEENcon marcas de tiempo. El final del rango recorta la mayor parte del último día. - Envolver en una función una columna de fecha con índice en la cláusula
WHERE. - Agrupar por número de mes sin el año.
- Mezclar una fecha y una marca de tiempo en una resta, y obtener un intervalo donde esperabas un número.
- Intercambiar el orden de los argumentos de
DATEDIFF. - Ignorar las zonas horarias, de modo que los eventos de la noche caen en el día equivocado.
- Suponer que la función de una base de datos existe en otra.
DATE_TRUNC,DATEDIFFystrftimeno son universales. - Escribir fechas fijas en un informe que debería actualizarse, o usar “ahora” en un informe que debería ser repetible.
Preguntas Frecuentes
¿Cuál es la diferencia entre DATE, DATETIME y TIMESTAMP?
DATE guarda solo una fecha de calendario. DATETIME y TIMESTAMP guardan una fecha y una hora. En algunas bases de datos, como MySQL, TIMESTAMP además convierte desde y hacia UTC, mientras que DATETIME no. En PostgreSQL, timestamp no tiene zona horaria y timestamptz sí.
¿Cómo obtengo la fecha de hoy en SQL?
En PostgreSQL usa CURRENT_DATE. En MySQL usa CURDATE(). En SQL Server usa CAST(GETDATE() AS DATE). En SQLite usa date('now').
¿Cómo calculo el número de días entre dos fechas?
En PostgreSQL, resta las fechas (d2 - d1). En MySQL usa DATEDIFF(d2, d1). En SQL Server usa DATEDIFF(day, d1, d2). En SQLite resta sus valores de julianday.
¿Cómo agrupo los datos por mes?
Trunca la fecha al primero de su mes, con DATE_TRUNC('month', d) en PostgreSQL o el equivalente en tu base de datos, y agrupa por el resultado. Así los distintos años quedan separados.
¿Por qué mi filtro de fechas omite filas del último día?
Probablemente usas BETWEEN con una columna de marca de tiempo. Una marca de tiempo '2026-03-04' significa medianoche, así que las filas posteriores de ese día quedan excluidas. Usa >= para el inicio y < para el día siguiente al final.
¿Las funciones de fecha funcionan igual en todas las bases de datos?
No. Las ideas son las mismas, pero los nombres de las funciones, el orden de los argumentos y las cadenas de formato difieren. Usa la hoja de referencia de esta guía y revisa la documentación de tu base de datos.
Conclusión
Trabajar con fechas en SQL se reduce a unos pocos hábitos: guardar tipos de fecha reales, escribir las fechas en formato ISO, truncar para agrupar por periodo, usar un rango con inicio inclusivo y fin exclusivo en los filtros, y vigilar las zonas horarias y los NULL. Cuando esto te salga natural, preguntas como “ingresos por mes”, “días promedio de envío” y “clientes que no han comprado en 90 días” se vuelven consultas cortas y legibles. Practica con una tabla pequeña como la de esta guía y ten la hoja de referencia a la mano cuando cambies de base de datos. Si necesitas ayuda con análisis de datos o informes, puedes agendar una consulta gratis.
Los ejemplos con estilo PostgreSQL se ejecutaron con los datos de muestra en un motor compatible con PostgreSQL, y los de SQLite en SQLite. Los ejemplos de MySQL y SQL Server siguen la sintaxis documentada de esas bases de datos. Los nombres y el comportamiento de las funciones varían según la versión de la base de datos, así que revisa la documentación de la tuya antes de usarlos en producción.
Lecturas Relacionadas
- Funciones de Ventana en SQL: Totales Acumulados y Rankings
- Los JOINs de SQL Explicados: Guía para Principiantes
- Domina las Subconsultas en SQL: Guía de Principiante a Avanzado
- Por Qué Tu Consulta SQL Es Lenta (y Cómo Arreglarla)
- Limpiar Datos Desordenados con SQL Puro: Guía para Principiantes
- PostgreSQL para Principiantes: Guía Paso a Paso
- ¿Qué Es SQLite? Guía para Principiantes con Ejemplos en Python
