Comment utiliser une base de données SQLite dans une application Android

Dans une application Android il existe plusieurs manières de stocker des informations

• Dans les préférences utilisateurs 
• Sous forme de fichier soit directement sur le device soit sur la carte externe 
• Dans la base de données interne SQLite 
• En appelant des services de stockage distant 

Dans cet article nous allons voir comment interagir avec la base de données SQLite embarquée sur votre device.

Créer une nouvelle base de données
Android fournit un Helper SQLiteOpenHelper pour vous aider à interagir avec SQLite. Nous utiliserons les méthodes getReadableDatabase() ou getWritableDatabase() de cet objet pour lancer une requête de sélection (lecture) ou de mise à jour (écriture).

Vous devez écrire une classe fille de SQLiteOpenHelper dans laquelle il faut surcharger la méthode onCreate pour indiquer quelles requêtes SQL doivent être lancées pour créer la base de données. Lors des livraisons ultérieures de l’application, vous pourrez également surcharger les méthodes onUpgrade et onDowngrade pour spécifier les traitements à lancer pour faire migrer la base de données d’une version de la base de donnée à une autre.

public class ScoreSheetOpenHelper extends SQLiteOpenHelper { 

    public ScoreSheetOpenHelper(Context context) { 
        super(context, ScoreSheetService.DATABASE_NAME, null, 
        ScoreSheetService.DATABASE_VERSION); 
    } 

    @Override 
    public void onCreate(SQLiteDatabase db) { 
        Log.w(TAG, "Create database version " + ScoreSheetService.DATABASE_VERSION); 
        create_tables(db); 
    } 

    @Override 
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
        Log.w(TAG, "Upgrading database from version " + oldVersion + " to " + newVersion 
            + ", which will destroy all old data"); 
    } 
}

Pour faciliter la lecture de votre code il est recommandé d’utiliser des constantes pour définir les objets liés à vos entités dans la base de données. Exemple d’un domain objet

public class Sport implements Parcelable{ 
   public static final String TABLE_NAME = "sport"; 
   public static final String COLUMN_NAME_ID = "id"; 
   public static final String COLUMN_NAME_LABEL = "label"; 
   private Long id; 
   private String label; 
   ………. 
}

La création de la base de données ressemblera a

private void create_tables(SQLiteDatabase db){ 
    // Sport table 
    db.execSQL(new StringBuilder("CREATE TABLE ") 
        .append(Sport.TABLE_NAME).append(" (") 
        .append(Sport.COLUMN_NAME_ID).append(" INTEGER PRIMARY KEY,") 
        .append(Sport.COLUMN_NAME_LABEL).append(" TEXT") 
        .append(");").toString()); 
        
 //… Suite de la création 
}

Lancer des requêtes CRUD
Au niveau de l’exécution des requêtes Create Read Update Delete je vais prendre ma casquette architecte et je vous conseille de les isoler dans une ou plusieurs classes métiers et de ne pas suivre les exemples donnés bien souvent sur le Web où les requêtes sont directement exécutées au niveau des classes Activity.

public class ScoreSheetService { 
    public static final String TAG = "ScoreSheetDatabase"; 
    private static final String DATABASE_NAME = "score_sheet.db"; 
    public static final int DATABASE_VERSION = 1; 
    private Context context; 
    private ScoreSheetOpenHelper mOpenHelper; 
 
    public ScoreSheetService(Context context) { 
      this.mOpenHelper = new ScoreSheetOpenHelper(context); 
      this.context = context; 
    } 
}

Je vous conseille également de travailler dans des transactions en utilisant les méthodes beginTransaction, setTransactionSuccessful et endTransaction de l’objet SQLiteDatabase.

    db.beginTransaction(); 
    try { 
        ... 
        db.setTransactionSuccessful(); 
    } finally { 
        db.endTransaction(); 
    }

Sauvegarder une donnée en base de données : Create /Update
Voici un exemple de code exécutant une insertion ou une mise à jour.

public void saveSport(Sport sport){ 
    SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 
    try { 
        db.beginTransaction(); 
        ContentValues values = new ContentValues(); 
        values.put(Sport.COLUMN_NAME_ID, sport.getId()); 
        values.put(Sport.COLUMN_NAME_LABEL, sport.getLabel()); 
        
        if (sport.getId()!=null) { 
            long rowId = db.insert(ScoreSheet.TABLE_NAME, null, values); 
            sport.setId(rowId); 
        } else { 
            String whereClause = Sport.COLUMN_NAME_ID + "= ?"; 
            String[] whereArgs = new String[] { sport.getId().toString() }; 
            db.update(Sport.TABLE_NAME, values, whereClause, whereArgs); 
        } 
        db.setTransactionSuccessful(); 
    } 
    catch (Exception e) { 
        throw new SQLException("Failed to insert sport " + e.getMessage()); 
    } 
    finally { 
        db.endTransaction(); 
        db.close(); 
    } 
}

Suppression d’une donnée en base de données : Delete
Voici un exemple de code exécutant une suppression

