Tutorial SQL: Tipos de datos

Tipos numéricos

Los tipos de datos numéricos en SQL permiten almacenar valores numéricos con diferentes características de precisión, rango y uso de memoria. Estos tipos son fundamentales para representar información cuantitativa como cantidades, medidas, identificadores y cálculos en una base de datos.

Tipos enteros

Los tipos enteros almacenan números sin parte decimal y son ideales para contadores, identificadores y cantidades discretas.

• TINYINT: El tipo numérico más pequeño, ocupa 1 byte.
• MySQL: Rango de -128 a 127 (con signo) o 0 a 255 (sin signo)
• PostgreSQL: No incluye TINYINT nativo, usa SMALLINT como alternativa

-- MySQL: Columna para almacenar edad (valores pequeños)
edad TINYINT UNSIGNED

• SMALLINT: Ocupa 2 bytes, adecuado para números pequeños.
• Rango: -32,768 a 32,767 (con signo)
• MySQL permite versión sin signo (0 a 65,535)

-- Columna para almacenar cantidad de productos en stock
stock SMALLINT

• INTEGER/INT: El tipo entero estándar, ocupa 4 bytes.
• Rango: Aproximadamente -2.1 mil millones a 2.1 mil millones
• Equilibrio entre rango y uso de almacenamiento

-- Columna para almacenar población de ciudades
poblacion INT

• BIGINT: Para enteros muy grandes, ocupa 8 bytes.
• Rango: Aproximadamente -9.2 quintillones a 9.2 quintillones
• Ideal para identificadores únicos en tablas muy grandes

-- Columna para identificadores únicos en sistemas grandes
id_usuario BIGINT

Tipos decimales de precisión exacta

Estos tipos almacenan números con parte decimal y garantizan precisión exacta, fundamentales para datos financieros y cálculos que requieren exactitud.

• DECIMAL(p,s) o NUMERIC(p,s):
• p = precisión total (número total de dígitos)
• s = escala (número de dígitos decimales)
• Almacenamiento variable según la precisión configurada

-- Columna para almacenar precios (10 dígitos en total, 2 decimales)
precio DECIMAL(10,2)

En este ejemplo, DECIMAL(10,2) puede almacenar valores desde -99999999.99 hasta 99999999.99 con exactamente 2 decimales.

• Diferencias entre MySQL y PostgreSQL:
• En PostgreSQL, NUMERIC y DECIMAL son idénticos
• MySQL trata NUMERIC como sinónimo de DECIMAL, pero con implementación interna ligeramente diferente

-- PostgreSQL: Columna para cálculos científicos de alta precisión
medicion NUMERIC(15,6)

Tipos de punto flotante

Los tipos de punto flotante almacenan números con decimales utilizando notación científica, sacrificando precisión exacta por mayor rango.

• FLOAT: Precisión simple, ocupa 4 bytes.
• Aproximadamente 7 dígitos de precisión
• Rango aproximado: ±1.18E-38 a ±3.4E+38

-- Columna para almacenar coordenadas geográficas (latitud)
latitud FLOAT

• DOUBLE PRECISION o DOUBLE: Precisión doble, ocupa 8 bytes.
• Aproximadamente 15 dígitos de precisión
• Rango aproximado: ±2.23E-308 a ±1.79E+308

-- Columna para cálculos científicos que requieren mayor precisión
valor_calculado DOUBLE PRECISION

• REAL:
• En PostgreSQL: Equivalente a FLOAT, precisión simple (4 bytes)
• En MySQL: Sinónimo de DOUBLE (8 bytes)

-- PostgreSQL: Columna para mediciones científicas
temperatura REAL

Tipos especiales y consideraciones

• SERIAL (PostgreSQL): Entero con autoincremento.
• SMALLSERIAL (2 bytes), SERIAL (4 bytes), BIGSERIAL (8 bytes)
• Útil para crear identificadores únicos automáticos

-- PostgreSQL: Columna de ID autoincremental
id SERIAL PRIMARY KEY

• AUTO_INCREMENT (MySQL): Atributo para columnas enteras.
• No es un tipo de dato sino una propiedad
• Se aplica a columnas INT, BIGINT, etc.

-- MySQL: Columna de ID autoincremental
id INT AUTO_INCREMENT PRIMARY KEY

