Inleiding
Records toevoegen aan en verwijderen uit tabellen zijn enkele van de meest voorkomende bewerkingen die databases uitvoeren. Het toevoegen van gegevens omvat het specificeren van de tabel- en kolomnamen waaraan u waarden wilt toevoegen, evenals de waarden die u in elk veld wilt invoeren. Het verwijderen van records omvat het identificeren van de juiste rij of rijen en deze uit de tabel verwijderen.
In deze handleiding behandelen we het gebruik van de SQL INSERT en DELETE commando's met PostgreSQL. Dit omvat de basissyntaxis, hoe u gegevens kunt retourneren over de gegevens die zijn verwerkt en hoe u meerdere rijen in één instructie kunt toevoegen of verwijderen.
De structuur van de tabel bekijken
Voordat u de INSERT . gebruikt opdracht, moet u de structuur van de tabel kennen, zodat u kunt voldoen aan de vereisten die worden opgelegd door de kolommen, gegevenstypen en beperkingen van de tabel. Er zijn een paar verschillende manieren om dit te doen, afhankelijk van uw databaseclient.
Als u de psql . gebruikt opdrachtregelclient, is de meest eenvoudige manier om deze informatie te vinden het gebruik van de \d+ meta-opdracht ingebouwd in de tool.
Om bijvoorbeeld de structuur te vinden van een tabel met de naam employee , zou je dit typen:
\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
De uitvoer geeft onder andere de kolomnamen, gegevenstypen en standaardwaarden van de tabel weer.
De \d+ meta-opdracht is alleen beschikbaar met de psql client, dus als u een andere client gebruikt, moet u mogelijk rechtstreeks de tabelinformatie opvragen. U kunt de meeste relevante informatie krijgen met een vraag als deze:
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)
Deze zouden u een goed idee moeten geven van de structuur van de tabel, zodat u waarden correct kunt invoegen.
INSERT gebruiken om nieuwe records aan tabellen toe te voegen
De SQL INSERT commando wordt gebruikt om rijen met gegevens toe te voegen aan een bestaande tabel. Zodra u de structuur van de tabel kent, kunt u een opdracht maken die overeenkomt met de kolommen van de tabel met de corresponderende waarden die u voor de nieuwe record wilt invoegen.
De basissyntaxis van het commando ziet er als volgt uit:
INSERT INTO my_table(column1, column2)VALUES ('value1', 'value2');
De kolommen in de kolomlijst komen direct overeen met de waarden in de waardenlijst.
Standaard is de INSERT commando retourneert de object-ID (meestal 0) en een aantal rijen die met succes zijn ingevoegd:
INSERT 0 1
Om bijvoorbeeld een nieuwe werknemer in te voegen in de employee bovenstaande tabel kunnen we typen:
INSERT INTO employee(first_name, last_name)VALUES ('Bob', 'Smith');
INSERT 0 1
Hier bieden we waarden voor de first_name en last_name kolommen terwijl u de andere kolommen laat vullen met hun standaardwaarden. Als u de tabel opvraagt, kunt u zien dat het nieuwe record is toegevoegd:
SELECT * FROM employee;
employee_id | first_name | last_name | last_update-------------+------------+-----------+---------------------------- 1 | Bob | Smith | 2020-08-19 21:07:00.952454(1 row)
Gegevens retourneren van INSERT uitspraken
Als u aanvullende informatie wilt over de gegevens die aan de tabel zijn toegevoegd, kunt u de RETURNING opnemen clausule aan het einde van uw verklaring. De RETURNING clausule specificeert de kolommen die moeten worden weergegeven van de records die zojuist zijn ingevoegd.
Als u bijvoorbeeld alle kolommen wilt weergeven voor de records die zojuist zijn ingevoegd, kunt u zoiets als dit typen:
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
Gebruik van de employee tabel, ziet dit er ongeveer zo uit:
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
U kunt er ook voor kiezen om alleen specifieke kolommen uit invoegingen te retourneren. Hier zijn we bijvoorbeeld alleen geïnteresseerd in de ID van de nieuwe werknemer:
INSERT INTO employee(first_name, last_name)VALUES ('Delores', 'Muniz')RETURNING employee_id;
employee_id ------------- 3(1 row)INSERT 0 1
Zoals gewoonlijk kunt u ook kolomaliassen gebruiken om de kolomnamen in de uitvoer te wijzigen:
INSERT INTO employee(first_name, last_name)VALUES ('Simone', 'Kohler')RETURNING employee_id AS "Employee ID";
Employee ID------------- 4(1 row)INSERT 0 1
INSERT gebruiken om meerdere rijen tegelijk toe te voegen
Records met één instructie tegelijk invoegen is tijdrovender en minder efficiënt dan het invoegen van meerdere rijen tegelijk. Met PostgreSQL kunt u meerdere rijen specificeren om aan dezelfde tabel toe te voegen. Elke nieuwe rij is ingekapseld tussen haakjes, waarbij elke reeks haakjes wordt gescheiden door komma's.
De basissyntaxis voor het invoegen van meerdere records ziet er als volgt uit:
INSERT INTO my_table(column_name, column_name_2)VALUES ('value', 'value2'), ('value3', 'value4'), ('value5', 'value6');
Voor de employee tabel waarnaar we hebben verwezen, kunt u vier nieuwe werknemers in één enkele verklaring toevoegen door te typen:
INSERT INTO employee(first_name, last_name)VALUES ('Abigail', 'Spencer'), ('Tamal', 'Wayne'), ('Katie', 'Singh'), ('Felipe', 'Espinosa');
INSERT 0 4
DELETE gebruiken om rijen uit tabellen te verwijderen
De SQL DELETE commando wordt gebruikt om rijen uit tabellen te verwijderen, functionerend als de aanvullende actie bij INSERT . Om rijen uit een tabel te verwijderen, moet u de rijen identificeren die u wilt targeten door overeenkomstcriteria op te geven binnen een WHERE clausule.
De basissyntaxis ziet er als volgt uit:
DELETE FROM my_tableWHERE <condition>;
Bijvoorbeeld naar elke rij in onze employee tabel met zijn first_name ingesteld op Abigail , zouden we dit kunnen typen:
DELETE FROM employeeWHERE first_name = 'Abigail';
DELETE 1
De geretourneerde waarde hier geeft aan dat de DELETE opdracht is verwerkt waarbij een enkele rij is verwijderd.
Gegevens teruggeven van DELETE uitspraken
Net als bij de INSERT commando, kunt u de betreffende rijen of specifieke kolommen uit de verwijderde rijen retourneren door een RETURNING toe te voegen clausule:
DELETE FROM my_tableWHERE <condition>RETURNING *;
We kunnen bijvoorbeeld controleren of het juiste record is verwijderd door alle kolommen van de verwijderde employee te retourneren. hier:
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
DELETE gebruiken om meerdere rijen tegelijk te verwijderen
U kunt meerdere items tegelijk verwijderen met DELETE door de selectiecriteria te manipuleren die zijn gespecificeerd in de WHERE clausule.
Als u bijvoorbeeld meerdere rijen op ID wilt verwijderen, typt u zoiets als dit:
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
Je kunt zelfs de WHERE . weglaten clausule om alle rijen uit een bepaalde tabel te verwijderen:
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
Houd er echter rekening mee dat het gebruik van DELETE het leegmaken van een tabel met gegevens is niet zo efficiënt als de TRUNCATE commando, dat gegevens kan verwijderen zonder de tabel te scannen.
Conclusie
In dit artikel hebben we enkele van de belangrijkste commando's geïntroduceerd om te bepalen welke gegevens in uw PostgreSQL-tabellen staan. De INSERT commando kan worden gebruikt om nieuwe gegevens aan tabellen toe te voegen, terwijl de DELETE commando specificeert welke rijen moeten worden verwijderd. Beide commando's kunnen de rijen die ze beïnvloeden teruggeven en kunnen op meerdere rijen tegelijk werken.
Deze twee opdrachten zijn de belangrijkste mechanismen die worden gebruikt om het aantal records dat uw tabel bevat te verhogen of te verlagen. Door grip te krijgen op hun basissyntaxis en de manieren waarop ze kunnen worden gecombineerd met andere clausules, kunt u uw tabellen zo nodig vullen en opschonen.