SQLite Requête INSERT, UPDATE, DELETE avec exemple

Requête d'insertion, de mise à jour et de suppression dans SQLite

Les clauses de modification des données dans SQLite sont les instructions INSERT, UPDATE et DELETE. Il est utilisé pour insérer de nouvelles lignes, mettre à jour des valeurs existantes ou supprimer des lignes de la base de données.

Notez que, pour tous les exemples suivants, vous devez exécuter sqlite3.exe et ouvrir une connexion à l'exemple de base de données de manière fluide :

Étape 1) Dans cette étape,

• Ouvrez Poste de travail et accédez au répertoire suivant « C:\sqlite » et
• Ouvrez ensuite « sqlite3.exe » :

Étape 2) Ouvrez la base de données « TutorialsSampleDB.db » à l’aide de la commande suivante :

.open TutorialsSampleDB.db

Vous êtes maintenant prêt à exécuter n’importe quel type de requête sur la base de données.

SQLite INSERT

SQLite INSERT est utilisé pour insérer des enregistrements dans une table spécifiée de la base de données. vous devez utiliser la clause 'INSERT'. La syntaxe de la clause INSERT est la suivante :

• Après la clause INSERT, vous devez indiquer dans quelle table vous devez insérer les valeurs.
• Après le nom de la table dans laquelle vous écrivez la liste des colonnes dans lesquelles vous souhaitez insérer les valeurs.
• Vous pouvez ignorer le nom des colonnes et ne pas y écrire.
• Si vous n'écrivez pas le nom des colonnes, les valeurs seront insérées dans toutes les colonnes du tableau avec le même ordre, les colonnes sont définies dans le tableau.
• Après la clause VALUES, vous devez lister les valeurs à insérer.
• Chaque clause INSERT insère une seule ligne. Si vous souhaitez insérer plusieurs lignes, vous devez écrire plusieurs clauses INSERT, une pour chaque ligne.

SQLite Insérer un exemple

Dans l'exemple suivant, nous allons insérer 2 lignes dans la table des étudiants, une pour chaque étudiant :

INSERT INTO Students(StudentId, StudentName, DepartmentId, DateOfBirth)
              VALUES(11, 'Ahmad', 4, '1997-10-12');

INSERT INTO Students VALUES(12, 'Aly', 4, '1996-10-12');

Cela devrait s'exécuter correctement et il n'y a aucune sortie pour ceci :

Cela insérera deux étudiants :

• Le premier étudiant avec StudentId=11, StudentName = Ahmad, DepartmentId = 4 et DateOfBirth = 1997-10-12.
• Le deuxième étudiant avec StudentId=12, StudentName = Aly, DepartmentId = 4 et DateOfBirth = 1996-10-12'.

Dans la première déclaration, nous avons listé les noms des colonnes « StudentId, StudentName, DepartmentId, DateOfBirth ». Cependant, dans la deuxième déclaration, nous ne l'avons pas fait.

Les quatre valeurs « 12, 'Aly', 4, '1996-10-12' » seront insérées dans les quatre colonnes de la table Students dans le même ordre que celui dans lequel les colonnes sont définies.

Vérifions maintenant que les deux étudiants ont été insérés dans la table Students en exécutant la commande suivante question:

SELECT * FROM Students;

Ensuite, vous devriez voir les deux étudiants renvoyés par cette requête comme suit :

SQLite Mises à jour

SQLite La requête UPDATE permet de modifier les enregistrements existants dans une table. Vous pouvez utiliser la clause WHERE avec la requête UPDATE pour mettre à jour les lignes sélectionnées. La clause UPDATE met à jour une table en modifiant une valeur pour une colonne spécifique. Voici la syntaxe de la clause UPDATE :

Comme suit:

• Après la « clause de mise à jour », vous devez écrire le nom de la table à mettre à jour.
• Vous devez écrire la « clause SET » qui sert à écrire le nom de la colonne à mettre à jour et la valeur à mettre à jour.
• Vous pouvez mettre à jour plusieurs colonnes. Vous pouvez utiliser une virgule entre chaque ligne.
• Vous pouvez spécifier une clause WHERE pour spécifier certaines lignes uniquement. Seules les lignes que l'expression évalue comme étant vraies sont mises à jour. Si vous n'avez pas spécifié de clause WHERE, toutes les lignes seront mises à jour.

