Cómo insertar datos en SQL

Introducción

El lenguaje de consulta estructurado, más conocido como SQL, ofrece gran flexibilidad para insertar datos en tablas. Por ejemplo, se pueden especificar filas individuales con la palabra clave VALUES, copiar conjuntos completos de datos de tablas existentes con consultas SELECT y definir columnas para que SQL inserte datos automáticamente.

En esta guía, exploraremos cómo utilizar la sintaxis INSERT INTO SQL para agregar datos a las tablas con cada uno de estos métodos.

Requisitos previos

Para seguir esta guía, necesitará una computadora con algún tipo de sistema de gestión de bases de datos relacionales (SGBDR) que utilice SQL. Las instrucciones y ejemplos de esta guía se han verificado en el siguiente entorno:

• Un servidor que ejecuta Ubuntu 20.04, con un usuario no root con privilegios administrativos y un firewall configurado con UFW.
• MySQL está instalado y protegido en el servidor.

También necesitarás una base de datos y una tabla para practicar la inserción de datos. Si no las tienes, puedes consultar la sección "Conectarse a MySQL y configurar una base de datos de ejemplo" para obtener más información sobre cómo crear la base de datos y la tabla que se utilizan en los ejemplos de esta guía.

Conexión a MySQL y configuración de una base de datos de ejemplo

Si su sistema de base de datos SQL se ejecuta en un servidor remoto, conéctese a su servidor mediante SSH desde su máquina local:

ssh sammy@your_server_ip

A continuación, abre la consola del servidor MySQL y sustituye Sami por tu nombre de usuario de MySQL:

mysql -u sammy -p

Crea una base de datos llamada insertDB:

CREATE DATABASE insertDB;

Si la base de datos se creó correctamente, recibirá el siguiente resultado:

Query OK, 1 row affected (0.01 sec)

Para seleccionar la base de datos insertDB, ejecute la siguiente declaración USE:

USE insertDB;

Output
Database changed

Tras seleccionar la base de datos insertDB, cree una tabla dentro de ella. Por ejemplo, supongamos que tiene una fábrica y desea crear una tabla para almacenar información sobre sus empleados. Esta tabla tendrá las siguientes cinco columnas:

• nombre:El nombre de cada empleado expresado utilizando el tipo de datos varchar con un máximo de 30 caracteres
• posición:Esta columna almacena el puesto de trabajo de cada empleado, que nuevamente se expresa utilizando el tipo de datos varchar con un máximo de 30 caracteres.
• departamento:El departamento en el que trabaja cada empleado, expresado mediante el tipo de dato varchar pero con un máximo de solo 20 caracteres.
• Salario por horaUna columna para registrar el salario por hora de cada empleado utiliza el tipo de dato decimal. Los valores de esta columna tienen hasta cuatro dígitos, dos de ellos a la derecha de la coma decimal. Por lo tanto, el rango de valores permitidos en esta columna es de -99,99 a 99,99.
• fecha de inicioFecha de incorporación de cada empleado, expresada mediante el tipo de dato "Fecha". Los valores de este tipo deben cumplir el formato AAAA-MM-DD.

Cree una tabla llamada factoryEmployees con estas cinco columnas:

CREATE TABLE factoryEmployees (
name varchar(30),
position varchar(30),
department varchar(20),
hourlyWage decimal(4,2),
startDate date
);

Con esto, estás listo para seguir el resto de la guía y comenzar a aprender cómo insertar datos con SQL.

Introducir datos manualmente

La sintaxis general para insertar datos en SQL es la siguiente:

INSERT INTO table_name
(column1, column2, . . . columnN)
VALUES
(value1, value2, . . . valueN);

Para demostrarlo, ejecute la siguiente declaración INSERT INTO para cargar la tabla factoryEmployees con una fila de datos:

INSERT INTO factoryEmployees
(name, position, department, hourlyWage, startDate)
VALUES
('Agnes', 'thingamajig foreman', 'management', 26.50, '2017-05-01');

Output
Query OK, 1 row affected (0.00 sec)

La instrucción comienza con la palabra clave INSERT INTO, seguida del nombre de la tabla donde se insertarán los datos. A continuación del nombre de la tabla, se incluye una lista de columnas entre paréntesis donde se insertarán los datos. A continuación de la lista de columnas, se incluye la palabra clave VALUES, seguida de un conjunto de valores entre paréntesis y separados por comas.

El orden en que se enumeran las columnas no importa. Es importante recordar que el orden de los valores proporcionados debe coincidir con el orden de las columnas. SQL siempre intenta insertar el primer valor dado en la primera columna de la lista, el segundo valor en la siguiente, y así sucesivamente. Por ejemplo, la siguiente instrucción INSERT añade otra fila de datos, pero enumera las columnas en un orden diferente:

INSERT INTO factoryEmployees
(department, hourlyWage, startDate, name, position)
VALUES
('production', 15.59, '2018-04-28', 'Jim', 'widget tightener');

Output
Query OK, 1 row affected (0.00 sec)

