Introduction
L'ajout et la suppression d'enregistrements dans des tables font partie des opérations les plus courantes effectuées par les bases de données. L'ajout de données implique de spécifier les noms de table et de colonne auxquels vous souhaitez ajouter des valeurs ainsi que les valeurs que vous souhaitez entrer dans chaque champ. La suppression d'enregistrements implique d'identifier la ou les lignes correctes et de les supprimer du tableau.
Dans ce guide, nous verrons comment utiliser le SQL INSERT et DELETE commandes avec PostgreSQL. Cela inclut la syntaxe de base, comment renvoyer des informations sur les données qui ont été traitées et comment ajouter ou supprimer plusieurs lignes dans une seule instruction.
Examiner la structure de la table
Avant d'utiliser le INSERT , vous devez connaître la structure de la table afin de pouvoir répondre aux exigences imposées par les colonnes, les types de données et les contraintes de la table. Il existe différentes manières de procéder en fonction de votre client de base de données.
Si vous utilisez le psql client en ligne de commande, le moyen le plus simple de trouver ces informations est d'utiliser le \d+ méta commande intégrée à l'outil.
Par exemple, pour trouver la structure d'une table appelée employee , vous taperiez ceci :
\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
La sortie affiche les noms de colonne de la table, les types de données et les valeurs par défaut, entre autres.
Le \d+ la commande meta n'est disponible qu'avec le psql client, donc si vous utilisez un client différent, vous devrez peut-être interroger directement les informations de la table. Vous pouvez obtenir la plupart des informations pertinentes avec une requête comme celle-ci :
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)
Ceux-ci devraient vous donner une bonne idée de la structure du tableau afin que vous puissiez insérer correctement les valeurs.
Utilisation de INSERT pour ajouter de nouveaux enregistrements aux tables
Le SQL INSERT La commande est utilisée pour ajouter des lignes de données à une table existante. Une fois que vous connaissez la structure du tableau, vous pouvez créer une commande qui fait correspondre les colonnes du tableau avec les valeurs correspondantes que vous souhaitez insérer pour le nouvel enregistrement.
La syntaxe de base de la commande ressemble à ceci :
INSERT INTO my_table(column1, column2)VALUES ('value1', 'value2');
Les colonnes de la liste de colonnes correspondent directement aux valeurs fournies dans la liste de valeurs.
Par défaut, le INSERT La commande renvoie l'ID de l'objet (généralement 0) et le nombre de lignes insérées avec succès :
INSERT 0 1
Par exemple, pour insérer un nouvel employé dans le champ employee tableau répertorié ci-dessus, nous pourrions taper :
INSERT INTO employee(first_name, last_name)VALUES ('Bob', 'Smith');
INSERT 0 1
Ici, nous fournissons des valeurs pour le first_name et last_name colonnes tout en laissant les autres colonnes être remplies par leurs valeurs par défaut. Si vous interrogez la table, vous pouvez voir que le nouvel enregistrement a été ajouté :
SELECT * FROM employee;
employee_id | first_name | last_name | last_update-------------+------------+-----------+---------------------------- 1 | Bob | Smith | 2020-08-19 21:07:00.952454(1 row)
Renvoyer des données depuis INSERT déclarations
Si vous souhaitez des informations supplémentaires sur les données qui ont été ajoutées à la table, vous pouvez inclure le RETURNING clause à la fin de votre déclaration. Le RETURNING clause spécifie les colonnes à afficher des enregistrements qui viennent d'être insérés.
Par exemple, pour afficher toutes les colonnes des enregistrements qui viennent d'être insérés, vous pouvez saisir quelque chose comme ceci :
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
Utilisation du employee table, cela ressemblerait à ceci :
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
Vous pouvez également choisir de ne renvoyer que des colonnes spécifiques à partir des insertions. Par exemple, ici, nous ne nous intéressons qu'à l'identifiant du nouvel employé :
INSERT INTO employee(first_name, last_name)VALUES ('Delores', 'Muniz')RETURNING employee_id;
employee_id ------------- 3(1 row)INSERT 0 1
Comme d'habitude, vous pouvez également utiliser des alias de colonne pour modifier les noms de colonne dans la sortie :
INSERT INTO employee(first_name, last_name)VALUES ('Simone', 'Kohler')RETURNING employee_id AS "Employee ID";
Employee ID------------- 4(1 row)INSERT 0 1
Utilisation de INSERT pour ajouter plusieurs lignes à la fois
L'insertion d'enregistrements une instruction à la fois prend plus de temps et est moins efficace que l'insertion de plusieurs lignes à la fois. PostgreSQL vous permet de spécifier plusieurs lignes à ajouter à la même table. Chaque nouvelle ligne est encapsulée entre parenthèses, chaque ensemble de parenthèses étant séparé par des virgules.
La syntaxe de base pour l'insertion multi-enregistrement ressemble à ceci :
INSERT INTO my_table(column_name, column_name_2)VALUES ('value', 'value2'), ('value3', 'value4'), ('value5', 'value6');
Pour le employee table à laquelle nous avons fait référence, vous pouvez ajouter quatre nouveaux employés dans une seule déclaration en tapant :
INSERT INTO employee(first_name, last_name)VALUES ('Abigail', 'Spencer'), ('Tamal', 'Wayne'), ('Katie', 'Singh'), ('Felipe', 'Espinosa');
INSERT 0 4
Utilisation de DELETE pour supprimer des lignes des tableaux
Le SQL DELETE La commande est utilisée pour supprimer des lignes des tables, fonctionnant comme l'action complémentaire de INSERT . Pour supprimer des lignes d'un tableau, vous devez identifier les lignes que vous souhaitez cibler en fournissant des critères de correspondance dans un WHERE clause.
La syntaxe de base ressemble à ceci :
DELETE FROM my_tableWHERE <condition>;
Par exemple, à chaque ligne de notre employee table qui a son first_name défini sur Abigail , nous pourrions taper ceci :
DELETE FROM employeeWHERE first_name = 'Abigail';
DELETE 1
La valeur de retour ici indique que le DELETE la commande a été traitée avec une seule ligne supprimée.
Renvoyer des données depuis DELETE déclarations
Comme avec le INSERT commande, vous pouvez renvoyer les lignes affectées ou des colonnes spécifiques à partir des lignes supprimées en ajoutant un RETURNING clause :
DELETE FROM my_tableWHERE <condition>RETURNING *;
Par exemple, nous pouvons vérifier que l'enregistrement correct est supprimé en renvoyant toutes les colonnes de l'employee supprimé ici :
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
Utilisation de DELETE pour supprimer plusieurs lignes à la fois
Vous pouvez supprimer plusieurs éléments à la fois avec DELETE en manipulant les critères de sélection spécifiés dans le WHERE clause.
Par exemple, pour supprimer plusieurs lignes par ID, vous pouvez saisir quelque chose comme ceci :
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
Vous pouvez même omettre le WHERE clause pour supprimer toutes les lignes d'une table donnée :
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
Sachez cependant que l'utilisation de DELETE vider une table de données n'est pas aussi efficace que le TRUNCATE commande, qui peut supprimer des données sans balayer la table.
Conclusion
Dans cet article, nous avons présenté certaines des commandes les plus importantes pour contrôler les données contenues dans vos tables PostgreSQL. Le INSERT La commande peut être utilisée pour ajouter de nouvelles données aux tables, tandis que la commande DELETE La commande spécifie quelles lignes doivent être supprimées. Les deux commandes sont capables de renvoyer les lignes qu'elles affectent et peuvent fonctionner sur plusieurs lignes à la fois.
Ces deux commandes sont les principaux mécanismes utilisés pour gérer l'augmentation ou la diminution du nombre d'enregistrements que contient votre table. Maîtriser leur syntaxe de base ainsi que la manière dont elles peuvent être combinées avec d'autres clauses vous permettra de remplir et de nettoyer vos tables si nécessaire.
