Introdução
Adicionar e remover registros de tabelas são algumas das operações mais comuns que os bancos de dados realizam. Adicionar dados envolve especificar os nomes de tabela e coluna aos quais você deseja adicionar valores, bem como os valores que deseja inserir em cada campo. A exclusão de registros envolve identificar a linha ou linhas corretas e removê-las da tabela.
Neste guia, abordaremos como usar o SQL
INSERT e DELETE comandos com PostgreSQL. Isso inclui a sintaxe básica, como retornar informações de dados sobre os dados que foram processados e como adicionar ou remover várias linhas em uma única instrução. Revisando a estrutura da tabela
Antes de usar o
INSERT comando, você deve conhecer a estrutura da tabela para que possa acomodar os requisitos impostos pelas colunas, tipos de dados e restrições da tabela. Existem algumas maneiras diferentes de fazer isso dependendo do seu cliente de banco de dados. Se você estiver usando o
psql cliente de linha de comando, a maneira mais simples de encontrar essas informações é usar o \d+ comando meta embutido na ferramenta. Por exemplo, para encontrar a estrutura de uma tabela chamada
employee , você digitaria isso:\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
A saída exibe os nomes das colunas da tabela, tipos de dados e valores padrão, entre outros.
O
\d+ O comando meta só está disponível com o psql cliente, portanto, se estiver usando um cliente diferente, talvez seja necessário consultar as informações da tabela diretamente. Você pode obter a maioria das informações relevantes com uma 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)
Eles devem dar uma boa ideia da estrutura da tabela para que você possa inserir valores corretamente.
Usando INSERT para adicionar novos registros às tabelas
O SQL
INSERT O comando é usado para adicionar linhas de dados a uma tabela existente. Depois de conhecer a estrutura da tabela, você pode construir um comando que corresponda às colunas da tabela com os valores correspondentes que deseja inserir para o novo registro. A sintaxe básica do comando se parece com isso:
INSERT INTO my_table(column1, column2)VALUES ('value1', 'value2');
As colunas na lista de colunas correspondem diretamente aos valores fornecidos na lista de valores.
Por padrão, o
INSERT O comando retorna o ID do objeto (geralmente 0) e uma contagem de linhas que foram inseridas com sucesso:INSERT 0 1
Por exemplo, para inserir um novo funcionário no campo
employee tabela listada acima, poderíamos digitar:INSERT INTO employee(first_name, last_name)VALUES ('Bob', 'Smith');
INSERT 0 1
Aqui, fornecemos valores para o
first_name e last_name colunas, deixando as outras colunas para serem preenchidas por seus valores padrão. Se você consultar a tabela, verá que o novo registro foi adicionado:SELECT * FROM employee;
employee_id | first_name | last_name | last_update-------------+------------+-----------+---------------------------- 1 | Bob | Smith | 2020-08-19 21:07:00.952454(1 row)
Retornando dados de INSERT declarações
Se você quiser informações adicionais sobre os dados que foram adicionados à tabela, você pode incluir o
RETURNING cláusula no final de sua declaração. O RETURNING A cláusula especifica as colunas a serem exibidas dos registros que acabaram de ser inseridos. Por exemplo, para exibir todas as colunas dos registros que acabaram de ser inseridos, você pode digitar algo assim:
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 o
employee tabela, ficaria algo assim: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
Você também pode optar por retornar apenas colunas específicas de inserções. Por exemplo, aqui, estamos interessados apenas no ID do novo funcionário:
INSERT INTO employee(first_name, last_name)VALUES ('Delores', 'Muniz')RETURNING employee_id;
employee_id ------------- 3(1 row)INSERT 0 1
Como de costume, você também pode usar aliases de coluna para alterar os nomes das colunas na saída:
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 adicionar várias linhas de uma vez
Inserir registros uma instrução por vez é mais demorado e menos eficiente do que inserir várias linhas de uma vez. O PostgreSQL permite que você especifique várias linhas para adicionar à mesma tabela. Cada nova linha é encapsulada entre parênteses, com cada conjunto de parênteses separado por vírgulas.
A sintaxe básica para inserção de vários registros é assim:
INSERT INTO my_table(column_name, column_name_2)VALUES ('value', 'value2'), ('value3', 'value4'), ('value5', 'value6');
Para o
employee tabela que estamos referenciando, você pode adicionar quatro novos funcionários em uma única instrução digitando:INSERT INTO employee(first_name, last_name)VALUES ('Abigail', 'Spencer'), ('Tamal', 'Wayne'), ('Katie', 'Singh'), ('Felipe', 'Espinosa');
INSERT 0 4
Usando DELETE para remover linhas de tabelas
O SQL
DELETE O comando é usado para remover linhas de tabelas, funcionando como ação complementar a INSERT . Para remover linhas de uma tabela, você deve identificar as linhas que deseja segmentar fornecendo critérios de correspondência em um WHERE cláusula. A sintaxe básica fica assim:
DELETE FROM my_tableWHERE <condition>;
Por exemplo, para cada linha em nosso
employee tabela que tem seu first_name definido como Abigail , poderíamos digitar isso:DELETE FROM employeeWHERE first_name = 'Abigail';
DELETE 1
O valor de retorno aqui indica que o
DELETE comando foi processado com uma única linha sendo removida. Retornando dados de DELETE declarações
Assim como o
INSERT comando, você pode retornar as linhas afetadas ou colunas específicas das linhas excluídas adicionando um RETURNING cláusula:DELETE FROM my_tableWHERE <condition>RETURNING *;
Por exemplo, podemos verificar se o registro correto foi removido retornando todas as colunas do
employee excluído aqui: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 remover várias linhas de uma vez
Você pode remover vários itens de uma vez com
DELETE manipulando os critérios de seleção especificados no WHERE cláusula. Por exemplo, para remover várias linhas por ID, você pode digitar algo assim:
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
Você pode até deixar de fora o
WHERE cláusula para remover todas as linhas de uma determinada tabela: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
Esteja ciente, no entanto, que usar
DELETE esvaziar uma tabela de dados não é tão eficiente quanto o TRUNCATE comando, que pode remover dados sem varrer a tabela. Conclusão
Neste artigo, apresentamos alguns dos comandos mais importantes para controlar quais dados estão em suas tabelas do PostgreSQL. O
INSERT pode ser usado para adicionar novos dados às tabelas, enquanto o comando DELETE O comando especifica quais linhas devem ser removidas. Ambos os comandos são capazes de retornar as linhas que afetam e podem operar em várias linhas ao mesmo tempo. Esses dois comandos são os principais mecanismos usados para gerenciar o aumento ou diminuição do número de registros que sua tabela contém. Entender sua sintaxe básica, bem como as maneiras de combiná-las com outras cláusulas, permitirá que você preencha e limpe suas tabelas conforme necessário.