public void deleteSport(Sport sport){ 
    SQLiteDatabase db = mOpenHelper.getWritableDatabase(); 
    try { 
        String whereClause = Sport.COLUMN_NAME_ID + "= ?"; 
        String[] whereArgs = new String[] { sport.getId().toString() }; 
        db.beginTransaction(); 
        db.delete(Sport.TABLE_NAME, whereClause, whereArgs); 
        db.setTransactionSuccessful(); 
    } 
    catch (Exception e) { 
        throw new SQLException("Failed to delete sport " + e.getMessage()); 
    } 
    finally { 
        db.endTransaction(); 
        db.close(); 
    } 
} 

Sélection d’une donnée en base de données : Read
Exemple de la sélection d’un enregistrement dans la base de données

public Sport getSport(Long idSport){ 
    SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 
    Cursor c = null; 
    try { 
        String[] colonnes = new String[] {Sport.COLUMN_NAME_ID, Sport.COLUMN_NAME_LABEL }; 
        String selection = Sport.COLUMN_NAME_ID + "= ?"; 
        String[] selectionArgs = new String[] { idSport.toString() }; 
        String groupBy = null; 
        String having = null; 
        String orderBy = Sport.COLUMN_NAME_LABEL; 

        c = db.query(Sport.TABLE_NAME, colonnes, selection, selectionArgs, 
                groupBy, having, orderBy); 

        if (c != null && c.getCount() > 0) { 
            c.moveToFirst(); 
            Sport sport = new Sport(); 
            sport.setId(c.getLong(0)); 
            sport.setLabel(c.getString(1)); 
            return sport; 
        } 
    } finally { 
        if (c != null) { 
            c.close(); 
        } 
        db.close(); 
    } 
    return null; 
}

Dans ce deuxième exemple nous récupérons un ensemble de données à l’aide de la classe utilitaire SQLiteQueryBuilder qui offre des méthodes utilitaires pour simplifier l’écriture des requêtes

public List<ScoreSheet> getScoreSheetList() { 
    SQLiteDatabase db = mOpenHelper.getReadableDatabase(); 
    SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); 
    qb.setTables(ScoreSheet.TABLE_NAME); 

    List<ScoreSheet> scoresheets = new ArrayList<ScoreSheet>(); 
    Cursor c = null; 
    try { 
        String[] colonnes = new String[] { 
            ScoreSheet.COLUMN_NAME_ID,ScoreSheet.COLUMN_NAME_DATE, 
            ScoreSheet.COLUMN_NAME_ID_SPORT, 
            ScoreSheet.COLUMN_NAME_SCORE_HOME, 
            ScoreSheet.COLUMN_NAME_SCORE_VISITOR }; 

        c = qb.query(db, colonnes, null, null, null, null, Sport.COLUMN_NAME_ID + " DESC");

        if (c != null && c.getCount() > 0) { 
            c.moveToFirst(); 
            do { 
                ScoreSheet scoreSheet = new ScoreSheet(); 
                scoreSheet.setId(c.getLong(0)); 
                scoreSheet.setDate(c.getString(1)); 
                scoreSheet.setSport(getSport(c.getLong(2))); 
                scoreSheet.setScoreHome(c.getLong(3)); 
                scoreSheet.setScoreVisitor(c.getLong(4)); 
                scoresheets.add(scoreSheet); 
            } while (c.moveToNext()); 
        } 
    } finally { 
        if (c != null) { 
            c.close(); 
        } 
        db.close(); 
    } 
    return scoresheets; 
}

   
Utiliser sqlite3 pour interroger la base de données depuis votre poste de développement
Nous allons voir comment interagir avec la base de données à l’aide de l’outil ADB (Android Debug Bridge), disponible dans le répertoire <android_sdk>/platform-tools/.. Ce dernier permet de se connecter soit à un émulateur soit directement à votre device connecté en USB.

Si ce n’est pas fait je vous conseille de

• définir une variable d’environnement ANDROID_SDK_HOME pointant vers le répertoire d’installation du sdk <android_sdk> 
• et de rajouter %ANDROID_SDK_HOME%/tools;%ANDROID_SDK_HOME%/platform-tools à la fin de la variable d’environnement path 

Pour lancer un shell distant sur l’émulateur lancez les commandes
adb -s emulator-5554 shell

Pour utiliser directement votre device vous pouvez utiliser
adb -d shell

Mais tous les devices n’ont pas forcément l’utilitare sqlite3 installé. Pour pouvoir le faire vous devez avoir rooter votre téléphone et même après cette opération, il n’est pas toujours très simple de rajouter ce programme.

Voici un ensemble de commande pour utiliser la base

sqlite3 –version	Donne la version de la base de données
sqlite3 data/data/com.ehret.scoresheet/ databases/score_sheet.db	Ouvre la base de données du projet FeuilleDeMatch (en spécifiant le nom du package et le nom de la base donné lors de sa création)
.help	Liste l’ensemble des colonnes
select * from sport;	Lancement d’une requête donne comme résultat 1|Rugby ├á XIII 2|Rugby ├á XV 3|Basket 4|Football
.exit	Permet de sortir de l’application

Sommaire des différents articles sur Android