Si no alinea los valores correctamente, SQL podría insertar los datos en las columnas incorrectas. Además, generará un error si alguno de los valores entra en conflicto con el tipo de dato de la columna, como en este ejemplo:

INSERT INTO factoryEmployees
(name, hourlyWage, position, startDate, department)
VALUES
('Louise', 'doodad tester', 16.50, '2017-05-01', 'quality assurance');

Output
ERROR 1366 (HY000): Incorrect decimal value: 'doodad tester' for column 'hourlyWage' at row 1

Tenga en cuenta que, si bien debe proporcionar un valor para cada columna que especifique, no es necesario especificar todas las columnas de la tabla al agregar una nueva fila de datos. Siempre que ninguna de las columnas que elimine tenga una restricción que cause un error en este caso (como NOT NULL), MySQL agregará NULL a las columnas no especificadas:

INSERT INTO factoryEmployees
(name, position, hourlyWage)
VALUES
('Harry', 'whatzit engineer', 26.50);

Output
Query OK, 1 row affected (0.01 sec)

Si va a insertar una fila con valores para cada columna de la tabla, no necesita introducir los nombres de las columnas. Tenga en cuenta que los valores que introduzca deben ser coherentes con el orden en que se definen las columnas en la definición de la tabla.

En este ejemplo, los valores enumerados se alinean en el orden en que se definen las columnas en la instrucción CREATE TABLE para la tabla factoryEmployee:

INSERT INTO factoryEmployees
VALUES
('Marie', 'doodad welder', 'production', 27.88, '2018-03-29');

Output
Query OK, 1 row affected (0.00 sec)

También puedes agregar varios registros a la vez separando cada fila con una coma, de la siguiente manera:

INSERT INTO factoryEmployees
VALUES
('Giles', 'gizmo inspector', 'quality assurance', 26.50, '2019-08-06'),
('Daphne', 'gizmo presser', 'production', 32.45, '2017-11-12'),
('Joan', 'whatzit analyst', 'quality assurance', 29.00, '2017-04-29');

Query OK, 3 rows affected (0.00 sec)
Records: 3 Duplicates: 0 Warnings: 0

Copiar datos con sentencias SELECT

En lugar de especificar datos fila por fila, puede copiar varias filas de datos de una tabla e insertarlas en otra tabla con una consulta SELECT.

La sintaxis para este tipo de operación es la siguiente:

INSERT INTO table_A (col_A1, col_A2, col_A3)
SELECT col_B1, col_B2, col_B3
FROM table_B;

En lugar de usar la palabra clave VALUES después de la lista de columnas, esta sintaxis de ejemplo incluye una instrucción SELECT. La instrucción SELECT de este ejemplo solo incluye la cláusula FROM, pero cualquier consulta válida funcionará.

Para demostrarlo, ejecute la siguiente operación CREATE TABLE para crear una nueva tabla llamada showroomEmployees. Tenga en cuenta que los nombres y tipos de datos de las columnas de esta tabla son los mismos que los de las tres columnas de la tabla factoryEmployees utilizadas en la sección anterior:

CREATE TABLE showroomEmployees (
name varchar(30),
hourlyWage decimal(4,2),
startDate date
);

Output
Query OK, 0 rows affected (0.02 sec)

Ahora puede cargar esta nueva tabla con algunos datos de la tabla factoryEmployees que se creó previamente incluyendo una consulta SELECT en la declaración INSERT INTO.

Si la consulta SELECT devuelve la misma cantidad de columnas en el mismo orden que las columnas de la tabla de destino, y también tienen tipos de datos coincidentes, puede omitir la lista de columnas de la declaración INSERT INTO:

INSERT INTO showroomEmployees
SELECT
factoryEmployees.name,
factoryEmployees.hourlyWage,
factoryEmployees.startDate
FROM factoryEmployees
WHERE name = 'Agnes';

Output
Query OK, 1 row affected (0.01 sec)
Records: 1 Duplicates: 0 Warnings: 0

La instrucción SELECT de esta operación incluye una cláusula WHERE que hace que la consulta devuelva solo las filas de la tabla factoryEmployees cuya columna de nombre contenga el valor Agnes. Dado que solo hay una fila en la tabla de origen, solo esa fila se copia a la tabla showroomEmployees.

Para verificar esto, ejecute la siguiente consulta para devolver todos los registros en la tabla de empleados de la sala de exposición:

SELECT * FROM showroomEmployees;

Output
+-------+------------+------------+
| name | hourlyWage | startDate |
+-------+------------+------------+
| Agnes | 26.50 | 2017-05-01 |
+-------+------------+------------+
1 row in set (0.00 sec)

Puede insertar varias filas de datos con cualquier consulta que devuelva más de una fila de la tabla de origen. Por ejemplo, la consulta de la siguiente instrucción devuelve cualquier registro de la base de datos factoryEmployees cuyo valor en la columna de nombre no comience por J:

