Tutorial SQL: Inserción de datos: INSERT INTO

INSERT con columnas

La sentencia INSERT en SQL nos permite agregar nuevos registros a una tabla existente. Aunque existe una forma básica de insertar datos proporcionando valores para todas las columnas en el orden definido en la tabla, el uso de INSERT especificando las columnas ofrece mayor flexibilidad y control sobre el proceso de inserción.

Sintaxis básica

La sintaxis para insertar datos especificando las columnas es:

INSERT INTO nombre_tabla (columna1, columna2, ..., columnaN)
VALUES (valor1, valor2, ..., valorN);

Esta forma de inserción tiene varias ventajas importantes:

• Permite insertar datos solo en columnas específicas
• No requiere seguir el orden exacto de las columnas en la definición de la tabla
• Hace que las consultas sean más legibles y mantenibles
• Evita errores cuando la estructura de la tabla cambia

Especificando columnas explícitamente

Veamos un ejemplo práctico. Supongamos que tenemos una tabla empleados con la siguiente estructura:

CREATE TABLE empleados (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nombre VARCHAR(50) NOT NULL,
    apellido VARCHAR(50) NOT NULL,
    email VARCHAR(100) UNIQUE,
    fecha_contratacion DATE NOT NULL,
    salario DECIMAL(10,2),
    departamento_id INT
);

Podemos insertar un nuevo empleado especificando solo algunas columnas:

INSERT INTO empleados (nombre, apellido, email, fecha_contratacion)
VALUES ('Ana', 'García', 'ana.garcia@empresa.com', '2023-05-15');

En este ejemplo, solo proporcionamos valores para cuatro columnas, mientras que:

• id se generará automáticamente (AUTO_INCREMENT)
• salario y departamento_id quedarán como NULL (si la definición de la tabla lo permite)

Orden personalizado de columnas

Una de las ventajas más importantes es que podemos especificar las columnas en cualquier orden, independientemente de cómo estén definidas en la tabla:

INSERT INTO empleados (fecha_contratacion, nombre, apellido, email)
VALUES ('2023-06-20', 'Carlos', 'Martínez', 'carlos.martinez@empresa.com');

El sistema de base de datos asignará cada valor a la columna correspondiente según el orden en que las especificamos en la consulta, no según el orden en la definición de la tabla.

Omitiendo columnas con valores por defecto

Si una columna tiene definido un valor por defecto o permite NULL, podemos omitirla en nuestra sentencia INSERT:

-- Suponiendo que departamento_id tiene un valor por defecto de 1 (departamento general)
INSERT INTO empleados (nombre, apellido, email, fecha_contratacion, salario)
VALUES ('Laura', 'Sánchez', 'laura.sanchez@empresa.com', '2023-07-10', 28500.00);

En este caso, departamento_id tomará el valor por defecto definido en la tabla.

Uso con columnas calculadas o generadas

En bases de datos modernas como MySQL 5.7+ o PostgreSQL, podemos tener columnas calculadas o generadas. Al usar INSERT con columnas específicas, podemos omitir estas columnas calculadas:

-- Suponiendo que tenemos una columna calculada 'nombre_completo'
INSERT INTO empleados (nombre, apellido, email, fecha_contratacion)
VALUES ('Miguel', 'López', 'miguel.lopez@empresa.com', '2023-08-05');

La columna calculada se generará automáticamente basándose en las reglas definidas en la tabla.

Mejores prácticas

Para mantener un código SQL robusto y mantenible, se recomienda:

• Siempre especificar las columnas en las sentencias INSERT, incluso si vas a proporcionar valores para todas las columnas
• Mantener un orden consistente de columnas en todo el código para facilitar la lectura
• Documentar con comentarios cualquier lógica especial relacionada con valores por defecto o columnas omitidas

-- Inserción completa especificando todas las columnas (excepto id autogenerado)
INSERT INTO empleados (nombre, apellido, email, fecha_contratacion, salario, departamento_id)
VALUES ('Javier', 'Rodríguez', 'javier.rodriguez@empresa.com', '2023-09-01', 32000.00, 3);

