Introducción
Agregar y eliminar registros de las tablas son algunas de las operaciones más comunes que realizan las bases de datos. Agregar datos implica especificar los nombres de la tabla y la columna a los que desea agregar valores, así como los valores que desea ingresar en cada campo. Eliminar registros implica identificar la fila o filas correctas y eliminarlas de la tabla.
En esta guía, cubriremos cómo usar SQL INSERT y DELETE comandos con PostgreSQL. Esto incluye la sintaxis básica, cómo devolver información sobre los datos que se procesaron y cómo agregar o eliminar varias filas en una sola declaración.
Revisando la estructura de la tabla
Antes de usar INSERT comando, debe conocer la estructura de la tabla para poder adaptarse a los requisitos impuestos por las columnas, los tipos de datos y las restricciones de la tabla. Hay algunas formas diferentes de hacer esto dependiendo de su cliente de base de datos.
Si está utilizando psql cliente de línea de comandos, la forma más directa de encontrar esta información es usar el \d+ metacomando integrado en la herramienta.
Por ejemplo, para encontrar la estructura de una tabla llamada employee , escribirías esto:
\d+ employee
Table "public.employee" Column | Type | Collation | Nullable | Default | Storage | Stats target | Description-------------+-----------------------------+-----------+----------+-----------------------------------------------+----------+--------------+------------- employee_id | integer | | not null | nextval('employee_employee_id_seq'::regclass) | plain | | first_name | character varying(45) | | not null | | extended | | last_name | character varying(45) | | not null | | extended | | last_update | timestamp without time zone | | not null | now() | plain | |Indexes: "employee_pkey" PRIMARY KEY, btree (employee_id) "idx_employee_last_name" btree (last_name)Triggers: last_updated BEFORE UPDATE ON employee FOR EACH ROW EXECUTE FUNCTION last_updated()Access method: heap
El resultado muestra los nombres de las columnas de la tabla, los tipos de datos y los valores predeterminados, entre otros.
El \d+ El comando meta solo está disponible con psql cliente, por lo que si está utilizando un cliente diferente, es posible que deba consultar la información de la tabla directamente. Puede obtener la mayor parte de la información relevante con una consulta como esta:
SELECT column_name, data_type, column_default, is_nullable, character_maximum_lengthFROM information_schema.columns WHERE table_name ='employee';
column_name | data_type | column_default | is_nullable | character_maximum_length-------------+-----------------------------+-----------------------------------------------+-------------+-------------------------- employee_id | integer | nextval('employee_employee_id_seq'::regclass) | NO | first_name | character varying | | NO | 45 last_name | character varying | | NO | 45 last_update | timestamp without time zone | now() | NO |(4 rows)
Estos deberían darle una buena idea de la estructura de la tabla para que pueda insertar valores correctamente.
Usando INSERT para agregar nuevos registros a las tablas
El SQL INSERT El comando se usa para agregar filas de datos a una tabla existente. Una vez que conozca la estructura de la tabla, puede construir un comando que haga coincidir las columnas de la tabla con los valores correspondientes que desea insertar para el nuevo registro.
La sintaxis básica del comando se ve así:
INSERT INTO my_table(column1, column2)VALUES ('value1', 'value2');
Las columnas en la lista de columnas corresponden directamente a los valores provistos dentro de la lista de valores.
Por defecto, el INSERT El comando devuelve el ID del objeto (normalmente 0) y un recuento de filas que se insertaron correctamente:
INSERT 0 1
Como ejemplo, para insertar un nuevo empleado en el employee tabla listada arriba, podríamos escribir:
INSERT INTO employee(first_name, last_name)VALUES ('Bob', 'Smith');
INSERT 0 1
Aquí proporcionamos valores para el first_name y last_name columnas mientras deja que las otras columnas se completen con sus valores predeterminados. Si consulta la tabla, puede ver que se ha agregado el nuevo registro:
SELECT * FROM employee;
employee_id | first_name | last_name | last_update-------------+------------+-----------+---------------------------- 1 | Bob | Smith | 2020-08-19 21:07:00.952454(1 row)
Returning data from INSERT declaraciones
Si desea información adicional sobre los datos que se agregaron a la tabla, puede incluir el RETURNING cláusula al final de su estado de cuenta. El RETURNING La cláusula especifica las columnas para mostrar de los registros que se acaban de insertar.
Por ejemplo, para mostrar todas las columnas de los registros que se acaban de insertar, puede escribir algo como esto:
INSERT INTO my_table(column_name, column_name_2)VALUES ('value', 'value2')RETURNING *;
column_name | column_name_2-------------+--------------- value | value2(1 row)INSERT 0 1
Usando el employee table, esto se vería así:
INSERT INTO employee(first_name, last_name)VALUES ('Sue', 'Berns')RETURNING *;
employee_id | first_name | last_name | last_update-------------+------------+-----------+-------------------------- 2 | Sue | Berns | 2020-08-19 21:15:01.7622(1 row)INSERT 0 1
También puede optar por devolver solo columnas específicas de las inserciones. Por ejemplo, aquí, solo nos interesa la identificación del nuevo empleado:
INSERT INTO employee(first_name, last_name)VALUES ('Delores', 'Muniz')RETURNING employee_id;
employee_id ------------- 3(1 row)INSERT 0 1
Como de costumbre, también puede usar alias de columna para cambiar los nombres de columna en la salida:
INSERT INTO employee(first_name, last_name)VALUES ('Simone', 'Kohler')RETURNING employee_id AS "Employee ID";
Employee ID------------- 4(1 row)INSERT 0 1
Usando INSERT para agregar varias filas a la vez
Insertar registros de una declaración a la vez consume más tiempo y es menos eficiente que insertar varias filas a la vez. PostgreSQL le permite especificar múltiples filas para agregar a la misma tabla. Cada nueva fila se encapsula entre paréntesis, con cada conjunto de paréntesis separados por comas.
La sintaxis básica para la inserción de registros múltiples se ve así:
INSERT INTO my_table(column_name, column_name_2)VALUES ('value', 'value2'), ('value3', 'value4'), ('value5', 'value6');
Para el employee tabla a la que hemos estado haciendo referencia, puede agregar cuatro nuevos empleados en una sola declaración escribiendo:
INSERT INTO employee(first_name, last_name)VALUES ('Abigail', 'Spencer'), ('Tamal', 'Wayne'), ('Katie', 'Singh'), ('Felipe', 'Espinosa');
INSERT 0 4
Usando DELETE para eliminar filas de las tablas
El DELETE de SQL El comando se usa para eliminar filas de las tablas, funcionando como la acción complementaria a INSERT . Para eliminar filas de una tabla, debe identificar las filas que desea orientar al proporcionar criterios de coincidencia dentro de un WHERE cláusula.
La sintaxis básica se ve así:
DELETE FROM my_tableWHERE <condition>;
Por ejemplo, a cada fila de nuestro employee tabla que tiene su first_name establecido en Abigail , podríamos escribir esto:
DELETE FROM employeeWHERE first_name = 'Abigail';
DELETE 1
El valor devuelto aquí indica que DELETE el comando se procesó con una sola fila eliminada.
Returning data from DELETE declaraciones
Al igual que con INSERT comando, puede devolver las filas afectadas o columnas específicas de las filas eliminadas agregando un RETURNING cláusula:
DELETE FROM my_tableWHERE <condition>RETURNING *;
Por ejemplo, podemos verificar que se eliminó el registro correcto devolviendo todas las columnas del employee eliminado aquí:
DELETE FROM employeeWHERE last_name = 'Smith'RETURNING *;
employee_id | first_name | last_name | last_update-------------+------------+-----------+---------------------------- 1 | Bob | Smith | 2020-08-19 21:07:00.952454(1 row)DELETE 1
Usando DELETE para eliminar varias filas a la vez
Puede eliminar varios elementos a la vez con DELETE manipulando los criterios de selección especificados en WHERE cláusula.
Por ejemplo, para eliminar varias filas por ID, puede escribir algo como esto:
DELETE FROM employeeWHERE employee_id in (3,4)RETURNING *;
employee_id | first_name | last_name | last_update -------------+------------+-----------+---------------------------- 3 | Delores | Muniz | 2020-08-19 21:17:06.943608 4 | Simone | Kohler | 2020-08-19 21:19:19.298833(2 rows)DELETE 2
Incluso puede omitir el WHERE cláusula para eliminar todas las filas de una tabla dada:
DELETE FROM employeeRETURNING *;
employee_id | first_name | last_name | last_update-------------+------------+-----------+---------------------------- 2 | Sue | Berns | 2020-08-19 21:15:01.7622 6 | Tamal | Wayne | 2020-08-19 22:11:53.408531 7 | Katie | Singh | 2020-08-19 22:11:53.408531 8 | Filipe | Espinosa | 2020-08-19 22:11:53.408531(4 rows)DELETE 4
Tenga en cuenta, sin embargo, que usar DELETE vaciar una tabla de datos no es tan eficiente como TRUNCATE comando, que puede eliminar datos sin escanear la tabla.
Conclusión
En este artículo, presentamos algunos de los comandos más importantes para controlar qué datos hay en sus tablas de PostgreSQL. El INSERT El comando se puede usar para agregar nuevos datos a las tablas, mientras que el comando DELETE El comando especifica qué filas deben eliminarse. Ambos comandos pueden devolver las filas a las que afectan y pueden operar en varias filas a la vez.
Estos dos comandos son los mecanismos principales que se utilizan para administrar aumentar o disminuir la cantidad de registros que contiene su tabla. Controlar su sintaxis básica, así como las formas en que se pueden combinar con otras cláusulas, le permitirá completar y limpiar sus tablas según sea necesario.
