SQLite sous Android

**devhafid** · 31/07/2014, 18h12

Bonjour,

J'ai cette classe DataBaseHelper qui va me permettre de me connecter à la base donnée SQLite sous Android. J'ai une classe utilisateurDAO pour insérer et récupérer dans la table utilisateur et une autre classe utilisateur contient juste les attributs de chaque utilisateur.

J'aimerais savoir :

A quel moment est détruite ma base données ? Dès que je ferme mon application ? C'est-à-dire la durée d’existence des données dans la base ?
Est-ce qu'avec la base de données SQLite je peux laisser la colonne ID (identifiant de la table) sans l’insérer? C'est-à-dire est-ce que l'autoincrement fonctionne avec SQLite ?
Où dois-je mettre le code pour créer la base données (méthode createDataBase())? Au moment de ma première activité d'authentification ?

Voici mon code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
package com.appmobile.model.DAO;
 
import java.io.*;
 
import android.content.*;
import android.database.SQLException;
import android.database.sqlite.*;
 
public class DataBaseHelper extends SQLiteOpenHelper {
 
    // The Android's default system path of your application database.
    private static String DB_PATH = "/data/data/com.greenappmobile.controller/databases/";
 
    private static String DB_NAME = "appdatabase";
 
    private SQLiteDatabase myDataBase;
    private static final String TABLE = "utilisateur";
    private static final String COL_ID = "id_utilisateur";
    private static final int NUM_COL_ID = 0;
    private static final String COL_NOM = "nom";
    private static final int NUM_COL_NOM = 1;
    private static final String COL_PRENOM = "prenom";
    private static final int NUM_COL_PRENOM = 2;
    private static final String COL_EMAIL = "email";
    private static final int NUM_COL_EMAIL = 3;
    private final Context myContext;
    private static final String CREATE_USER = "CREATE TABLE " + TABLE + " ("
            + COL_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COL_NOM +
            " TEXT NOT NULL, "+COL_PRENOM + " TEXT NOT NULL, "+ 
            COL_EMAIL + " TEXT NOT NULL);";
 
    /**
     * Constructor Takes and keeps a reference of the passed context in order to
     * access to the application assets and resources.
     * 
     * @param context
     */
    public DataBaseHelper(Context context) {
 
        super(context, DB_NAME, null, 1);
        this.myContext = context;
    }
 
    /**
     * Creates a empty database on the system and rewrites it with your own
     * database.
     * */
    public void createDataBase() throws IOException {
 
        boolean dbExist = checkDataBase();
 
        if (dbExist) {
            // do nothing - database already exist
        } else {
 
            // By calling this method and empty database will be created into
            // the default system path
            // of your application so we are gonna be able to overwrite that
            // database with our database.
            this.getReadableDatabase();
 
            try {
 
                copyDataBase();
 
            } catch (IOException e) {
 
                throw new Error("Error copying database");
 
            }
        }
 
    }
 
    /**
     * Check if the database already exist to avoid re-copying the file each
     * time you open the application.
     * 
     * @return true if it exists, false if it doesn't
     */
    private boolean checkDataBase() {
 
        SQLiteDatabase checkDB = null;
 
        try {
            String myPath = DB_PATH + DB_NAME;
            checkDB = SQLiteDatabase.openDatabase(myPath, null,
                    SQLiteDatabase.OPEN_READONLY);
 
        } catch (SQLiteException e) {
 
            // database does't exist yet.
 
        }
 
        if (checkDB != null) {
 
            checkDB.close();
 
        }
 
        return checkDB != null ? true : false;
    }
 
    /**
     * Copies your database from your local assets-folder to the just created
     * empty database in the system folder, from where it can be accessed and
     * handled. This is done by transfering bytestream.
     * */
    private void copyDataBase() throws IOException {
 
        // Open your local db as the input stream
        InputStream myInput = myContext.getAssets().open(DB_NAME);
 
        // Path to the just created empty db
        String outFileName = DB_PATH + DB_NAME;
 
        // Open the empty db as the output stream
        OutputStream myOutput = new FileOutputStream(outFileName);
 
        // transfer bytes from the inputfile to the outputfile
        byte[] buffer = new byte[1024];
        int length;
        while ((length = myInput.read(buffer)) > 0) {
            myOutput.write(buffer, 0, length);
        }
 
        // Close the streams
        myOutput.flush();
        myOutput.close();
        myInput.close();
 
    }
 
    public void openDataBase() throws SQLException {
 
        // Open the database
        String myPath = DB_PATH + DB_NAME;
        myDataBase = SQLiteDatabase.openDatabase(myPath, null,
                SQLiteDatabase.OPEN_READONLY);
 
    }
 
    @Override
    public synchronized void close() {
 
        if (myDataBase != null)
            myDataBase.close();
 
        super.close();
 
    }
 
    @Override
    public void onCreate(SQLiteDatabase db) {
 
        db.execSQL(CREATE_USER);
    }
 
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package com.appmobile.model.DAO;
 
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
 
import com.appmobile.model.Utilisateur;
 
 
public class utilisateurDAO {
 
    private static final int VERSION_BDD = 1;
    private static final String NOM_BDD = "DBName";
 
    private static final String TABLE = "utilisateur";
    private static final String COL_ID = "id_utilisateur";
    private static final int NUM_COL_ID = 0;
    private static final String COL_NOM = "nom";
    private static final int NUM_COL_NOM = 1;
    private static final String COL_PRENOM = "prenom";
    private static final int NUM_COL_PRENOM = 2;
    private static final String COL_EMAIL = "email";
    private static final int NUM_COL_EMAIL = 3;
 
 
    private SQLiteDatabase bdd;
    private static final String CREATE_BDD = "CREATE TABLE " + TABLE + " ("
            + COL_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COL_NOM +
            " TEXT NOT NULL, "+COL_PRENOM + " TEXT NOT NULL, "+ 
            COL_EMAIL + " TEXT NOT NULL);";
    private DataBaseHelper maBaseSQLite;
 
    public utilisateurDAO(Context context){
        //On crée la BDD et sa table
        maBaseSQLite = new DataBaseHelper(context);
    }
 
    public void onCreate(SQLiteDatabase db) {
        //on crée la table à partir de la requête écrite dans la variable CREATE_BDD
        db.execSQL(CREATE_BDD);
    }
    public void open(){
        //on ouvre la BDD en écriture
        bdd = maBaseSQLite.getWritableDatabase();
    }
 
    public void close(){
        //on ferme l'accès à la BDD
        bdd.close();
    }
 
    public SQLiteDatabase getBDD(){
        return bdd;
    }
 
    public long insertutilisateur(Utilisateur utilisateur){
        //Création d'un ContentValues (fonctionne comme une HashMap)
        ContentValues values = new ContentValues();
        //on lui ajoute une valeur associée à une clé (qui est le nom de la colonne dans laquelle on veut mettre la valeur)
        values.put(COL_ID, utilisateur.getId());
        values.put(COL_NOM, utilisateur.getNomutil());
        values.put(COL_PRENOM, utilisateur.getPrenomutil());
        values.put(COL_EMAIL, utilisateur.getEmail());
 
        //on insère l'objet dans la BDD via le ContentValues
        return bdd.insert(TABLE, null, values);
    }
 
 
 
    public int removeutilisateurWithID(int id){
        //Suppression d'un utilisateur de la BDD grâce à l'ID
        return bdd.delete(TABLE, COL_ID + " = " +id, null);
    }
 
    public Utilisateur getUtilisateurWithEmail(String titre){
        //Récupère dans un Cursor les valeurs correspondant à un utilisateur contenu dans la BDD (ici on sélectionne le utilisateur grâce à son titre)
        Cursor c = bdd.query(TABLE, new String[] {COL_ID, COL_NOM, COL_PRENOM, COL_EMAIL},
                COL_EMAIL + " LIKE \"" + titre +"\"", null, null, null, null);
        return cursorToutilisateur(c);
    }
 
 
    //Cette méthode permet de convertir un cursor en un utilisateur
    private Utilisateur cursorToutilisateur(Cursor c){
        //si aucun élément n'a été retourné dans la requête, on renvoie null
        if (c.getCount() == 0)
            return null;
 
        //Sinon on se place sur le premier élément
        c.moveToFirst();
        //On créé un utilisateur
        Utilisateur utilisateur = new Utilisateur();
        //on lui affecte toutes les infos grâce aux infos contenues dans le Cursor
 
        utilisateur.setId(c.getInt(NUM_COL_ID));
 
        //On ferme le cursor
        c.close();
 
        //On retourne le utilisateur
        return utilisateur;
    }
}

Quelqu'un saurait-il m'indiquer s'il y a des erreurs dans mon code ?

Merci d'avance pour votre aide.

**hotcryx** · 31/07/2014, 20h16

La db n'est pas détruite à moins que tu effaces les tables et la db.
Elle sera effacée quand l'application correspondante sera effacée.

Il n'y a pas d'auto-incrément (de mémoire).
Tu dois utiliser une méthode qui va rechercher la valeur max et l'incrémenter.
C'est la table où se trouve tout le schéma de la db.

Tu dois faire la création de la db dans ta classe DataBaseHelper.
Tu vérifies la version actuelle de la db et en conséquence tu modifies (alter table) ou crées tes tables.

Oui des champs peuvent rester vide.

Pour ton code, il faudrait tout regarder et analyser mais je vois déjà ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
if (dbExist) {
   // do nothing - database already exist
} 
else 
{ ... }

Ecris plutôt:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
if (!dbExist) {
   // do something - database exists :lol:
}

**devhafid** · 01/08/2014, 17h33

merci beaucoup pour tes réponses,
ce qui concerne autoincrement ça marche pour moi parce que si j’insère un enregistrement sans ajouter ID ça insère bien,
car je teste la méthode d'insertion sil est supérieure à 0.
juste la méthode getUtilisateurWithEmail(string) qui marche pas, cette méthode a besoin d'ouverture base donnée en lecture??
pour la creation de base donnée je dois créer plusieurs tables et je vais faire les traitements au niveau de base donnée pour chaque table a part, donc si je la crée en classe DataBaseHelper a chaque fois j’appellerai la méthode de création ???
merci d'avance,

**hotcryx** · 01/08/2014, 18h19

Je crois qu'il y a une subtilité pour l'auto-increment.
Il y aurait un auto-increment global à la db si je ne me trompe pas.
Cela veut dire que tes ID ne vont probablement pas se suivre si tu fais des insert dans plusieurs tables

Pour gérer ma db, je n'ai pas vraiment utilisé toutes les classes, méthodes et moyen mis en oeuvre dans les nombreux exemples de création de db, j'ai trouvé cela d'un compliqué lol

alors j'ai développé mes propres méthodes et ça fonctionne très bien.

Je me base sur le nr de version de la db et la fait évoluer en conséquence.

Ex: je suis en version nr 2: j'ai 2 tables.
Lors de la version 3: j'ai créé une nouvelle table et ajouté un champs dans une des tables => dans mon switch de version, j'ajoute par query la nouvelle table et ajoute le champs et éventuellement y fait un insert d'une valeur par défaut.

Tout mon code modifiant mon schéma se trouve dans DatabaseHelper.

**devhafid** · 01/08/2014, 19h20

moi je parle autoincrement de ID de chaque table c a d a chaque insertion d'une enregistrement dans une table ID ça incrémente.
Pour db je vais utiliser juste le seul classe DatabaseHelper qui va connecter a la base donnée (ouverture de bd avec creation bd, lecture , ecriture et fermeture ) ms je vais utiliser plusieurs classe utilisateurDAO,commandeDAO,visiteDAO qui va traiter chaque table de base donnée.
toi pourquoi tu as besoin de créer les tables en dépendance avec version de bd ?? pourquoi ne pas créer tes 3 tables dans une seul version 1ERE???

**hotcryx** · 01/08/2014, 21h48

Je parlais de l'auto-incrémente pour chaque table mais je crois que ce n'est pas gérer comme d'autres SGBD.

Avant j'avais une seule version

par conséquent je ne gérais pas les mises à jour (de version).
Effectivement c'est plus facile mais fort embêtant pour les utilisateurs

**devhafid** · 02/08/2014, 11h47

mais j'ai testé les ajout des enregistrements ça se passe bien, en laissant le champs ID vide?
comment il est fort embêtant pour les utilisateurs?
donc j'ai besoin moi aussi de faire plusieurs version?

**hotcryx** · 02/08/2014, 14h04

Si tu veux gérer des mises à jour, oui tu seras obligé sinon les utilisateurs devront à chaque fois l'installer mais ils perdront toutes leurs données (préférences, records...).

Tandis qu'une mise à jour (c'est également une installation mais moins complète) en tiendra compte (en fait c'est toi qui en tiendra compte)

C'est la différence entre un "fresh install" et un "update".

**devhafid** · 04/08/2014, 10h51

c'est a dire si je veux garder les données dans la base donnée j'aurai besoin de faire de mise a jour (update)!

**hotcryx** · 04/08/2014, 15h51

Tant que le schéma ne change pas, t'as pas à t'en soucier

**devhafid** · 04/08/2014, 16h16

Non j'aurai besoin de synchroniser ma base donnée sqlite après avec serveur mysql, c pour cela la base donnée ça va être toujours mis a jour sil y a une connexion!?

**hotcryx** · 04/08/2014, 17h29

Mais si ton schema de ta db server change, tu serais obligé de changer la db côté client.

Si tu effaces tout et recrée + download les data c'est OK mais risque d'être couteux en temps.

**devhafid** · 04/08/2014, 17h41

ah oui j'ai besoin de changer la base donnée locale a chaque fois qu il ya synchronisation.
je n'ai pas besoin de recréer a chaque fois la db risque d'être coûteux en temps comme vous lavez dit?
juste une note de formation concernant autoincrement.
Jai trouvé ce lien il annonce nouveauté de sqlite version 3,
http://www.finalclap.com/faq/180-sqlite-definition
l'un des nouveauté c'est qu'il apporte Auto increment (très utile pour les clé primaires à base d'entiers générés automatiquement).

**nicroman** · 04/08/2014, 18h37

Auto-increment ne sert par à grand chose.... juste à être sur d'avoir un identifiant unique pour chaque "row" (utile pour les foreign-keys).
Oracle n'a pas de auto-increment mais permet l'utilisation de "sequences"
SQLite n'a pas non plus de auto-increment, mais "bind" automatiquement une colonne INTEGER PRIMARY KEY en "row-id" (qui sera donc auto-incrémenté).

**devhafid** · 04/08/2014, 18h47

merci Mr nicroman pour l'information, ça n'a pas un grand importance pour moi, juste ce qui m’intéresse c'est synchronisation entre db sqlite et db mysql ?