web-dev-qa-db-fra.com

Comment puis-je intégrer une base de données SQLite dans une application?

Je pense que j'ai un problème de compréhension de base, alors peut-être que quelqu'un peut aider :-)

Je développe une Android utilisant Eclipse et cette application utilisera une base de données (seule la lecture de la base de données sera implémentée). La base de données contient environ 4 000 entrées, c'est-à-dire la création et le remplissage de la base de données via le code source n'est pas une option. J'ai donc créé la base de données à l'avance avec tous ses enregistrements.

Mais comment puis-je "incorporer" ce fichier de base de données dans mon application, puis y accéder? La base de données aura une taille de fichier d'environ 500 Ko. Le téléchargement à partir d'un serveur distant n'est pas non plus une option car cela n'est pas autorisé.

Merci, Robert

androidsqliteimport
31
Robert Strauch

J'ai résolu ce problème en:

  1. ajouter file.db dans le dossier project/assets;

  2. écrire la classe suivante:

    public class LinnaeusDatabase extends SQLiteOpenHelper{

    private static String DATABASE_NAME = "Dragonfly.db";
    public final static String DATABASE_PATH = "/data/data/com.kan.linnaeus/databases/";
    private static final int DATABASE_VERSION = 1;

    private SQLiteDatabase dataBase;
    private final Context dbContext;

    public LinnaeusDatabase(Context context) {
        super(context, DBActivity.DatabaseName, null, DATABASE_VERSION);
        this.dbContext = context;
        DATABASE_NAME = DBActivity.DatabaseName;
        // checking database and open it if exists
        if (checkDataBase()) {
            openDataBase();
        } else
        {
            try {
                this.getReadableDatabase();
                copyDataBase();
                this.close();
                openDataBase();

            } catch (IOException e) {
                throw new Error("Error copying database");
            }
            Toast.makeText(context, "Initial database is created", Toast.LENGTH_LONG).show();
        }
    }

    private void copyDataBase() throws IOException{
        InputStream myInput = dbContext.getAssets().open(DATABASE_NAME);
        String outFileName = DATABASE_PATH + DATABASE_NAME;
        OutputStream myOutput = new FileOutputStream(outFileName);

        byte[] buffer = new byte[1024];
        int length;
        while ((length = myInput.read(buffer))>0){
            myOutput.write(buffer, 0, length);
        }

        myOutput.flush();
        myOutput.close();
        myInput.close();
    }

    public void openDataBase() throws SQLException {
        String dbPath = DATABASE_PATH + DATABASE_NAME;
        dataBase = SQLiteDatabase.openDatabase(dbPath, null, SQLiteDatabase.OPEN_READWRITE);
    }

    private boolean checkDataBase() {
        SQLiteDatabase checkDB = null;
        boolean exist = false;
        try {
            String dbPath = DATABASE_PATH + DATABASE_NAME;
            checkDB = SQLiteDatabase.openDatabase(dbPath, null,
            SQLiteDatabase.OPEN_READONLY);
        } catch (SQLiteException e) {
            Log.v("db log", "database does't exist");
        }

        if (checkDB != null) {
            exist = true;
            checkDB.close();
        }
        return exist;
    }
}
27
Anton Derevyanko

Bel article sur le blog ReignDesign intitulé tilisation de votre propre base de données SQLite dans Android . Fondamentalement, vous pré-créez votre base de données, la placez dans votre répertoire d'actifs dans votre apk, et le premier utilisez la copie dans le répertoire "/ data/data/YOUR_PACKAGE/databases /".

14
evilone

Je l'ai fait dans le passé en stockant un fichier JSON dans l'application dans le res/raw ressources, puis chargement du fichier lors du premier chargement. De là, vous pouvez utiliser le mode d'insertion en bloc pour importer des entrées par lots. Voir mon chargeur de base de données pour les unités comme exemple de cette technique. Un avantage du res/raw le style est que vous pouvez utiliser le système de sélection de ressources Android pour localiser les données dans différentes régions, afin que vous puissiez avoir une base de données différente (ou une partie de celle-ci) pour différentes langues ou régions.

Vous pouvez également placer un vidage SQL brut dans un fichier similaire et le charger lors du premier chargement. Vous pouvez obtenir le fichier à partir des ressources en utilisant openRawResource (int) . Je recommanderais cela au lieu de stocker un fichier de base de données sqlite prédéfini pour augmenter la compatibilité entre les versions de sqlite, ainsi que pour faciliter la maintenance de la base de données (à partir d'un PDV de cycle de vie de développement d'application).

Lorsque vous chargez des objets en vrac, assurez-vous d'utiliser des transactions, car cela aidera à accélérer les choses et à rendre le chargement plus fiable.

10
Steve Pomeroy

Dans un commentaire à cette réponse , CommonsWare déconseille la même méthode proposée par @evilone ici (c.-à-d., Copier la base de données des actifs vous-même). Au lieu de cela, vous devez utiliser la méthode éprouvée SQLiteAssetHelper . Je l'ai utilisé dans Android Studio et cela fonctionne bien.

Les directions sont assez clairs. Voici quelques extraits clés:

Si vous utilisez le système de construction Gradle, ajoutez simplement la dépendance suivante dans votre fichier build.gradle:

dependencies {
    compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+'
}

Étendez SQLiteAssetHelper comme vous le feriez normalement SQLiteOpenHelper, en fournissant au constructeur un nom de base de données et un numéro de version:

public class MyDatabase extends SQLiteAssetHelper {

    private static final String DATABASE_NAME = "northwind.db";
    private static final int DATABASE_VERSION = 1;

    public MyDatabase(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
}

Mettez votre base de données dans assets/databases/northwind.db (En utilisant le nom de base de données que vous avez).

La base de données est disponible pour utilisation la première fois que getReadableDatabase() ou getWritableDatabase() est appelée.

5
Suragch