SQLite Exemple de mise à jour

Dans l'instruction UPDATE suivante, nous mettrons à jour le DepartmentId de l'étudiant avec StudentId = 6 pour qu'il soit 3 :

UPDATE Students
SET DepartmentId = 3 
WHERE StudentId = 6;

Cela devrait s'exécuter correctement et vous ne devriez obtenir aucun résultat :

Dans la clause UPDATE, nous avons précisé que nous souhaitions mettre à jour la table Students.

• Dans la clause WHERE, nous avons filtré tous les étudiants pour sélectionner uniquement la ligne pour StudentId = 6.
• La clause SET mettra à jour la valeur de l'identifiant du département pour les étudiants sélectionnés à 3.

Vérifions maintenant que l'étudiant avec l'ID 6 est mis à jour, en exécutant la commande suivante :

SELECT * FROM Students WHERE StudentId = 6;

Vous devriez maintenant voir que la valeur de l'ID de service est désormais 3, comme suit :

SQLite Supprimer

SQLite La requête DELETE est utilisée pour supprimer les enregistrements existants d’une table spécifiée. Vous pouvez utiliser la clause WHERE avec les requêtes DELETE pour supprimer les lignes sélectionnées.

La clause DELETE a la syntaxe suivante :

• Vous devez indiquer le nom de la table après la clause DELETE FROM, c'est-à-dire la table dont vous souhaitez supprimer les enregistrements. (Remarque : la clause DELETE permet de supprimer certains enregistrements d'une table ou de supprimer tous les enregistrements, mais elle ne supprime pas la table elle-même. En revanche, la clause DROP permet de supprimer la table entière et tous ses enregistrements.)
• Si vous écrivez la clause DELETE comme celle-ci « DELETE FROM guru », cela supprimera tous les enregistrements de la table « guru ».
• Vous pouvez spécifier une condition WHERE avec une expression si vous souhaitez supprimer certaines lignes spécifiques. Seules les lignes pour lesquelles l'expression est évaluée à true seront supprimées. Par exemple, « DELETE FROM guru WHERE id > 5 » – cela supprimera uniquement les enregistrements dont l’identifiant est supérieur à 5.

Exemple

Dans l'instruction suivante, nous supprimerons deux étudiants avec StudentId 11 et 12 :

DELETE FROM Students WHERE StudentId = 11 OR StudentId = 12;

L'expression « StudentId = 11 OU StudentId = 12 » sera vraie uniquement pour les étudiants dont l'identifiant est 11 ou 12. La clause DELETE sera donc appliquée aux deux et ne supprimera que ces deux étudiants.

Cette commande devrait s'exécuter correctement et vous ne devriez obtenir aucun résultat comme suit :

Vous pouvez vérifier que les deux étudiants ont été supprimés en sélectionnant tous les enregistrements de la table Étudiants comme suit :

SELECT * FROM Students;

Vous ne devriez pas voir les deux étudiants avec les identifiants 11 et 12 comme suit :

SQLite Clause de conflit

Supposons que vous disposiez d'une colonne qui présente l'une des contraintes de colonne suivantes : UNIQUE, NOT NULL, CHECK ou PRIMARY KEY. Et puis vous avez essayé d'insérer ou de mettre à jour une valeur sur cette colonne avec une valeur qui entre en conflit avec cette contrainte.

Par exemple, si une colonne a une contrainte UNIQUE et que vous avez essayé d'insérer une valeur qui existe déjà (une valeur en double), ce qui est en conflit avec la contrainte UNIQUE. Ensuite, la clause CONFLICT vous permet de choisir quoi faire dans de tels cas pour résoudre ce conflit.

Avant de continuer à expliquer comment la clause CONFLICT résout le conflit. Vous devez comprendre ce qu'est une transaction de base de données.

Transaction de base de données

Le terme transaction de base de données est une liste de SQLite opérations (insertion, mise à jour ou suppression). La transaction de base de données doit être exécutée en une seule unité, soit toutes les opérations exécutées avec succès, soit aucune. Toutes les opérations seront annulées si l'une d'entre elles échoue.

