Introduzione
L'aggiunta e la rimozione di record dalle tabelle sono alcune delle operazioni più comuni eseguite dai database. L'aggiunta di dati implica la specifica dei nomi di tabelle e colonne a cui desideri aggiungere valori, nonché i valori che desideri inserire in ciascun campo. L'eliminazione dei record implica l'identificazione della riga o delle righe corrette e la loro rimozione dalla tabella.
In questa guida, illustreremo come utilizzare l'SQL INSERT e DELETE comandi con PostgreSQL. Ciò include la sintassi di base, come restituire le informazioni sui dati che sono stati elaborati e come aggiungere o rimuovere più righe in una singola istruzione.
Revisione della struttura della tabella
Prima di utilizzare il INSERT comando, è necessario conoscere la struttura della tabella in modo da poter soddisfare i requisiti imposti dalle colonne, dai tipi di dati e dai vincoli della tabella. Esistono diversi modi per farlo a seconda del client del database.
Se stai usando psql client della riga di comando, il modo più semplice per trovare queste informazioni è utilizzare \d+ metacomando integrato nello strumento.
Ad esempio, per trovare la struttura di una tabella chiamata employee , dovresti digitare questo:
\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
L'output mostra i nomi delle colonne della tabella, i tipi di dati e i valori predefiniti, tra gli altri.
Il \d+ meta comando è disponibile solo con psql client, quindi se stai utilizzando un client diverso, potresti dover interrogare direttamente le informazioni sulla tabella. Puoi ottenere la maggior parte delle informazioni rilevanti con una query come questa:
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)
Questi dovrebbero darti una buona idea della struttura della tabella in modo da poter inserire i valori correttamente.
Utilizzo di INSERT per aggiungere nuovi record alle tabelle
L'SQL INSERT Il comando viene utilizzato per aggiungere righe di dati a una tabella esistente. Una volta che conosci la struttura della tabella, puoi costruire un comando che abbini le colonne della tabella con i valori corrispondenti che desideri inserire per il nuovo record.
La sintassi di base del comando è simile alla seguente:
INSERT INTO my_table(column1, column2)VALUES ('value1', 'value2');
Le colonne nell'elenco delle colonne corrispondono direttamente ai valori forniti nell'elenco dei valori.
Per impostazione predefinita, il INSERT il comando restituisce l'ID oggetto (solitamente 0) e un conteggio delle righe che sono state inserite correttamente:
INSERT 0 1
Ad esempio, per inserire un nuovo dipendente nel employee tabella sopra elencata, potremmo digitare:
INSERT INTO employee(first_name, last_name)VALUES ('Bob', 'Smith');
INSERT 0 1
Qui forniamo i valori per il first_name e last_name colonne lasciando che le altre colonne vengano popolate con i loro valori predefiniti. Se interroghi la tabella, puoi vedere che il nuovo record è stato aggiunto:
SELECT * FROM employee;
employee_id | first_name | last_name | last_update-------------+------------+-----------+---------------------------- 1 | Bob | Smith | 2020-08-19 21:07:00.952454(1 row)
Restituzione dei dati da INSERT dichiarazioni
Se desideri ulteriori informazioni sui dati che sono stati aggiunti alla tabella, puoi includere il RETURNING clausola alla fine della tua dichiarazione. Il RETURNING La clausola specifica le colonne da visualizzare dei record appena inseriti.
Ad esempio, per visualizzare tutte le colonne dei record appena inseriti, puoi digitare qualcosa del genere:
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
Utilizzando il employee table, questo sarebbe simile a questo:
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
Puoi anche scegliere di restituire solo colonne specifiche dagli inserimenti. Ad esempio, qui siamo interessati solo all'ID del nuovo dipendente:
INSERT INTO employee(first_name, last_name)VALUES ('Delores', 'Muniz')RETURNING employee_id;
employee_id ------------- 3(1 row)INSERT 0 1
Come al solito, puoi anche utilizzare gli alias di colonna per modificare i nomi delle colonne nell'output:
INSERT INTO employee(first_name, last_name)VALUES ('Simone', 'Kohler')RETURNING employee_id AS "Employee ID";
Employee ID------------- 4(1 row)INSERT 0 1
Utilizzo di INSERT per aggiungere più righe contemporaneamente
L'inserimento di record un'istruzione alla volta richiede più tempo e meno efficiente rispetto all'inserimento di più righe contemporaneamente. PostgreSQL ti consente di specificare più righe da aggiungere alla stessa tabella. Ogni nuova riga è racchiusa tra parentesi, con ogni serie di parentesi separate da virgole.
La sintassi di base per l'inserimento di più record è la seguente:
INSERT INTO my_table(column_name, column_name_2)VALUES ('value', 'value2'), ('value3', 'value4'), ('value5', 'value6');
Per il employee tabella a cui abbiamo fatto riferimento, puoi aggiungere quattro nuovi dipendenti in una singola istruzione digitando:
INSERT INTO employee(first_name, last_name)VALUES ('Abigail', 'Spencer'), ('Tamal', 'Wayne'), ('Katie', 'Singh'), ('Felipe', 'Espinosa');
INSERT 0 4
Utilizzo di DELETE per rimuovere righe dalle tabelle
L'SQL DELETE Il comando viene utilizzato per rimuovere righe dalle tabelle, fungendo da azione complementare a INSERT . Per rimuovere righe da una tabella, devi identificare le righe che desideri scegliere come target fornendo criteri di corrispondenza all'interno di un WHERE clausola.
La sintassi di base è simile alla seguente:
DELETE FROM my_tableWHERE <condition>;
Ad esempio, a ogni riga del nostro employee tabella che ha il suo first_name impostato su Abigail , potremmo digitare questo:
DELETE FROM employeeWHERE first_name = 'Abigail';
DELETE 1
Il valore restituito qui indica che DELETE il comando è stato elaborato con la rimozione di una singola riga.
Restituzione dei dati da DELETE dichiarazioni
Come con INSERT comando, puoi restituire le righe interessate o colonne specifiche dalle righe eliminate aggiungendo un RETURNING clausola:
DELETE FROM my_tableWHERE <condition>RETURNING *;
Ad esempio, possiamo verificare che il record corretto sia stato rimosso restituendo tutte le colonne dal employee eliminato qui:
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
Utilizzo di DELETE per rimuovere più righe contemporaneamente
Puoi rimuovere più elementi contemporaneamente con DELETE manipolando i criteri di selezione specificati nel WHERE clausola.
Ad esempio, per rimuovere più righe per ID, puoi digitare qualcosa del genere:
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
Puoi anche omettere WHERE clausola per rimuovere tutte le righe da una determinata tabella:
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
Tieni presente, tuttavia, che usando DELETE svuotare una tabella di dati non è efficiente come TRUNCATE comando, che può rimuovere i dati senza scansionare la tabella.
Conclusione
In questo articolo, abbiamo introdotto alcuni dei comandi più importanti per controllare quali dati si trovano nelle tabelle PostgreSQL. Il INSERT il comando può essere utilizzato per aggiungere nuovi dati alle tabelle, mentre il comando DELETE comando specifica quali righe devono essere rimosse. Entrambi i comandi sono in grado di restituire le righe che interessano e possono operare su più righe contemporaneamente.
Questi due comandi sono i meccanismi principali utilizzati per gestire l'aumento o la diminuzione del numero di record contenuti nella tabella. Ottenere un controllo sulla loro sintassi di base e sui modi in cui possono essere combinati con altre clausole ti consentirà di popolare e pulire le tue tabelle secondo necessità.