INSERT INTO showroomEmployees
SELECT
factoryEmployees.name,
factoryEmployees.hourlyWage,
factoryEmployees.startDate
FROM factoryEmployees
WHERE name NOT LIKE 'J%';

Output
Query OK, 5 rows affected (0.01 sec)
Records: 5 Duplicates: 0 Warnings: 0

Para devolver todos los registros de la tabla de empleados de la sala de exposición, ejecute esta consulta nuevamente:

SELECT * FROM showroomEmployees;

+--------+------------+------------+
| name | hourlyWage | startDate |
+--------+------------+------------+
| Agnes | 26.50 | 2017-05-01 |
| Agnes | 26.50 | 2017-05-01 |
| Harry | 26.50 | NULL |
| Marie | 27.88 | 2018-03-29 |
| Giles | 26.50 | 2019-08-06 |
| Daphne | 32.45 | 2017-11-12 |
+--------+------------+------------+
6 rows in set (0.00 sec)

Observe que hay dos filas idénticas con Agnes en la columna Nombre. Cada vez que se ejecuta una instrucción INSERT INTO que utiliza SELECT, SQL trata los resultados de la consulta como un nuevo conjunto de datos. A menos que se impongan restricciones específicas a la tabla o se creen consultas más precisas, no hay nada que impida que la base de datos se cargue con registros duplicados al agregar datos como este.

Insertar información automáticamente

Al crear una tabla, puede aplicar ciertos atributos a las columnas que harán que el RDBMS las rellene automáticamente con datos.

Para ilustrarlo, ejecute la siguiente instrucción para definir una tabla llamada interns. Esto crea una tabla llamada interns con tres columnas. La primera columna de este ejemplo, internID, contiene datos de tipo int. Sin embargo, tenga en cuenta que también incluye el atributo AUTO_INCREMENT. Este atributo hace que SQL genere automáticamente un valor numérico único para cada nueva fila, comenzando en 1 por defecto y aumentando en uno con cada registro subsiguiente.

De forma similar, la segunda columna, sección, contiene la palabra clave DEFAULT. Si elimina la sección de la lista de columnas de la instrucción INSERT INTO, el RDBMS insertará automáticamente el valor predeterminado: “producción” en este ejemplo.

CREATE TABLE interns (
internID int AUTO_INCREMENT PRIMARY KEY,
department varchar(20) DEFAULT 'production',
name varchar(30)
);

Para demostrar estas funciones, cargue la tabla Interns con algunos datos ejecutando la siguiente instrucción INSERT INTO. Esta operación especifica únicamente los valores de la columna Name:

INSERT INTO interns (name) VALUES ('Pierre'), ('Sheila'), ('Francois');

Output
Query OK, 3 rows affected (0.01 sec)
Records: 3 Duplicates: 0 Warnings: 0

Luego ejecute esta consulta para devolver todos los registros de la tabla:

SELECT * FROM interns;

Output
+----------+------------+----------+
| internID | department | name |
+----------+------------+----------+
| 1 | production | Pierre |
| 2 | production | Sheila |
| 3 | production | Francois |
+----------+------------+----------+
3 rows in set (0.00 sec)

Esta salida muestra que, debido a las definiciones de columnas, la instrucción INSERT INTO anterior agrega valores tanto a la sección interna como a la externa, aunque no estén especificados.

Para agregar un valor distinto del valor predeterminado a una columna de sección, debe especificar esa columna en la declaración INSERT INTO, de la siguiente manera:

INSERT INTO interns (name, department)
VALUES
('Jacques', 'management'),
('Max', 'quality assurance'),
('Edith', 'management'),
('Daniel', DEFAULT);

Output
Query OK, 4 rows affected (0.00 sec)
Records: 4 Duplicates: 0 Warnings: 0

Tenga en cuenta que la última fila de valores proporcionada en este ejemplo contiene la palabra clave DEFAULT en lugar de una cadena. Esto hace que la base de datos inserte el valor predeterminado ('production'):

SELECT * FROM interns;

Output
+----------+-------------------+----------+
| internID | department | name |
+----------+-------------------+----------+
| 1 | production | Pierre |
| 2 | production | Sheila |
| 3 | production | Francois |
| 4 | management | Jacques |
| 5 | quality assurance | Max |
| 6 | management | Edith |
| 7 | production | Daniel |
+----------+-------------------+----------+
7 rows in set (0.00 sec)

Resultado

Al leer esta guía, aprendió varias formas diferentes de insertar datos en una tabla, incluida la especificación de filas individuales de datos con la palabra clave VALUES, la copia de conjuntos de datos completos con consultas SELECT y la definición de columnas en las que SQL insertará datos automáticamente.

Los comandos que se listan aquí deberían funcionar en cualquier sistema de gestión de bases de datos que utilice SQL. Tenga en cuenta que cada base de datos SQL utiliza su propia implementación del lenguaje, por lo que le recomendamos consultar la documentación de su sistema de gestión de bases de datos para obtener una explicación más completa sobre cómo se maneja la instrucción INSERT INTO y las opciones disponibles.