Exemple de transaction de base de données

La transaction de transfert d’argent d’un compte bancaire à un autre impliquera plusieurs activités. Cette opération de transaction comprend le retrait d'argent du premier compte et son dépôt sur un autre compte. Cette transaction doit être entièrement réalisée ou entièrement annulée et ne pas échouer à mi-chemin.

Voici la liste des cinq résolutions que vous pouvez choisir dans la clause CONFLIT :

1. ANNULATION – cette option annulera la transaction en cours SQLite déclaration qui a le conflit (cela annulera toute la transaction). Par exemple, si vous essayez de mettre à jour 10 lignes et que la cinquième ligne a une valeur qui entre en conflit avec une contrainte, aucune ligne ne sera mise à jour, les 10 lignes resteront les mêmes. Une erreur sera générée.
2. ANNULER – cette action annulera l'opération en cours. SQLite seule la déclaration qui présente le conflit et la transaction ne sera pas annulée. Par exemple, si vous essayez de mettre à jour 10 lignes et que la cinquième ligne a une valeur en conflit avec une contrainte, seule la cinquième valeur ne sera pas mise à jour mais les 9 autres lignes seront mises à jour. Une erreur sera générée.
3. ÉCHEC – interrompt le processus en cours SQLite déclaration qui a le conflit. Cependant, la transaction ne se poursuivra pas, mais les modifications apportées aux lignes précédant celle présentant le conflit seront validées. Par exemple, si vous essayez de mettre à jour 10 lignes et que la cinquième ligne a une valeur qui entre en conflit avec une contrainte, seules les 4 lignes seront mises à jour et les autres non. Une erreur sera générée.
4. IGNORER – cette option ignore la ligne contenant la violation de contrainte et poursuit le traitement des lignes suivantes. SQLite déclaration. Par exemple, si vous essayez de mettre à jour 10 lignes et que la cinquième ligne a une valeur qui entre en conflit avec une contrainte, seules les 4 lignes seront mises à jour et les autres non. Il ne procédera pas plus loin pour mettre à jour les autres lignes et s'arrêtera à la ligne qui a la valeur de conflit. Aucune erreur ne sera générée.
5. REMPLACER – cela dépend du type de contrainte qui est violée :
   • Lorsqu’il y a une violation de contrainte pour la contrainte UNIQUE ou PRIMARY KEY. Le REPLACE remplacera la ligne à l'origine de la violation par la nouvelle ligne insérée ou mise à jour.
   • En cas de violation de contrainte NOT NULL, la clause REPLACE remplacera la valeur NULL par la valeur par défaut de cette colonne. Si la colonne n'a pas de valeur par défaut, alors SQLite annulera la déclaration (la déclaration sera annulée)
   • SI la violation de la contrainte CHECK se produit, la clause sera abandonnée.

Remarque : Les cinq solutions ci-dessus sont des options pour résoudre le conflit. Ce qui est applicable à un type de conflit ne l’est pas forcément à d’autres.

Comment déclarer la clause CONFLIT

Vous pouvez déclarer la clause ON CONFLICT lorsque vous définissez une contrainte pour une définition de colonne dans la clause CREATE TABLE. En utilisant la syntaxe suivante :

Vous pouvez choisir l'une des cinq résolutions pour résoudre le conflit comme expliqué précédemment.

SUR LE CONFLIT IGNORER Exemple

Étape 1) Créez un nouveau sujet de tableau comme suit :

CREATE TABLE [Subjects] (  
    [SubjectId] INTEGER NOT NULL PRIMARY KEY ON CONFLICT IGNORE,
    [SubjectName] NVARCHAR NOT NULL
);

Notez que nous avons défini une contrainte de clé primaire sur la colonne SubjectId. Cette contrainte empêche l'insertion de deux valeurs dupliquées dans la colonne SubjectId, garantissant ainsi l'unicité de toutes les valeurs de cette colonne. Notez également que nous avons choisi « IGNORER » comme mode de résolution des conflits.

La commande devrait s'exécuter correctement et vous ne devriez obtenir aucune erreur :

