Si vous avez travaillé avec des systèmes de bases de données relationnelles, il est probable que vous ayez entendu parler de systèmes de bases de données populaires tels que MySQL, SQL Server ou PostgreSQL. SQLite est un autre RDBMS extrêmement utile, très simple à configurer et à utiliser. En outre, il possède de nombreuses fonctionnalités distinctes par rapport aux autres bases de données relationnelles. Ce didacticiel SQLite enseigne les concepts de base que vous devez connaître à l'aide de pratiques pratiques approfondies.
Les sujets abordés dans cet article sont :
- Qu'est-ce que SQLite ?
- Fonctionnalités de SQLite
- Installer SQLite sous Windows
- Commandes SQLite
- Commandes de base de données
- Commandes de tableau
- Opérations CRUD
- Clauses/Conditions SQLite
- Joints dans SQLite
- Inconvénients de SQLite
Tutoriel SQLite :Qu'est-ce que SQLite ?
Voici la définition standard de l'industrie de SQLite :
SQLite est un moteur de base de données transactionnelle open source, sans configuration, autonome et autonome, conçu pour être intégré dans une application.
Vous pouvez envisager SQLite comme "briquet ” version d'autres SGBDR complexes (Oracle, SQL, etc.), où son moteur de base de données est configuré pour un traitement indépendant (bibliothèque in-process) c'est-à-dire un sans serveur, autonome, sans configuration et transactionnel . Il est connu pour sa portabilité, sa fiabilité et ses performances élevées, même dans des environnements à faible mémoire. En outre, SQLite est un choix populaire en tant que base de données intégrée pour le stockage local/client dans les programmes ou applications finaux, contrairement aux autres SGBDR, où le moteur de base de données client-serveur est configuré.
Fonctionnalités de SQLite
SQLite offre de nombreuses fonctionnalités distinctes telles que :
- Sans serveur : La plupart des bases de données SQL sont implémentées en tant que processus serveur distinct, mais SQLite n'a pas de processus serveur distinct. C'est un moteur de base de données sans serveur. Il lit et écrit directement dans les fichiers de disque ordinaires.
- Zéro-Configuration : Il ne nécessite aucune configuration pour le faire fonctionner. Cela signifie qu'aucun processus serveur ne doit être démarré, arrêté ou configuré comme dans un système client/serveur.
- Saisie du manifeste : SQLite utilise le typage manifeste, qui permet le stockage de n'importe quelle quantité de n'importe quel type de données dans n'importe quelle colonne, quel que soit le type de données déclaré de la colonne. Notez qu'il existe certaines exceptions à cette règle.
- Léger : Comme son nom l'indique, la bibliothèque SQLite est très légère. Le fait est que, bien que l'espace qu'il utilise varie en fonction du système sur lequel il est installé, il peut occuper moins de 600 Kio d'espace.
- Portable : Contrairement aux autres SGBD, une base de données SQLite entière est stockée dans un seul fichier. Ce fichier peut être partagé très facilement via un support amovible ou un protocole de transfert de fichiers.
- Choix varié : De nombreux langages de programmation fournissent des liaisons pour SQLite, notamment C, C++, C#, Java, JavaScript, Ruby, Python et bien d'autres.
- Gratuit : SQLite est gratuit et open-source. Pour travailler avec SQLite, une licence commerciale n'est pas requise.
Comme indiqué ci-dessus, SQLite est connu pour sa configuration zéro, ce qui signifie qu'aucune configuration ou administration complexe n'est vraiment requise. Dans la prochaine partie de ce didacticiel SQLite, voyons comment installer SQLite sur votre système.
Tutoriel SQLite :Installer SQLite sous Windows
Les étapes à suivre sont :
Étape 1 : Allez sur le site officiel de SQLite et cliquez sur le lien approprié pour télécharger les binaires précompilés.
Étape 2 : Téléchargez le fichier zip de ligne de commande SQLite (ici :sqlite-tools-win32-x86-3270200.zip) et décompressez ces fichiers dans un dossier de votre choix.
Cet outil de ligne de commande SQLite contiendra les produits SQLite suivants
- Cœur SQLite :Le noyau SQLite contient le moteur de base de données et l'API publique.
- Outil de ligne de commande SQLite3 :L'application sqlite3 est un outil de ligne de commande qui repose sur le noyau SQLite.
- Extension TCL :Cette bibliothèque est essentiellement une copie du noyau SQLite avec les liaisons Tcl ajoutées.
- Outil d'analyse SQLite :L'outil d'analyse SQLite est utilisé pour analyser les fichiers de base de données.
Étape 3 : Après cela, lancer la ligne de commande SQLite est aussi simple que de cliquer sur l'application sqlite3, ce qui fera apparaître la ligne de commande.
Si vous souhaitez tester davantage, tapez simplement .help commande depuis sqlite> invite à voir toutes les commandes disponibles dans sqlite3 comme indiqué ci-dessous.
Remarque : Par défaut, une session SQLite utilise la base de données en mémoire, par conséquent, toutes les modifications seront supprimées à la fin de la session.
Assez simple non? Ensuite, commençons avec les commandes SQLite.
Tutoriel SQLite :Commandes SQLite
Cette section du didacticiel SQLite présente les instructions SQL de base que vous pouvez utiliser avec SQLite.
Remarque : Les commandes SQLite se terminent par un point-virgule (; ). Il indique à SQLite que votre commande est terminée et doit être exécutée. Vous pouvez également répartir votre commande sur plusieurs lignes et utiliser le point-virgule sur la dernière ligne.
Commandes de base de données
Cette section se compose de ces commandes, par lesquelles vous pouvez gérer votre base de données. Les commandes sont :
- SQLite Créer une base de données
SQLite n'utilise pas l'instruction CREATE DATABASE comme dans d'autres systèmes de gestion de bases de données relationnelles, tels que MySQL, SQL Server, etc. Pour créer une nouvelle base de données dans SQLite, entrez simplement sqlite3 suivi par le nom du fichier que vous souhaitez utiliser pour la base de données. Le code suivant crée un fichier de base de données appelé StudentDetails.db :
Exemple
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- Base de données SQLite Attach
Lorsque vous avez plusieurs bases de données, vous ne pouvez en utiliser qu'une à la fois. Dans SQLite, l'instruction ATTACH DATABASE est utilisée pour attacher une base de données particulière pour la connexion en cours. Après cette commande, toutes les instructions SQLite seront exécutées sous la base de données attachée.
Exemple
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- SQLite Detach Database
Dans SQLite, l'instruction DETACH DATABASE est utilisée pour détacher la base de données nommée par alias d'une connexion à la base de données qui était précédemment attachée à l'aide de l'instruction ATTACH. Si le même fichier de base de données a été joint avec plusieurs alias, cette commande ne déconnectera que le nom donné et le reste de la pièce jointe continuera d'exister. Les bases de données de la base de données en mémoire ou temporaire seront complètement détruites et le contenu sera perdu.
Exemple
sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db sqlite> DETACH DATABASE 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db
Commandes de tableau
Ici, nous allons apprendre à gérer les tables lors de l'utilisation de SQLite.
- Créer une table SQL
Dans SQLite, l'instruction CREATE TABLE est utilisée pour créer une nouvelle table. Lors de la création de la table, vous devez nommer la table et définir sa colonne et les types de données de chaque colonne.
Syntaxe :
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Exemple
CREATE TABLE StudentInfo( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), DEPARTMENTID INTEGER NOT NULL, PHONE TEXT DEFAULT 'UNKNOWN', FOREIGN KEY(DEPARTMENTID) REFERENCES DepartmentInfo(DeptID) );
Vous pouvez vérifier si la table a été créée ou non en utilisant les .tables commande comme indiqué ci-dessous. Notez que j'ai déjà créé une table appelée DepartmentInfo où DeptID est la clé primaire. La table Departments a une contrainte de clé étrangère sur la table Students.
sqlite> .tables StudentInfo Contacts Emp_Master
- Tableau Drop SQLite
Dans SQLite, l'instruction DROP TABLE vous permet de supprimer ou de supprimer une table de la base de données SQLite. Une fois la table supprimée, toutes les données qu'elle contient sont définitivement supprimées de la base de données. Tous les index et déclencheurs associés sont également supprimés. Si une contrainte de clé étrangère est activée sur cette table, elle sera supprimée de manière équivalente pour chaque ligne de la table et tous les déclencheurs associés à la table seront également supprimés.
Syntaxe
DROP TABLE [ IF EXISTS ] table_name;
Exemple
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Remarque : IF EXISTS, est une clause facultative. Si spécifié, l'instruction DROP TABLE ne déclenchera pas d'erreur si l'une des tables n'existe pas.
Il existe également une instruction SQLite Alter Table , que nous comprendrons dans les prochaines sections de cet article. Maintenant que nous avons créé un tableau, voyons comment insérer, supprimer et modifier les données.
Tutoriel SQLite :Opérations CRUD
- Requête d'insertion SQLite
Après avoir créé la table, la commande SQLite Insérer dans peut être utilisée pour créer de nouvelles lignes dans la table spécifiée. Il existe deux formes significatives de l'instruction d'insertion SQLite. Le premier formulaire utilise une clause VALUES pour spécifier une liste de valeurs à insérer.
Syntaxe
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Exemple
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Sortie
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Ici, une seule nouvelle ligne est créée et chaque valeur est enregistrée dans sa colonne respective. Notez que les deux listes doivent avoir le même nombre d'objets. Ici, la liste des colonnes est facultatif. Nous pouvons également insérer des données dans le tableau sans spécifier la liste des colonnes .
Exemple
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Sortie
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite offre également une fonctionnalité pourinsérer plusieurs lignes dans une seule instruction INSERT. La syntaxe est comme indiqué ci-dessous.
Exemple
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Sortie
Select *from StudentInfo; 1|Dean|20|California|2|934******* 2|SAM|22|Texas|2|976******* 3|John|23|Norway|1|923******* 4|Mitch|22|Houston|3|934*******
Comme vous pouvez le voir, le format de la sortie n'est pas tout à fait similaire à celui d'avant. Alors, comment changez-vous le format de sortie dans SQLite ? Formatons la sortie afin que nos résultats soient un peu plus faciles à lire.
- Formatage
Vous pouvez utiliser .mode pour changer le mode de sortie. L'exemple ci-dessus utilise .mode list, qui affiche les résultats sous forme de liste. Vous pouvez également utiliser .headers pour spécifier s'il faut ou non afficher les en-têtes de colonne. Une fois les modifications effectuées, vous pouvez afficher le paramètre à l'aide de .show commande.
Exemple
sqlite>.mode 'column' sqlite> .headers on sqlite> .show echo: off eqp: off explain: auto headers: on mode: column nullvalue: "" output: stdout colseparator: "|" rowseparator: "n" stats: off width: filename: StudentDetails.db
Sortie
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENT PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- Requête de sélection SQLite
Dans SQLite, l'instruction Select est utilisée pour extraire des données d'une table, qui renvoie des données sous la forme d'une table de résultats. Ces tableaux de résultats sont également appelés jeux de résultats. En utilisant l'instruction de sélection SQLite, nous pouvons effectuer des calculs simples ou plusieurs expressions en fonction de nos besoins. Nous avons déjà utilisé une instruction SELECT précédemment lorsque nous avons inséré des données.
Syntaxe
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINCT – Lorsque nous utilisons un mot-clé distinct dans une instruction select, il ne renvoie que des lignes de données distinctes.
- TOUS – Si nous utilisons le mot-clé ALL dans une instruction select, il renvoie toutes les lignes de données même si elles sont dupliquées.
- À PARTIR de la liste des tables – Il s'agit d'une liste de tables à partir desquelles vous souhaitez obtenir des données.
- expression OÙ – L'expression WHERE est utilisée pour définir nos conditions personnalisées afin d'obtenir les données requises à partir des tables.
Exemple1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Sortie
ID NAME ---------- ---------- 1 Dean
Exemple2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Sortie
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- Requête de mise à jour SQLite
Dans SQLite, l'instruction UPDATE peut être utilisée pour modifier les enregistrements existants dans une table. La clause WHERE de SQLite peut être utilisée pour spécifier exactement quelles lignes doivent être mises à jour. Vous pouvez facilement mettre à jour toutes les lignes, certaines lignes ou aucune, selon les conditions de filtrage appliquées par la clause WHERE.
Syntaxe
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Exemple
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Sortie
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 4 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- Requête de suppression SQLite
Dans SQLite, l'instruction DELETE peut être utilisée pour supprimer l'enregistrement de la table. Vous pouvez facilement supprimer toutes les lignes, certaines lignes ou aucune, selon les conditions de filtrage appliquées par la clause WHERE.
Exemple
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Sortie
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Si vous essayez de supprimer un enregistrement référencé par une clé étrangère, vous obtiendrez une erreur. Vous devrez d'abord supprimer les enregistrements de clé étrangère, avant de supprimer l'enregistrement de clé primaire. Essayons de supprimer le département science.
Exemple
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Nous devons donc supprimer les enregistrements de clé étrangère avant de supprimer la clé primaire.
DELETE FROM StudentInfo WHERE DEPARTMENTID = 4; sqlite> DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; sqlite> SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
Vous savez maintenant comment modifier les enregistrements dans la table de la base de données SQLite. Pour aller plus loin dans ce blog de didacticiel SQLite, discutons des différentes clauses et conditions que vous rencontrez le plus fréquemment dans SQLite.
Clauses/Conditions SQLite
Avant de commencer avec les clauses, voici la syntaxe complète de l'instruction SELECT dans SQLite.
Syntaxe
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr] [GROUP BY expr-list] [HAVING expr] [compound-op select]* [ORDER BY sort-expr-list] [LIMIT integer [(OFFSET|,) integer]]
Remarque :J'ai mis à jour les tables StudentInfo et DepartmentInfo comme indiqué ci-dessous.
//Student Table ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934******* 2 SAM 22 Texas 4 976******* 5 Johny 23 Norway 2 945******* 6 Robin 23 Norway 2 UNKNOWN //Department Details DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music 5 Science
- SQLite OÙ
Dans SQLite, la clause WHERE est utilisée pour imposer des restrictions à l'instruction SELECT en définissant une ou plusieurs conditions pour obtenir les données requises à partir des tables de la base de données. Si la condition spécifiée est satisfaite ou vraie, elle renvoie une valeur spécifique de la table. Comme vous l'avez vu auparavant, la clause WHERE n'est pas seulement utilisée dans l'instruction SELECT, mais elle est également utilisée dans l'instruction UPDATE, DELETE, etc.
Exemple
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
Dans SQLite, il existe un certain nombre d'opérateurs relationnels qui peuvent être utilisés avec la clause WHERE.
- SQLite GROUP BY
Dans SQLite, la clause GROUP BY est utilisée pour agréger les données dans une seule ligne où la valeur d'une ou plusieurs colonnes spécifiées est répétée. Cette clause est utilisée avec la clause WHERE dans l'instruction SELECT et précède la clause ORDER BY.
Syntaxe
SELECT result FROM [table-list] GROUP BY [expr-list]
SELECT NAME, ADDRESS FROM StudentInfo GROUP BY NAME; NAME ADDRESS ---------- ---------- Dean California John Norway Johny Norway Mitch Houston Robin Norway SAM Texas
Notez que le processus de regroupement comporte deux étapes. Tout d'abord, l'expression GROUP BY est utilisée pour organiser les lignes du tableau en différents groupes. Une fois les groupes définis, l'instruction SELECT définit comment ces groupes sont aplatis en une seule ligne.
- SQLite ORDER BY
Généralement, les tables SQLite stockent les données dans un ordre non spécifié et renverront les enregistrements dans le même ordre non spécifié lors de la récupération des données à l'aide de l'instruction de sélection SQLite. Dans de tels cas, vous pouvez utiliser la clause ORDER BY pour trier les enregistrements de colonne dans l'ordre croissant ou décroissant. Dans l'exemple ci-dessous, j'ai regroupé et ordonné9en ordre décroissant) les données en fonction de l'adresse.
Syntaxe
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Exemple
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS ORDER BY ADDRESS DESC; ADDRESS COUNT(ADDRESS) ---------- -------------- Texas 1 Norway 3 Houston 1 California 1
- SQLite AYANT PAR
Dans SQLite, le AVOIR la clause est identique à WHERE clause. La clause HAVING est une condition supplémentaire appliquée après l'agrégation avec le group by dans l'instruction select. Généralement dans SQLite, WHERE La clause est utilisée pour appliquer une condition à des éléments individuels dans une table et la HAVING La clause est utilisée pour ajouter des conditions de filtre basées sur les groupes créés par la clause Group By.
Exemple
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- Clause de limite SQLite
Dans SQLite, la clause LIMIT est utilisée pour définir une limite aux enregistrements renvoyés par l'instruction select. Prenons un exemple pour comprendre le concept.
Syntaxe
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Exemple
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET est facultatif et définit le nombre de lignes à ignorer au début du jeu de résultats en fonction de offset_value .
- SQLite AND &OR
Dans SQLite, les opérateurs ET et OU sont utilisés pour effectuer plusieurs conditions sur les instructions de sélection, d'insertion, de mise à jour et de suppression en fonction de nos exigences. L'opérateur SQLite AND renverra les lignes ou les enregistrements qui satisfont aux conditions définies à l'aide de l'opérateur AND.
Exemple1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
La condition OR est utilisée pour définir plusieurs conditions dans les instructions SQLite et renverra des lignes ou des enregistrements à partir de l'instruction si l'une des conditions est satisfaite.
Exemple2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- Opérateur SQLite GLOB
Dans SQLite, l'opérateur GLOB est utilisé pour vérifier si la valeur de chaîne donnée correspond à un modèle spécifique ou non. Si la valeur de la chaîne correspond à la valeur du modèle, elle renverra true et il est similaire à l'opérateur LIKE. De plus, GLOB est sensible à la casse.
Syntaxe
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Exemple
SELECT *FROM StudentInfo WHERE NAME GLOB 'Joh*'; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 3 John 23 Norway 1 923******* 5 Johny 23 Norway 2 945*******
- SQLite Distinct
Dans SQLite, le mot-clé DISTINCT analyse le jeu de résultats de l'instruction SELECT et élimine les lignes en double. De plus, les valeurs NULL sont considérées comme des doublons, donc si nous utilisons la clause DISTINCT avec une colonne contenant des valeurs NULL, elle ne conservera qu'une seule ligne d'une valeur NULL. Lorsque vous appliquez DISTINCT pour plusieurs colonnes, l'instruction renvoie chaque combinaison unique de coulnm1 et colonne2.
Exemple
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- Opérateur SQLite IN
Dans SQLite, l'opérateur IN est utilisé pour déterminer si la valeur donnée correspond à une liste de valeurs données ou au résultat renvoyé par la sous-requête.
Exemple
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALL
Dans SQLite, l'opérateur UNION est utilisé pour combiner les ensembles de résultats de 2 ou plusieurs instructions SELECT et supprime les lignes en double entre les différentes instructions SELECT. N'oubliez pas que les instructions SELECT que nous avons utilisées avec l'opérateur UNION doivent avoir le même nombre de champs dans les ensembles de résultats avec des types de données similaires.
Syntaxe
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Exemple
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
L'opérateur UNION ALL est utilisé pour combiner les ensembles de résultats de 2 ou plusieurs instructions SELECT et il renverra toutes les lignes, y compris les doublons.
Exemple
SELECT DEPARTMENTID FROM StudentInfo UNION ALL SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 1 2 2 2 2 3 3 4 4 5
Avec cela, nous avons couvert les commandes les plus élémentaires que vous pourriez avoir à utiliser lorsque vous travaillez avec SQLite. Pour aller de l'avant avec ce didacticiel SQLite, examinons l'instruction de jointure dans SQLite.
Joints dans SQLite
Dans SQLite, les jointures sont utilisées pour combiner des enregistrements de deux tables ou plus dans une base de données et obtenir des enregistrements en fonction de nos besoins. Les différents types de JOINS disponibles dans SQLite sont :
- Jointure interne - INNER JOIN est utilisé pour combiner et renvoyer uniquement les enregistrements correspondants de plusieurs tables en fonction des conditions définies dans les instructions SQLite.
- Jointure externe - SQLite Outer Join sélectionnera les lignes correspondantes de plusieurs tables de la même manière que Inner Join et quelques autres lignes en dehors de la relation. En termes simples, nous pouvons dire que SQLite OUTER JOIN est un ajout de INNER JOIN. Généralement, nous avons trois types de jointures externes dans la norme SQL, à savoir les jointures externes LEFT, RIGHT et FULL, mais SQLite ne prend en charge que LEFT OUTER JOIN.
- Jointure croisée – Il est utilisé pour obtenir le produit cartésien des lignes en faisant correspondre chaque ligne du premier tableau avec chaque ligne du second tableau.
- Auto-jointure – Il est utilisé pour joindre la même table avec elle-même. Pour utiliser Self Join, nous devons créer différents noms d'alias pour la même table afin d'effectuer des opérations en fonction de nos besoins.
Le concept est similaire à celui d'autres systèmes de bases de données relationnelles comme SQL. Donc, pour en savoir plus, vous pouvez vous référer à cet article sur les jointures SQL.
Avec cela, nous avons couvert les commandes SQLite de base. Les concepts avancés ne sont pas abordés ici. Alors, restez à l'écoute pour un autre article sur les concepts avancés de SQLite. Même avec toutes les bonnes fonctionnalités que SQLite a à offrir, il présente également certains inconvénients.
Tutoriel SQLite :Inconvénients de SQLite
Vous trouverez ci-dessous la liste des inconvénients de l'utilisation de SQLite :
- Cela ne fonctionne pas bien dans l'architecture client/serveur.
- La taille d'une base de données SQLite est limitée à 2 Go dans la plupart des cas.
- SQLite n'a pas implémenté RIGHT OUTER JOIN et FULL OUTER JOIN. Avec SQLite, nous ne pouvons implémenter LEFT OUTER JOIN.
- Les vues dans SQLite sont en lecture seule. Nous ne pouvons pas utiliser les instructions DML (Insert, Update et Delete) avec les vues.
- Nous ne pouvons pas utiliser les instructions GRANT et REVOKE avec SQLite.
Avec cela, nous arrivons à la fin de ce didacticiel SQLite.
Si vous souhaitez en savoir plus sur MySQL et découvrir cette base de données relationnelle open source, consultez notre Formation de certification MySQL DBA qui vient avec une formation en direct dirigée par un instructeur et une expérience de projet réelle. Cette formation vous aidera à comprendre MySQL en profondeur et vous aidera à maîtriser le sujet.
Vous avez une question pour nous ? Veuillez le mentionner dans la section des commentaires de ce didacticiel SQLite et je vous répondrai.