Esta práctica hace que el código sea más resistente a cambios futuros en la estructura de la tabla y facilita la comprensión de la intención del desarrollador.

Compatibilidad entre MySQL y PostgreSQL

La sintaxis para INSERT con columnas es prácticamente idéntica en MySQL y PostgreSQL, lo que facilita la portabilidad del código entre estos sistemas de gestión de bases de datos:

-- Esta sintaxis funciona igual en MySQL y PostgreSQL
INSERT INTO productos (nombre, precio, categoria_id)
VALUES ('Monitor 24"', 199.99, 5);

Sin embargo, hay algunas diferencias sutiles en cómo manejan los valores por defecto y las secuencias para columnas autoincrementales, por lo que siempre es recomendable consultar la documentación específica de cada sistema si se trabaja en entornos mixtos.

Múltiples registros

La inserción de múltiples registros en una sola operación es una técnica fundamental para optimizar el rendimiento de las bases de datos cuando necesitamos agregar varios registros simultáneamente. Esta funcionalidad nos permite reducir significativamente el número de conexiones con el servidor de base de datos y mejorar la eficiencia de las operaciones de inserción masiva.

Sintaxis para insertar múltiples registros

Para insertar varios registros a la vez, SQL nos permite extender la sintaxis básica del comando INSERT añadiendo múltiples conjuntos de valores:

INSERT INTO nombre_tabla (columna1, columna2, ..., columnaN)
VALUES 
    (valor1_registro1, valor2_registro1, ..., valorN_registro1),
    (valor1_registro2, valor2_registro2, ..., valorN_registro2),
    (valor1_registro3, valor2_registro3, ..., valorN_registro3),
    ...;

Esta sintaxis es compatible tanto con MySQL como con PostgreSQL, lo que facilita la portabilidad del código entre ambos sistemas.

Ejemplo práctico

Supongamos que necesitamos insertar varios productos en una tabla de inventario:

INSERT INTO productos (nombre, categoria, precio, stock)
VALUES 
    ('Teclado mecánico', 'Periféricos', 89.99, 45),
    ('Ratón inalámbrico', 'Periféricos', 29.99, 60),
    ('Monitor 27"', 'Pantallas', 249.99, 15),
    ('Disco SSD 1TB', 'Almacenamiento', 119.99, 30);

Con esta única sentencia, hemos insertado cuatro productos diferentes en la tabla, lo que es mucho más eficiente que ejecutar cuatro sentencias INSERT separadas.

Ventajas de la inserción múltiple

La inserción de múltiples registros ofrece varias ventajas importantes:

• Rendimiento mejorado: Reduce significativamente el tiempo de ejecución para inserciones masivas
• Menor sobrecarga de red: Minimiza el tráfico entre la aplicación y la base de datos
• Transacciones más eficientes: Permite que todas las inserciones se realicen dentro de una única transacción
• Código más limpio: Resulta en consultas SQL más concisas y legibles

Consideraciones de rendimiento

El rendimiento de las inserciones múltiples mejora notablemente cuando se trabaja con grandes volúmenes de datos:

-- Inserción de 1000 registros de ejemplo en una tabla de logs
INSERT INTO logs (timestamp, nivel, mensaje)
VALUES 
    ('2023-10-15 08:01:23', 'INFO', 'Inicio de sesión usuario 1'),
    ('2023-10-15 08:02:45', 'WARNING', 'Intento fallido de acceso'),
    ('2023-10-15 08:03:12', 'INFO', 'Actualización completada'),
    -- ... (muchos más registros)
    ('2023-10-15 23:59:59', 'INFO', 'Cierre del sistema');

Las pruebas de rendimiento muestran que insertar 1000 registros con una sola sentencia puede ser hasta 20 veces más rápido que hacerlo con 1000 sentencias individuales, dependiendo de la configuración del servidor y la estructura de la tabla.

Límites y consideraciones

Aunque la inserción múltiple es muy potente, debemos tener en cuenta algunas limitaciones:

• Cada sistema de base de datos tiene un límite máximo de registros que se pueden insertar en una sola operación:

• MySQL generalmente permite hasta 1000 filas por defecto (configurable con max_allowed_packet)

• PostgreSQL no tiene un límite fijo, pero está limitado por la memoria disponible

• Para conjuntos de datos extremadamente grandes, puede ser necesario dividir la inserción en lotes (batches) de tamaño manejable:

-- Primer lote de 500 registros
INSERT INTO mediciones (sensor_id, valor, timestamp)
VALUES 
    (1, 23.5, '2023-10-15 00:00:00'),
    (2, 18.2, '2023-10-15 00:00:01'),
    -- ... (más registros)
    (500, 22.1, '2023-10-15 00:08:19');

-- Segundo lote de 500 registros en otra sentencia
INSERT INTO mediciones (sensor_id, valor, timestamp)
VALUES 
    (501, 24.0, '2023-10-15 00:08:20'),
    -- ... (más registros)
    (1000, 19.8, '2023-10-15 00:16:40');

Manejo de errores

Un aspecto importante a considerar es el comportamiento ante errores. Por defecto, si uno de los registros en una inserción múltiple falla (por ejemplo, por violar una restricción de unicidad), toda la operación fallará.

Sin embargo, MySQL ofrece la cláusula IGNORE para continuar con el resto de inserciones incluso si algunas fallan:

-- MySQL: Continuar insertando aunque algunos registros fallen
INSERT IGNORE INTO usuarios (email, nombre, fecha_registro)
VALUES 
    ('usuario1@ejemplo.com', 'Ana García', '2023-10-01'),
    ('usuario2@ejemplo.com', 'Luis Pérez', '2023-10-02'),
    ('usuario1@ejemplo.com', 'Duplicado', '2023-10-03'); -- Este email está duplicado

En PostgreSQL, podemos lograr un comportamiento similar utilizando la cláusula ON CONFLICT:

-- PostgreSQL: Ignorar conflictos en la columna email
INSERT INTO usuarios (email, nombre, fecha_registro)
VALUES 
    ('usuario1@ejemplo.com', 'Ana García', '2023-10-01'),
    ('usuario2@ejemplo.com', 'Luis Pérez', '2023-10-02'),
    ('usuario1@ejemplo.com', 'Duplicado', '2023-10-03')
ON CONFLICT (email) DO NOTHING;

Inserción múltiple desde subconsultas

Una técnica avanzada es insertar múltiples registros utilizando los resultados de una subconsulta:

-- Insertar productos con descuento basados en productos existentes
INSERT INTO productos_oferta (producto_id, nombre, precio_oferta, fecha_inicio)
SELECT 
    id, 
    nombre, 
    precio * 0.8, -- 20% de descuento
    '2023-11-01'
FROM productos
WHERE categoria = 'Electrónica' AND stock > 10;

Esta técnica es extremadamente útil para migraciones de datos o para crear registros derivados de información existente.

Optimización con prepared statements

Cuando trabajamos con inserciones múltiples desde aplicaciones, es recomendable utilizar prepared statements para mejorar aún más el rendimiento y la seguridad:

-- Ejemplo conceptual de prepared statement (la sintaxis exacta depende del lenguaje)
PREPARE insert_producto (varchar, varchar, numeric, int) AS
INSERT INTO productos (nombre, categoria, precio, stock)
VALUES ($1, $2, $3, $4);

-- Luego se ejecuta múltiples veces con diferentes valores
EXECUTE insert_producto('Teclado mecánico', 'Periféricos', 89.99, 45);
EXECUTE insert_producto('Ratón inalámbrico', 'Periféricos', 29.99, 60);

Los prepared statements reducen la sobrecarga de análisis y planificación de consultas, además de proteger contra ataques de inyección SQL.

Uso en entornos de producción

En entornos de producción con grandes volúmenes de datos, es común implementar estrategias de carga por lotes que combinen la inserción múltiple con otras técnicas de optimización:

• Desactivar temporalmente índices o restricciones antes de inserciones masivas
• Utilizar transacciones para agrupar lotes de inserciones
• Monitorear el rendimiento para determinar el tamaño óptimo de lote

-- Ejemplo de enfoque transaccional para inserciones masivas
START TRANSACTION;

INSERT INTO registros_ventas (producto_id, cantidad, precio_unitario, fecha)
VALUES 
    (101, 2, 19.99, '2023-10-15'),
    (203, 1, 49.99, '2023-10-15'),
    (155, 3, 9.99, '2023-10-15'),
    -- ... más registros
    (302, 1, 29.99, '2023-10-15');

COMMIT;

Esta combinación de técnicas permite manejar eficientemente incluso los escenarios más exigentes de carga de datos.

Valores NULL y default

Al insertar datos en una tabla SQL, no siempre dispondremos de valores para todas las columnas. SQL nos ofrece mecanismos para manejar estas situaciones mediante valores NULL y valores predeterminados (default). Entender cómo trabajar con estos valores es esencial para diseñar operaciones de inserción flexibles y robustas.

Trabajando con valores NULL

Un valor NULL en SQL representa la ausencia de datos o un valor desconocido. No es lo mismo que un cero, una cadena vacía o un espacio en blanco. Para insertar un valor NULL explícitamente en una columna, podemos usar la palabra clave NULL:

INSERT INTO empleados (nombre, apellido, email, telefono)
VALUES ('Juan', 'Pérez', 'juan.perez@empresa.com', NULL);

En este ejemplo, estamos indicando que no conocemos el número de teléfono del empleado Juan Pérez.

Podemos insertar valores NULL en múltiples columnas en una misma sentencia:

INSERT INTO pedidos (cliente_id, producto_id, cantidad, fecha_entrega, notas)
VALUES (1001, 5432, 2, NULL, NULL);

Aquí, tanto la fecha de entrega como las notas del pedido se establecen como NULL.

Restricciones NOT NULL

Es importante recordar que no todas las columnas aceptan valores NULL. Si una columna está definida con la restricción NOT NULL, intentar insertar un valor NULL generará un error:

-- Suponiendo que nombre y apellido tienen restricción NOT NULL
INSERT INTO empleados (nombre, apellido, email)
VALUES (NULL, 'García', 'ana.garcia@empresa.com');
-- ERROR: la columna "nombre" no admite valores nulos

Omisión de columnas

Una forma implícita de asignar NULL a una columna es omitirla en la lista de columnas de la sentencia INSERT, siempre que la columna permita valores nulos:

INSERT INTO clientes (nombre, email, ciudad)
VALUES ('María López', 'maria@ejemplo.com', 'Barcelona');
-- La columna 'telefono' se omite y recibirá NULL

Esta técnica es muy útil cuando trabajamos con tablas que tienen muchas columnas opcionales.

Valores predeterminados (DEFAULT)

Las bases de datos permiten definir valores predeterminados para las columnas durante la creación de la tabla. Estos valores se utilizan automáticamente cuando no se especifica un valor explícito para esa columna.

Para usar explícitamente el valor predeterminado de una columna, podemos utilizar la palabra clave DEFAULT:

INSERT INTO productos (nombre, precio, stock, estado)
VALUES ('Monitor LED 24"', 199.99, 15, DEFAULT);

Suponiendo que la columna estado tiene un valor predeterminado de 'activo', este producto se insertará con ese estado.

Definición de valores predeterminados

Los valores predeterminados se establecen durante la creación de la tabla:

CREATE TABLE articulos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    titulo VARCHAR(100) NOT NULL,
    contenido TEXT,
    fecha_publicacion DATE DEFAULT CURRENT_DATE,
    estado VARCHAR(20) DEFAULT 'borrador',
    visitas INT DEFAULT 0
);

En esta tabla:

• fecha_publicacion usará la fecha actual por defecto
• estado será 'borrador' por defecto
• visitas comenzará en 0

Combinando NULL y DEFAULT

Podemos combinar valores NULL y DEFAULT en la misma sentencia INSERT:

INSERT INTO usuarios (nombre, email, fecha_registro, ultimo_acceso, preferencias)
VALUES ('Carlos Ruiz', 'carlos@ejemplo.com', DEFAULT, NULL, DEFAULT);

En este ejemplo:

• fecha_registro utilizará el valor predeterminado (posiblemente la fecha actual)
• ultimo_acceso se establecerá como NULL (ya que el usuario aún no ha accedido)
• preferencias utilizará el valor predeterminado definido en la tabla

