SQLite Requête INSERT, UPDATE, DELETE avec exemple

Par : Marcus Allen Marcus Allen
Hours Le kit de préparation mis à jour

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,

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

SQLite Requête - INSÉRER, METTRE À JOUR, SUPPRIMER

Étape 2) Ouvrez la base de données "TutorielsSampleDB.db» par la commande suivante :

.open TutorialsSampleDB.db

SQLite Requête - INSÉRER, METTRE À JOUR, SUPPRIMER

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 :

SQLite INSERT

  • 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 :

SQLite insérer

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 instruction, nous avons répertorié 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'» sera inséré dans les quatre colonnes du tableau Étudiants dans le même ordre 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 insérer

ARTICLES LIÉS

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 :

SQLite Mises à jour

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 :

SQLite Mises à jour

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 Mises à jour

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 :

SQLite Supprimer

  • Vous devez écrire un nom de table après la clause DELETE FROM, à partir de laquelle vous souhaitez supprimer des enregistrements. (Remarque : que l' Clause SUPPRIMER est utilisé pour supprimer certains enregistrements d'une table ou supprimer tous les enregistrements et il ne supprimera pas la table elle-même. Cependant, le Clause DROP est utilisé pour supprimer la table entière avec tous les enregistrements qu'elle contient.)
  • 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 "ID étudiant = 11 OU ID étudiant = 12» sera vrai uniquement pour les étudiants avec les identifiants 11 et 12. Ainsi, la clause DELETE sera appliquée aux deux et les supprimera uniquement.

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

SQLite Supprimer

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 Supprimer

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. RETOUR EN ARRIERE – cela annulera la transaction dans laquelle le courant 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. Abandonner – cela abandonnera (annulera) le courant 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. ÉCHOUER - abandonne le courant 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.
  1. IGNORER – cela ignorera la ligne qui contient la violation de contrainte et continuera à traiter les autres lignes suivantes de la 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.
  1. REMPLACER – cela dépend du type de contrainte qui a la violation :
  • 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 5 résolutions ci-dessus sont des options sur la manière dont vous souhaitez résoudre le conflit. Il se peut que ce qui est applicable pour résoudre un conflit ne soit pas nécessairement applicable pour résoudre d’autres types de conflits.

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 :

SQLite Clause de conflit

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 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 choisissons une résolution de conflit comme étant «IGNORER" .

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

SUR LE CONFLIT IGNORER Exemple

É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:

SUR LE CONFLIT IGNORER Exemple

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

SELECT * FROM Subjects;

Cela vous donnera la liste des sujets :

SUR LE CONFLIT IGNORER Exemple

Notez que seuls trois sujets ont été insérés "Algèbre, cours de base 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 choisissons une option de résolution de conflit comme étant «REMPLACER« . La commande devrait s'exécuter correctement et vous ne devriez obtenir aucune erreur :

SUR LE CONFLIT REMPLACEMENT Exemple

É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:

SUR LE CONFLIT REMPLACEMENT Exemple

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

SELECT * FROM Subjects;

Cela vous donnera la liste des sujets :

SUR LE CONFLIT REMPLACEMENT Exemple

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 qui a la valeur qui viole la contrainte de clé primaire, qui est «Structures de données" a remplacé la valeur "Cours de base 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 SQLite essaie d'exécuter la troisième instruction d'insertion avec SubjectId 2 et SubjectName "Structures de données», il découvre 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 choisira une résolution REPLACE pour ce conflit. Il remplace la valeur qui existe déjà dans la table des sujets par la nouvelle valeur de l'instruction insert. Alors le "Cours de base de données« Nom du sujet sera remplacé par »Structures de données" Nom du sujet.

Résumé

Les clauses INSERT, UPDATE et DELETE sont utilisées pour modifier les données dans le SQLite base de données. La clause CONFLICT est une clause puissante pour résoudre tout conflit entre les données et les données à modifier.

Tu pourrais aimer: