Share
Les applications Android peuvent stocker des données d'application dans des bases de données SQLite. Dans ce tutoriel, vous apprendrez à concevoir et à manipuler les bases de données SQLite..
Ici, nous commençons par concevoir et utiliser une base de données SQLite simple pour gérer les scores des tournois d’échecs. Ce tutoriel est conçu comme un bref aperçu du fonctionnement des bases de données SQLite. Ces connaissances seront ensuite utilisées dans les prochains tutoriels de développement pour implémenter des applications Android basées sur une base de données..
Les applications Android peuvent créer et manipuler leurs propres bases de données relationnelles SQLite privées. Les développeurs peuvent également inspecter et modifier les bases de données sur un émulateur ou un périphérique Android donné à l'aide de l'outil de ligne de commande sqlite3 fourni avec l'outil de SDK Android appelé Android Debug Bridge (adb)..
Dans ce didacticiel, nous supposons que vous avez une certaine compréhension des bases de données relationnelles, en théorie, mais que vous avez besoin d’un peu de perfectionnement avant de les utiliser dans vos applications Android. Ce tutoriel particulier ne nécessite aucun outil; c'est plus un exercice théorique.
Toutefois, si vous envisagez de développer des applications Android reposant sur des bases de données SQLite, vous devez installer les outils nécessaires au développement Android, tels que le SDK Android et l'IDE Eclipse. Découvrez les nombreux autres tutoriels Android utiles disponibles ici sur Mobiletuts + pour vous aider à accomplir ces tâches..
SQLite est un moteur de base de données relationnelle léger. SQLite est rapide et peu encombrant, ce qui le rend parfait pour les appareils Android. Au lieu des bases de données serveur lourdes telles qu'Oracle et Microsoft SQL Server, chaque base de données SQLite est stockée dans un fichier unique sur le disque. Les applications Android peuvent choisir de stocker des données d'application privées dans une base de données SQLite..
Remarque: Si vous connaissez SQL, SQLite sera très facile à prendre en main. SQLite est fondamentalement un moteur de base de données SQL simplifié pour les périphériques intégrés. Pour des informations spécifiques sur SQLite, ses fonctionnalités, ses fonctionnalités et ses limitations, consultez la documentation en ligne de SQLite..
Une base de données est simplement un moyen structuré de stocker des données de manière persistante. Les données sont stockées dans des tables. Une table a des colonnes avec différents types de données. Chaque ligne d'un tableau représente un enregistrement de données. Vous trouverez peut-être utile de penser à un tableau comme une feuille de calcul Excel. Pour une perspective de programmation orientée objet, chaque table d'une base de données représente souvent un objet (représenté par une classe). Chaque colonne de la table représente un attribut de classe. Chaque enregistrement dans une table représente une instance spécifique de cet objet.
Regardons un exemple rapide. Supposons que vous disposiez d'une base de données d'entreprise avec une table appelée Employee. La table des employés peut comporter cinq colonnes: EmployéID (nombre), Prénom (chaîne), Nom (chaîne), Titre (chaîne) et Salaire (nombre). Vous pouvez ensuite ajouter un enregistrement à la base de données d'un employé nommé John Doe et un enregistrement distinct pour un employé nommé Anne Droid..
Les données contenues dans une base de données doivent être inspectées et manipulées. Les données dans une table peuvent être:
Accentsconagua
INSÉRER commander)METTRE À JOUR commander)EFFACER commander)Vous pouvez rechercher des données spécifiques dans une base de données en utilisant ce que l'on appelle une requête. Une requête (à l'aide de la commande SELECT) peut impliquer une table ou plusieurs tables. Pour créer une requête, vous devez spécifier les tables, les colonnes de données et les valeurs de données d'intérêt à l'aide du langage de commande SQL. Chaque commande SQL se termine par un point-virgule (;).
Le meilleur moyen de vraiment comprendre le fonctionnement des bases de données SQLite consiste à utiliser un exemple simple. Faisons-le. Supposons que nous ayons une application qui garde trace des scores des joueurs d'un tournoi d'échecs occasionnel. Les scores des joueurs sont enregistrés et à la fin d’une série de matches, le vainqueur est déterminé. Le score global du tournoi de chaque joueur est calculé à partir de ses performances sur:
Remarque: pour le tournoi, les scores des joueurs peuvent être basés sur une formule qui prend en compte le temps nécessaire pour gagner le jeu, ainsi que le type et le nombre de pièces laissées sur le tableau à la fin de la partie. De cette façon, un joueur fort recevra un score élevé pour avoir perdu quelques pièces puissantes et gagner le jeu rapidement. Les juges ont peut-être inclus style et attitude pour encourager le jeu léger et amusant. La manière dont les scores sont calculés n’a vraiment pas d’importance dans la définition de notre base de données; nous les stockons simplement dans la base de données. Pour simplifier, nous supposerons que les scores sont basés sur une échelle de 0 à 100.
Un schéma de base de données est simplement la définition de la structure de la base de données en termes de tables, de colonnes de données, etc. Le schéma de notre base de données de tournois est assez simple:
Le schéma de base de données TournamentScores comporte trois tables:
SQLite3 prend en charge les types de données communs suivants pour les colonnes:
ENTIER (entiers signés)RÉAL (valeurs en virgule flottante)TEXTE (Chaîne UTF-8 ou UTF-16; codée à l'aide du codage de la base de données)GOUTTE (bloc de données)Une fois que vous avez déterminé quelles colonnes sont nécessaires pour chaque table, vous êtes prêt à créer des tables dans votre schéma de base de données..
Commençons par créer la table des joueurs. Cette table nécessite un identifiant de joueur unique pour référencer chaque joueur. Nous pouvons en faire la clé primaire (pour identifier de manière unique un enregistrement dans cette table) et définir son attribut autoincrement. L'incrémentation automatique signifie que chaque fois qu'un nouvel enregistrement de joueur est ajouté, l'enregistrement obtiendra un nouvel identifiant de joueur unique. Nous voulons aussi stocker le prénom et le nom de chaque joueur - aucun null autorisé.
Ici, nous pouvons utiliser l’instruction CREATE TABLE SQL pour générer la table Players:
Joueurs CREATE TABLE (id INTEGER PRIMARY KEY AUTOINCREMENT, fname TEXT NOT NULL, lname TEXT NOT NULL);
La table de jeux est très similaire. Nous avons besoin d'un identifiant de jeu unique pour référencer chaque jeu. Nous voulons également un nom convivial pour chaque jeu et une valeur de pondération indiquant le poids du jeu dans le score du tournoi final du joueur (en pourcentage). Voici l'instruction SQL pour créer la table des jeux:
CREATE TABLE Games (id INTEGER PRIMARY KEY AUTOINCREMENT, nom de fichier TEXT, pondération REAL DEFAULT .10 CHECK (pondération<=1));
Vous pouvez également supprimer des tables à l'aide de l'instruction DROP TABLE. Par exemple, pour supprimer la table des jeux, utilisez la commande SQL suivante:
DROP TABLE Jeux;
Avant de poursuivre, ajoutons quelques données à ces tables. Pour ajouter un enregistrement à la table Players, vous devez spécifier les noms des colonnes et les valeurs dans l'ordre. Par exemple, l'instruction SQL suivante utilise la commande INSERT pour ajouter un enregistrement pour le joueur d'échecs Bobby Fisher:
INSERT dans les joueurs (fname, lname) VALUES ('Bobby', 'Fisher'); Pendant que nous y sommes, nous ajouterons deux autres joueurs: Bart Simpson (un joueur d'échecs très pitoyable) et Garry Kasparov (peut-être le meilleur joueur d'échecs de tous les temps). Dans le même temps, nous devons ajouter de nombreux enregistrements à la table des jeux. Nous ajoutons d’abord la demi-finale, qui compte pour 25% du score du tournoi du joueur:
INSCRIRE dans les jeux (nom de jeu, poids) VALEURS ('Demi-finale', 0,25); Ensuite, nous ajoutons quelques chaleurs d’échauffement, qui utilisent le poids par défaut de 10%:
INSCRIRE dans Jeux (nom du jeu) VALUES ('Warm-up Heat 1'); Enfin, nous ajoutons une finale représentant 35% du score total du tournoi:
INSCRIRE dans Jeux (nom de jeu, poids) VALEURS ('Final', 0,35); Comment savons-nous que les données que nous avons ajoutées se trouvent dans le tableau? Eh bien, c'est facile. Nous interrogeons simplement toutes les lignes d'une table à l'aide d'une instruction SELECT:
SELECT * FROM Jeux;
Ceci renvoie tous les enregistrements de la table des jeux:
id nom de jeu poids ----- --------------- ------ 1 Demi-Final 0.25 2 Chaleur d'échauffement 1 0.1 3 Chaleur d'échauffement 2 0.1 4 Chaud préparatoire 3 0,1 5 Échauffement 4 0,1 6 Final 0,35
Nous pouvons également créer nos propres colonnes et les aliaser. Par exemple, nous pouvons créer un alias de colonne appelé PlayerName qui est une colonne calculée: il s’agit du nom et du prénom du joueur concaténés à l’aide de || opérateur, séparé par un espace:
SELECT fname || "|| lname AS PlayerName, id FROM Players;
Cette requête produit les résultats suivants:
PlayerName id ------------ - Bobby Fisher 1 Bart Simpsen 2 Garry Kasparov 3
Le nom de famille de Bart (joueur 2) est mal orthographié. Pour mettre à jour la table Players afin de refléter l'orthographe correcte, vous pouvez utiliser la commande UPDATE:
UPDATE Players SET lname = "Simpson" WHERE playerid = 2;
Vous pouvez supprimer des lignes d'une table à l'aide de la fonction DELETE. Par exemple, pour supprimer l'enregistrement que nous venons de mettre à jour:
DELETE FROM joueurs WHERE playerid = 2;
Vous pouvez supprimer toutes les lignes d'une table en ne spécifiant pas la clause WHERE:
SUPPRIMER DES Joueurs;
Maintenant que nos joueurs et nos jeux sont tous configurés, créons la table GameResults. C'est un tableau plus compliqué. La table GameResults associe les identifiants de joueurs de la table Players aux identifiants de jeux de la table Games, puis répertorie le score obtenu par le joueur pour le jeu en question. Les colonnes, qui relient les autres tables de cette manière, sont souvent appelées clés étrangères. Nous voulons des combinaisons uniques joueur / jeu. Nous avons donc créé une clé primaire composite à partir de la clé étrangère du joueur et du jeu afin d'identifier de manière unique un enregistrement GameResults. Enfin, nous imposons que les scores sont des nombres entiers compris entre 0 et 100.
CREATE TABLE GameResults (playerid INTEGER REFERENCES Joueurs (id), gameid INTEGER REFERENCES Jeux (id), score INTEGER CHECK (score<=100 AND score>= 0), PRIMARY KEY (playerid, gameid));
(Remarque: SQLite n'impose pas les contraintes de clé étrangère, mais vous pouvez quand même les configurer et les appliquer en créant des déclencheurs.)
Il est maintenant temps d'insérer des données dans la table GameResults. Disons que Bobby Fisher (identifiant du joueur 1) a reçu un score de 82 points en demi-finale (identifiant du jeu 1). Vous pouvez utiliser la commande SQL suivante pour insérer l'enregistrement approprié dans la table GameResults:
INSCRIRE dans GameResults (playerid, gameid, score) VALUES (1,1,82);
Supposons maintenant que le tournoi est joué et que les scores sont ajoutés à la table GameResults. Bobby est un bon joueur, Bart est un joueur terrible et Garry joue toujours un jeu parfait. Une fois que les enregistrements ont été ajoutés à la table GameResults, nous pouvons exécuter une commande SELECT * pour répertorier tous les enregistrements de la table ou spécifier explicitement les colonnes de la manière suivante:
SELECT playerid, gameid, score FROM GameResults;
Voici les résultats de cette requête:
playerid gameid score ---------- ---------- ----- 1 1 82 1 2 88 1 3 78 1 4 90 1 5 85 1 6 94 2 1 10 2 2 60 2 3 50 2 4 55 2 5 45 2 6 65 3 6 100 3 5 100 3 4 100 3 3 100 3 2 100 3 1 100
Comme vous pouvez le constater, cette liste n’est pas particulièrement lisible.
Ne serait-il pas plus utile que les noms des joueurs et des jeux soient affichés à la place de leurs identifiants numériques? L'interrogation et la combinaison de données dans des instructions SELECT sont souvent gérées en effectuant une jointure avec plusieurs sources de table. il existe différents types de JOINS. Lorsque vous travaillez avec plusieurs tables, vous devez spécifier la table à laquelle une colonne appartient (en particulier lorsque les colonnes portent le même nom, comme avec toutes ces différentes colonnes id). Vous pouvez faire référence aux colonnes par leur nom ou par leur nom de table, puis un point (.), Puis le nom de la colonne..
Relistons à nouveau les scores des joueurs, mais cette fois-ci, inclurons le nom du jeu et le nom du joueur. De plus, nous limitons nos résultats au score de la finale (numéro de jeu 6):
SELECT Players.fname || "|| Players.lname AS PlayerName, Jeux.gamename, GameResults.score FROM GameResults REJOIGNEZ les joueurs ON (GameResults.playerid = Players.id) REJOIGNEZ les jeux ON (GameResults.gameid = Games.id) WHERE gameid = 6;
ce qui nous donne les résultats suivants (vous pouvez quitter le O obtenir tous les jeux):
Nom du joueur nom du joueur ------------------ -------------- ----- Final de Bobby Fisher 94 Final de Bart Simpson 65 Garry Kasparov 100 final
Le ciel est la limite en ce qui concerne les requêtes que vous pouvez effectuer ici. Pour notre exemple, la requête la plus importante est celle qui nous dit qui a remporté le tournoi..
Voici la dernière requête pour calculer le classement du tournoi:
SELECT Players.fname || "|| Players.lname AS PlayerName, SUM ((Games.weight * GameResults.score)) AS TotalWeightedScore DE GameResults REJOIGNEZ les joueurs ON (GameResults.playerid = Players.id) REJOIGNEZ les jeux ON (GameResults.gameid = Games.id) GROUP BY GameResults.playerid ORDER BY TotalWeightedScore DESC;
Cette requête rassemble des informations provenant de plusieurs tables différentes à l'aide de JOIN et calcule les résultats du tournoi de manière lisible. Alors regardons ce que fait cette requête:
Les résultats de cette requête sont affichés ci-dessous:
PlayerName TotalWeightedScore ------------------------- ----------------- Garry Kasparov 100.0 Bobby Fisher 87.5 Bart Simpson 46.25
Ceci conclut notre exploration d’un exemple de base de données SQLite simple: une base de données de tournois d’échecs. J'espère que vous vous êtes familiarisé de nouveau avec les concepts de base de données relationnelle tels que les tables, les enregistrements et les requêtes et que vous vous êtes familiarisé avec la plupart des commandes SQLite les plus utilisées. Enfin, vous avez décrit et utilisé une base de données exemple. Maintenant que vous avez une idée du fonctionnement des bases de données SQLite, vous êtes prêt à les utiliser dans vos applications Android (le sujet de notre prochain tutoriel de cette série)..
Les développeurs mobiles Lauren Darcey et Shane Conder ont co-écrit plusieurs livres sur le développement Android: un livre de programmation en profondeur intitulé Développement d'applications sans fil Android et Sams TeachYourself Développement d'applications Android en 24 heures. Lorsqu'ils n'écrivent pas, ils passent leur temps à développer des logiciels mobiles dans leur entreprise et à fournir des services de conseil. Vous pouvez les contacter par courrier électronique à l'adresse [email protected], via leur blog à l'adresse androidbook.blogspot.com et sur Twitter @androidwireless..