Valores predeterminados dinámicos

Tanto MySQL como PostgreSQL permiten valores predeterminados dinámicos basados en funciones:

-- MySQL
CREATE TABLE registros (
    id INT AUTO_INCREMENT PRIMARY KEY,
    evento VARCHAR(100) NOT NULL,
    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
    usuario VARCHAR(50) DEFAULT CURRENT_USER()
);

-- PostgreSQL
CREATE TABLE registros (
    id SERIAL PRIMARY KEY,
    evento VARCHAR(100) NOT NULL,
    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    usuario VARCHAR(50) DEFAULT CURRENT_USER
);

Al insertar registros en estas tablas, podemos aprovechar estos valores dinámicos:

INSERT INTO registros (evento)
VALUES ('Inicio del sistema');
-- timestamp y usuario se completarán automáticamente

Diferencias entre MySQL y PostgreSQL

Aunque la sintaxis básica es similar, existen algunas diferencias entre MySQL y PostgreSQL:

• Funciones para valores predeterminados:

• MySQL usa CURRENT_TIMESTAMP() o NOW()

• PostgreSQL usa CURRENT_TIMESTAMP o NOW()

• Columnas generadas:

• MySQL permite columnas virtuales y almacenadas

• PostgreSQL utiliza columnas generadas almacenadas

-- MySQL: Columna virtual (calculada al vuelo)
CREATE TABLE productos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    precio DECIMAL(10,2) NOT NULL,
    impuesto DECIMAL(10,2) GENERATED ALWAYS AS (precio * 0.21) VIRTUAL
);

-- PostgreSQL: Columna generada almacenada
CREATE TABLE productos (
    id SERIAL PRIMARY KEY,
    precio DECIMAL(10,2) NOT NULL,
    impuesto DECIMAL(10,2) GENERATED ALWAYS AS (precio * 0.21) STORED
);

Mejores prácticas

Para trabajar eficientemente con valores NULL y DEFAULT:

• Documenta claramente el significado de NULL en cada columna (ausencia de datos, no aplicable, pendiente, etc.)
• Utiliza restricciones NOT NULL para columnas que siempre deben tener un valor
• Define valores predeterminados significativos que minimicen la necesidad de especificarlos explícitamente
• Considera el impacto en las consultas - recuerda que las comparaciones con NULL requieren operadores especiales (IS NULL, IS NOT NULL)

Ejemplo completo

Veamos un ejemplo completo que combina todas estas técnicas:

-- Creación de la tabla con valores predeterminados
CREATE TABLE tareas (
    id INT AUTO_INCREMENT PRIMARY KEY,
    titulo VARCHAR(100) NOT NULL,
    descripcion TEXT,
    fecha_creacion DATETIME DEFAULT CURRENT_TIMESTAMP,
    fecha_vencimiento DATE,
    prioridad VARCHAR(10) DEFAULT 'media',
    estado VARCHAR(15) DEFAULT 'pendiente',
    asignado_a INT,
    completado_porcentaje INT DEFAULT 0
);

-- Inserción con diferentes combinaciones de NULL y DEFAULT
INSERT INTO tareas (titulo, descripcion, fecha_vencimiento, asignado_a)
VALUES ('Actualizar documentación', 'Revisar y actualizar manuales de usuario', '2023-12-15', 103);
-- fecha_creacion, prioridad, estado y completado_porcentaje usarán valores predeterminados

INSERT INTO tareas (titulo, prioridad, fecha_vencimiento)
VALUES ('Corregir error #1234', 'alta', '2023-11-05');
-- descripcion será NULL, asignado_a será NULL

INSERT INTO tareas (titulo, descripcion, prioridad, estado, fecha_vencimiento)
VALUES ('Preparar presentación', NULL, DEFAULT, 'en progreso', NULL);
-- descripcion explícitamente NULL, prioridad usará el valor predeterminado 'media',
-- fecha_vencimiento explícitamente NULL

Este ejemplo muestra la flexibilidad que ofrecen los valores NULL y DEFAULT para adaptarse a diferentes escenarios de inserción de datos, permitiéndonos crear sentencias INSERT más concisas y mantenibles.