• Consideraciones de rendimiento:
• Los tipos más pequeños ocupan menos espacio en disco y memoria
• Las operaciones con DECIMAL son más lentas que con FLOAT/DOUBLE
• BIGINT consume más recursos que INT en operaciones e índices

Selección del tipo numérico adecuado

La elección del tipo numérico debe basarse en varios factores:

• Rango de valores: Selecciona el tipo más pequeño que pueda contener todos los valores posibles.
• Precisión requerida: Para cálculos financieros, usa DECIMAL. Para cálculos científicos donde la precisión exacta es menos importante, usa FLOAT/DOUBLE.
• Espacio de almacenamiento: Considera el impacto en el tamaño de la base de datos, especialmente para tablas grandes.
• Rendimiento: Las operaciones con tipos más pequeños son generalmente más rápidas.

-- Ejemplo de selección de tipos para una tabla de productos
CREATE TABLE productos (
    id INT PRIMARY KEY,           -- Identificador (valores moderados)
    codigo SMALLINT,              -- Código de producto (valores pequeños)
    precio DECIMAL(10,2),         -- Precio (precisión exacta para dinero)
    peso FLOAT,                   -- Peso (precisión aproximada suficiente)
    existencias INT,              -- Cantidad en stock (valores moderados)
    valoracion DECIMAL(3,1)       -- Valoración de 0 a 10 con un decimal
);

Conversión entre tipos numéricos

SQL permite la conversión (casting) entre diferentes tipos numéricos:

-- PostgreSQL: Conversión explícita
SELECT CAST(precio AS FLOAT) FROM productos;
-- o usando la sintaxis ::
SELECT precio::FLOAT FROM productos;

-- MySQL: Conversión explícita
SELECT CAST(precio AS DOUBLE) FROM productos;
-- o usando CONVERT
SELECT CONVERT(precio, DOUBLE) FROM productos;

Es importante tener en cuenta que la conversión de un tipo de mayor precisión a uno de menor precisión puede resultar en pérdida de datos o precisión.

Tipos de texto

Los tipos de datos de texto en SQL permiten almacenar cadenas de caracteres, desde simples etiquetas hasta documentos extensos. Estos tipos son esenciales para manejar nombres, descripciones, direcciones y cualquier información textual en una base de datos.

Tipos de longitud fija

Los tipos de longitud fija reservan siempre el mismo espacio de almacenamiento, independientemente del contenido real.

• CHAR(n): Almacena cadenas de texto de longitud fija.
• n = número máximo de caracteres (entre 1 y 255)
• Si el texto es más corto que n, se rellena con espacios
• Ocupa exactamente n caracteres de almacenamiento

-- Columna para códigos postales (siempre 5 caracteres)
codigo_postal CHAR(5)

• Diferencias entre MySQL y PostgreSQL:
• MySQL: Elimina automáticamente los espacios finales al recuperar valores CHAR
• PostgreSQL: Preserva los espacios finales en valores CHAR

-- MySQL vs PostgreSQL
-- Si almacenamos 'ABC' en un campo CHAR(5):
-- MySQL devolverá 'ABC' (sin espacios)
-- PostgreSQL devolverá 'ABC  ' (con espacios)

Tipos de longitud variable

Los tipos de longitud variable ajustan su tamaño de almacenamiento según el contenido real, lo que los hace más eficientes para texto de longitud impredecible.

• VARCHAR(n) o CHARACTER VARYING(n):
• n = longitud máxima (1-65,535 en MySQL, 1-10,485,760 en PostgreSQL)
• Almacena solo los caracteres utilizados más algunos bytes de sobrecarga
• Ideal para texto de longitud variable pero con límite conocido

-- Columna para nombres de usuario (máximo 50 caracteres)
nombre_usuario VARCHAR(50)

• TEXT: Para almacenar grandes cantidades de texto sin límite práctico.
• No requiere especificar longitud máxima
• MySQL: Hasta 65,535 caracteres (aproximadamente 64KB)
• PostgreSQL: Hasta 1GB

-- Columna para almacenar descripciones largas de productos
descripcion TEXT

• Variantes de TEXT en PostgreSQL:
• TEXT: Tipo estándar, sin límite práctico (hasta 1GB)
• PostgreSQL ofrece tipos adicionales:
• VARCHAR sin especificar longitud: Equivalente a TEXT

-- PostgreSQL: Equivalentes en la práctica
descripcion_1 TEXT,
descripcion_2 VARCHAR -- Sin especificar longitud, equivale a TEXT

• Variantes de TEXT en MySQL:
• TINYTEXT: Hasta 255 caracteres
• TEXT: Hasta 65,535 caracteres
• MEDIUMTEXT: Hasta 16,777,215 caracteres (aproximadamente 16MB)
• LONGTEXT: Hasta 4,294,967,295 caracteres (aproximadamente 4GB)

-- MySQL: Columnas para diferentes volúmenes de texto
resumen TINYTEXT,           -- Para textos muy cortos
descripcion TEXT,           -- Para descripciones estándar
contenido MEDIUMTEXT,       -- Para artículos o posts
documento_completo LONGTEXT -- Para documentos muy extensos

Tipos para caracteres especiales y Unicode

Para almacenar texto en múltiples idiomas o con caracteres especiales, SQL ofrece tipos específicos que soportan Unicode.

• Conjuntos de caracteres en MySQL:
• Se pueden especificar con CHARACTER SET
• Los más comunes son:
• utf8mb4: Soporta todos los caracteres Unicode (incluyendo emojis)
• utf8: Soporta la mayoría de caracteres Unicode (3 bytes por carácter)
• latin1: Para idiomas de Europa occidental

-- MySQL: Columna para nombres en cualquier idioma
nombre VARCHAR(100) CHARACTER SET utf8mb4

• Soporte Unicode en PostgreSQL:
• PostgreSQL soporta Unicode nativamente
• Tipos específicos:
• VARCHAR: Soporta Unicode por defecto
• TEXT: Soporta Unicode por defecto

-- PostgreSQL: No es necesario especificar el conjunto de caracteres
comentario TEXT -- Ya soporta Unicode

Tipos para datos binarios

Para almacenar datos binarios como imágenes, archivos o cualquier contenido no textual, SQL ofrece tipos específicos.

• BINARY(n) y VARBINARY(n) en MySQL:
• Similares a CHAR y VARCHAR pero para datos binarios
• Almacenan bytes en lugar de caracteres

-- MySQL: Columna para almacenar una clave hash de 16 bytes
hash_md5 BINARY(16)

• BYTEA en PostgreSQL:
• Equivalente a VARBINARY en MySQL
• Para almacenar datos binarios de longitud variable

-- PostgreSQL: Columna para almacenar una imagen pequeña
imagen_miniatura BYTEA

• BLOB en MySQL (Binary Large Object):
• TINYBLOB: Hasta 255 bytes
• BLOB: Hasta 65,535 bytes
• MEDIUMBLOB: Hasta 16,777,215 bytes
• LONGBLOB: Hasta 4,294,967,295 bytes

-- MySQL: Columna para almacenar un archivo PDF
documento_pdf MEDIUMBLOB

Tipos especializados

Algunos tipos de texto están optimizados para usos específicos, mejorando el rendimiento en determinados escenarios.

• ENUM en MySQL:
• Define una lista de valores posibles
• Internamente almacena valores como números
• Más eficiente que VARCHAR para conjuntos fijos de opciones

-- MySQL: Columna para estado de un pedido
estado ENUM('pendiente', 'procesando', 'enviado', 'entregado', 'cancelado')

• SET en MySQL:
• Similar a ENUM pero permite múltiples valores
• Puede almacenar cualquier combinación de la lista definida

-- MySQL: Columna para características de un producto
caracteristicas SET('resistente_agua', 'bluetooth', 'bateria_larga', 'pantalla_tactil')

• PostgreSQL y tipos enumerados:
• PostgreSQL usa tipos personalizados en lugar de ENUM
• Se crean con la sentencia CREATE TYPE

-- PostgreSQL: Crear tipo enumerado y usarlo
CREATE TYPE estado_pedido AS ENUM ('pendiente', 'procesando', 'enviado', 'entregado', 'cancelado');

-- Usar el tipo creado
CREATE TABLE pedidos (
    id SERIAL PRIMARY KEY,
    estado estado_pedido
);

Consideraciones de rendimiento y almacenamiento

La elección del tipo de texto adecuado afecta significativamente al rendimiento y espacio de almacenamiento:

• Indexación:
• Los campos CHAR y VARCHAR pequeños son más eficientes para índices
• Los campos TEXT generalmente no se pueden indexar completamente

-- Índice en un campo VARCHAR (eficiente)
CREATE INDEX idx_nombre ON usuarios(nombre);