Étape 2) Maintenant, insérons quelques valeurs dans les nouveaux sujets de table, mais avec une valeur qui viole la contrainte de clé primaire :

INSERT INTO Subjects VALUES(1, 'Algebra');
INSERT INTO Subjects VALUES(2, 'Database Course');
INSERT INTO Subjects VALUES(2, 'Data Structures');
INSERT INTO Subjects VALUES(4, 'Algorithms');

Dans cette instruction INSERT, nous avons essayé d'insérer deux cours avec le même identifiant de sujet de clé primaire 2, ce qui constitue une violation de la contrainte de clé primaire.

Les commandes devraient fonctionner correctement et vous ne devriez obtenir aucune erreur. Comme suit:

Étape 3) Sélectionnez tous les sujets du tableau comme suit :

SELECT * FROM Subjects;

Cela vous donnera la liste des sujets :

Notez que seules trois matières ont été insérées : « Algèbre, Cours de bases de données et… » Algorithms» au lieu de 4 lignes.

La ligne dont la valeur viole la contrainte de clé primaire, à savoir « Structures de données », a été ignorée et n'a pas été insérée. Cependant, SQLite continue d'exécuter d'autres instructions après cette ligne.

Étape 4) SUPPRIMEZ les sujets de la table pour la recréer avec une clause ON CONFLICT différente pour l'exemple suivant en exécutant la commande suivante :

DROP TABLE Subjects;

La commande drop supprime la table entière. Les sujets de table n’existent plus.

SUR LE CONFLIT REMPLACEMENT Exemple

Étape 1) Créez un nouveau sujet de tableau comme suit :

CREATE TABLE [Subjects] (  
    [SubjectId] INTEGER NOT NULL PRIMARY KEY ON CONFLICT REPLACE,
    [SubjectName] NVARCHAR NOT NULL
);

Notez que nous avons défini une contrainte PRIMARY KEY sur la colonne SubjectId. La contrainte de clé primaire ne permettra pas d'insérer deux valeurs dupliquées dans la colonne SubjectId afin que toutes les valeurs de cette colonne soient uniques.

Notez également que nous avons choisi l'option « REMPLACER » pour la résolution des conflits. La commande devrait s'exécuter sans problème et vous ne devriez rencontrer aucune erreur.

Étape 2) Maintenant, insérons quelques valeurs dans la nouvelle table Sujets, mais avec une valeur qui viole la contrainte de clé primaire :

INSERT INTO Subjects VALUES(1, 'Algebra');
INSERT INTO Subjects VALUES(2, 'Database Course');
INSERT INTO Subjects VALUES(2, 'Data Structures');
INSERT INTO Subjects VALUES(4, 'Algorithms');

Dans cette instruction INSERT, nous avons essayé d'insérer deux cours avec le même identifiant de sujet de clé primaire 2, ce qui constitue une violation de la contrainte de clé primaire.

Les commandes devraient fonctionner correctement et vous ne devriez obtenir aucune erreur. Comme suit:

Étape 3) Sélectionnez tous les sujets du tableau comme suit :

SELECT * FROM Subjects;

Cela vous donnera la liste des sujets :

Notez que seuls trois sujets ont été insérés : « Algèbre, Structures de données et Algorithms» alors que nous avons essayé d'insérer 4 lignes.

La ligne dont la valeur enfreint la contrainte de clé primaire, à savoir « Structures de données », a remplacé la valeur « Cours de bases de données » comme suit :

• Les deux premières instructions insert fonctionnent correctement sans problème. Deux matières, Algèbre et Cours de base de données, seront insérées avec les identifiants 1, 2.
• Lorsque vous SQLite Lorsqu'il tente d'exécuter la troisième instruction d'insertion avec SubjectId 2 et SubjectName « Data Structures », il constate qu'il existe déjà un sujet avec SubjectId = 2. Ce qui constitue une violation de la contrainte de clé primaire définie sur la colonne SubjectId.
• SQLite La méthode REPLACE sera choisie pour résoudre ce conflit. Elle remplace la valeur existante dans la table des matières par la nouvelle valeur issue de l'instruction INSERT. Ainsi, le nom de matière « Cours de bases de données » sera remplacé par le nom de matière « Structures de données ».

FAQ