-- Índice parcial en un campo TEXT (menos eficiente)
CREATE INDEX idx_descripcion ON productos(descripcion(100));

• Almacenamiento:
• CHAR siempre usa espacio fijo, incluso para valores cortos
• VARCHAR usa solo el espacio necesario más algunos bytes de sobrecarga
• TEXT/BLOB pueden almacenarse fuera de la fila principal de la tabla

-- Comparación de espacio usado
-- Para almacenar "ABC":
-- CHAR(10): Usa 10 bytes
-- VARCHAR(10): Usa aproximadamente 4 bytes (3 + sobrecarga)

Selección del tipo de texto adecuado

Para elegir el tipo de texto más apropiado, considera estos factores:

• Longitud conocida y constante: Usa CHAR para valores de longitud fija como códigos.
• Longitud variable pero limitada: Usa VARCHAR para la mayoría de los datos de texto.
• Texto extenso sin límite claro: Usa TEXT para contenido largo como artículos o descripciones.
• Conjunto limitado de valores: Usa ENUM (MySQL) o tipos enumerados (PostgreSQL).
• Soporte multilingüe: Asegúrate de usar tipos con soporte Unicode.

-- Ejemplo de selección de tipos para una tabla de productos
CREATE TABLE productos (
    id INT PRIMARY KEY,
    sku CHAR(10),                 -- Código de producto (longitud fija)
    nombre VARCHAR(100),          -- Nombre (longitud variable pero limitada)
    descripcion_corta VARCHAR(255), -- Resumen breve
    descripcion_completa TEXT,    -- Descripción detallada (potencialmente larga)
    categoria VARCHAR(50),        -- Categoría del producto
    etiquetas VARCHAR(200)        -- Lista de etiquetas separadas por comas
);

Conversión entre tipos de texto

SQL permite convertir entre diferentes tipos de texto cuando sea necesario:

-- PostgreSQL: Conversión de TEXT a VARCHAR
SELECT CAST(descripcion_completa AS VARCHAR(100)) FROM productos;

-- MySQL: Conversión de CHAR a VARCHAR
SELECT CONVERT(sku, CHAR) FROM productos;

Al convertir entre tipos, ten en cuenta que puede haber truncamiento si el tipo destino es más pequeño que el contenido original.

Tipos de fecha/hora

Los tipos de datos de fecha y hora en SQL permiten almacenar momentos temporales, desde fechas simples hasta marcas de tiempo precisas con zona horaria. Estos tipos son fundamentales para registrar cuándo ocurren eventos, gestionar calendarios, calcular duraciones y realizar análisis temporales en bases de datos.

Tipo DATE

El tipo DATE almacena únicamente información de fecha (año, mes y día), sin componente horario.

• Formato estándar: 'YYYY-MM-DD'
• Rango:
• MySQL: '1000-01-01' a '9999-12-31'
• PostgreSQL: '4713 BC' a '5874897 AD'
• Almacenamiento: 3 bytes en MySQL, 4 bytes en PostgreSQL

-- Columna para almacenar fechas de nacimiento
fecha_nacimiento DATE

-- Ejemplos de inserción de fechas
INSERT INTO empleados (nombre, fecha_nacimiento) VALUES ('Ana García', '1985-03-15');

Tipo TIME

El tipo TIME almacena únicamente la hora del día, sin componente de fecha.

• Formato estándar: 'HH:MM:SS'
• Características:
• MySQL: Puede incluir microsegundos y admite rangos más allá de 24 horas
• PostgreSQL: Precisión de microsegundos

-- Columna para horarios de apertura de tiendas
hora_apertura TIME

• Diferencias entre sistemas:
• MySQL: Rango de '-838:59:59' a '838:59:59', permite representar duraciones
• PostgreSQL: Rango de '00:00:00' a '24:00:00', enfocado en horas del día

-- MySQL: Almacenando duración de un proceso
duracion_proceso TIME -- Puede almacenar '45:30:00' (45 horas, 30 minutos)

-- PostgreSQL: Hora del día
hora_reunion TIME -- Almacena '14:30:00' (2:30 PM)

Tipo DATETIME y TIMESTAMP

Estos tipos combinan fecha y hora, permitiendo registrar momentos específicos en el tiempo.

• DATETIME (MySQL) / TIMESTAMP (estándar SQL):
• Formato: 'YYYY-MM-DD HH:MM:SS'
• Pueden incluir fracciones de segundo (microsegundos)

-- Columna para registrar cuándo se realizó un pedido
fecha_pedido DATETIME -- MySQL
momento_pedido TIMESTAMP -- PostgreSQL

• Diferencias clave:

• MySQL:

• DATETIME: Rango '1000-01-01 00:00:00' a '9999-12-31 23:59:59', 8 bytes

• TIMESTAMP: Rango '1970-01-01 00:00:01' a '2038-01-19 03:14:07', 4 bytes, se convierte automáticamente a UTC al almacenar

• PostgreSQL:

• TIMESTAMP: Equivalente al DATETIME de MySQL, rango amplio

• TIMESTAMPTZ: TIMESTAMP con zona horaria

-- MySQL: Registro de creación y modificación
fecha_creacion DATETIME,
fecha_modificacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP

-- PostgreSQL: Con y sin zona horaria
creado_en TIMESTAMP, -- Sin zona horaria
actualizado_en TIMESTAMPTZ -- Con zona horaria

Soporte de zona horaria

El manejo de zonas horarias es crucial para aplicaciones que operan globalmente.

• PostgreSQL: Soporte nativo con el tipo TIMESTAMPTZ
• Almacena internamente en UTC
• Convierte automáticamente a la zona horaria del cliente al recuperar

-- PostgreSQL: Almacenamiento con zona horaria
momento_login TIMESTAMPTZ

-- Inserción especificando zona horaria
INSERT INTO sesiones (usuario_id, momento_login) 
VALUES (1, '2023-05-15 14:30:00 America/New_York');

• MySQL: Soporte limitado en versiones anteriores a 8.0
• MySQL 8.0+ incluye tipos TIMESTAMP y DATETIME con conversión de zona horaria

-- MySQL 8.0+: Convertir entre zonas horarias
SELECT CONVERT_TZ(fecha_registro, 'UTC', 'America/Mexico_City') 
FROM registros;

Tipos especiales y variantes

Algunos sistemas ofrecen tipos adicionales para casos de uso específicos.

• INTERVAL (PostgreSQL):
• Almacena períodos de tiempo (no momentos específicos)
• Útil para cálculos de duración

-- PostgreSQL: Almacenar duración de una suscripción
duracion_suscripcion INTERVAL

-- Ejemplo de uso en consulta
SELECT nombre, fecha_inicio + duracion_suscripcion AS fecha_fin
FROM suscripciones;

• YEAR (MySQL):
• Tipo especializado que almacena solo el año
• Ocupa 1 byte, rango de 1901 a 2155

-- MySQL: Almacenar año de graduación
anio_graduacion YEAR

Funciones de fecha y hora

SQL ofrece numerosas funciones para manipular y calcular con fechas y horas.

• Funciones para obtener la fecha/hora actual:

-- MySQL
SELECT 
    NOW(),           -- Fecha y hora actuales: '2023-06-15 14:30:45'
    CURDATE(),       -- Solo fecha actual: '2023-06-15'
    CURTIME();       -- Solo hora actual: '14:30:45'

-- PostgreSQL
SELECT 
    CURRENT_TIMESTAMP,  -- Fecha y hora con zona horaria
    CURRENT_DATE,       -- Solo fecha actual
    CURRENT_TIME;       -- Hora actual con zona horaria

• Extracción de componentes:

-- MySQL
SELECT 
    YEAR(fecha_nacimiento),    -- Extrae el año
    MONTH(fecha_nacimiento),   -- Extrae el mes (1-12)
    DAY(fecha_nacimiento)      -- Extrae el día
FROM empleados;

-- PostgreSQL
SELECT 
    EXTRACT(YEAR FROM fecha_nacimiento),
    EXTRACT(MONTH FROM fecha_nacimiento),
    EXTRACT(DAY FROM fecha_nacimiento)
FROM empleados;

• Cálculos con fechas:

-- MySQL: Añadir intervalos
SELECT 
    fecha_inicio,
    DATE_ADD(fecha_inicio, INTERVAL 30 DAY) AS fecha_vencimiento
FROM prestamos;

-- PostgreSQL: Añadir intervalos
SELECT 
    fecha_inicio,
    fecha_inicio + INTERVAL '30 days' AS fecha_vencimiento
FROM prestamos;

• Diferencia entre fechas:

-- MySQL: Diferencia en días
SELECT DATEDIFF(fecha_fin, fecha_inicio) AS dias_transcurridos
FROM proyectos;

-- PostgreSQL: Diferencia como intervalo
SELECT fecha_fin - fecha_inicio AS duracion
FROM proyectos;

Formato y conversión

Tanto MySQL como PostgreSQL ofrecen funciones para formatear y convertir fechas.

• Formateo de fechas para presentación:

-- MySQL
SELECT DATE_FORMAT(fecha_nacimiento, '%d/%m/%Y') AS fecha_formateada
FROM empleados;

-- PostgreSQL
SELECT TO_CHAR(fecha_nacimiento, 'DD/MM/YYYY') AS fecha_formateada
FROM empleados;

• Conversión de texto a fecha:

-- MySQL
SELECT STR_TO_DATE('15/06/2023', '%d/%m/%Y') AS fecha_convertida;

-- PostgreSQL
SELECT TO_DATE('15/06/2023', 'DD/MM/YYYY') AS fecha_convertida;

Consideraciones de rendimiento y almacenamiento

La elección del tipo de fecha/hora adecuado afecta al rendimiento y espacio de almacenamiento:

• Espacio de almacenamiento:

• DATE: Más compacto (3-4 bytes)

• TIMESTAMP: Tamaño intermedio (4 bytes en MySQL)

• DATETIME: Mayor tamaño (8 bytes en MySQL)

• Indexación:

• Los campos de fecha/hora son excelentes candidatos para índices

• Mejoran significativamente consultas con filtros temporales

-- Índice para búsquedas frecuentes por fecha
CREATE INDEX idx_fecha_creacion ON pedidos(fecha_creacion);

• Particionamiento:
• Las columnas de fecha son ideales para particionar tablas grandes
• Mejora el rendimiento en tablas con datos históricos

-- PostgreSQL: Particionamiento por rango de fechas
CREATE TABLE registros (
    id SERIAL,
    fecha_registro DATE,
    datos TEXT
) PARTITION BY RANGE (fecha_registro);

-- Crear particiones por año
CREATE TABLE registros_2022 PARTITION OF registros
    FOR VALUES FROM ('2022-01-01') TO ('2023-01-01');

Selección del tipo adecuado

Para elegir el tipo de fecha/hora más apropiado, considera estos factores:

• Solo fecha sin hora: Usa DATE
• Solo hora sin fecha: Usa TIME
• Fecha y hora juntas:
• Para eventos recientes y futuros en un rango limitado: TIMESTAMP
• Para fechas históricas o muy futuras: DATETIME/TIMESTAMP
• Necesidad de zona horaria:
• PostgreSQL: TIMESTAMPTZ
• MySQL 8.0+: TIMESTAMP con conversión de zona horaria

-- Ejemplo de selección de tipos para una tabla de reservas
CREATE TABLE reservas (
    id INT PRIMARY KEY,
    cliente_id INT,
    fecha_reserva DATE,           -- Solo necesitamos la fecha
    hora_inicio TIME,             -- Hora de inicio
    hora_fin TIME,                -- Hora de finalización
    creado_en TIMESTAMP,          -- Cuándo se creó el registro
    ultima_modificacion TIMESTAMP -- Última actualización
);

Valores por defecto y actualización automática

Los campos de fecha/hora pueden configurarse para actualizarse automáticamente:

-- MySQL: Actualización automática
CREATE TABLE articulos (
    id INT PRIMARY KEY,
    titulo VARCHAR(100),
    contenido TEXT,
    fecha_creacion DATETIME DEFAULT CURRENT_TIMESTAMP,
    fecha_actualizacion DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

-- PostgreSQL: Usando valores por defecto
CREATE TABLE articulos (
    id SERIAL PRIMARY KEY,
    titulo VARCHAR(100),
    contenido TEXT,
    fecha_creacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    fecha_actualizacion TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- PostgreSQL: Actualización automática con trigger
CREATE OR REPLACE FUNCTION actualizar_timestamp()
RETURNS TRIGGER AS $$
BEGIN
    NEW.fecha_actualizacion = CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER actualizar_articulos_timestamp
BEFORE UPDATE ON articulos
FOR EACH ROW EXECUTE FUNCTION actualizar_timestamp();

Los tipos de fecha y hora son esenciales para aplicaciones que necesitan registrar cuándo ocurren eventos, calcular duraciones o programar actividades futuras. La elección correcta del tipo dependerá de los requisitos específicos de precisión, rango temporal y consideraciones de zona horaria de tu aplicación.