Quelles sont les meilleures pratiques pour SQLite sous Android?

Des insertions, des mises à jour, suppressions et les lectures sont généralement OK à partir de plusieurs threads, mais Brad réponse n'est pas correct. Vous devez être prudent avec la façon dont vous créez vos connexions et de les utiliser. Il y a des situations où votre mise à jour échoue, même si votre base de données n'est pas corrompue.

La réponse basique.

La SqliteOpenHelper objet tient à une connexion de base de données. Il apparaît pour vous offrir une lecture et d'écriture de connexion, mais il n'a vraiment pas. L'appel de la lecture seule, et vous aurez l'écriture, à la connexion de base de données indépendamment.

Donc, un accompagnateur exemple, une connexion db. Même si vous l'utilisez à partir de plusieurs threads, une seule connexion à la fois. Le SqliteDatabase objet utilise java serrures pour garder l'accès sérialisé. Ainsi, si 100 threads ont un db d'instance, les appels à la réelle sur le disque de la base de données sont sérialisées.

Donc, d'une aide, d'une connexion db, ce qui est sérialisé dans du code java. Un thread, 1000 threads, si vous utilisez un accompagnateur instance partagé entre eux, l'ensemble de votre base de données code d'accès est de série. Et la vie est belle (ish).

Si vous essayez d'écrire dans la base de données à partir de données réelles distinctes connexions en même temps, on va à l'échec. Il ne va pas attendre jusqu'à la première qui est fait et puis écrire. Il sera tout simplement pas écrire votre changement. Pire, si vous n'appelez pas la bonne version de l'insertion/mise à jour sur le SQLiteDatabase, vous n'obtiendrez pas une exception. Il vous suffit de faire un message dans le LogCat, et qui le sera.

Ainsi, plusieurs threads? Utiliser un helper. Période. Si vous ne CONNAISSEZ qu'un seul thread sera écrit, vous POUVEZ être en mesure d'utiliser plusieurs connexions, et votre lit sera plus rapide, mais l'acheteur méfiez-vous. Je n'ai pas testé plus que ça.

Voici un blog avec beaucoup plus de détails et un exemple d'application.

• Android Sqlite Verrouillage (Lien mis à jour 6/18/2012)
• Android-Base de données-Verrouillage-Collisions-Exemple touchlab sur GitHub

Gris et je sont réellement enveloppant d'un outil ORM, en fonction de son Ormlite, qui fonctionne nativement avec Android la base de données de mise en œuvre, suit le coffre de la création/l'appel de la structure que je décris dans le post de blog. Qui devrait sortir très bientôt. Prendre un coup d'oeil.

Dans l'intervalle, il s'agit d'un suivi post de blog:

• Unique connexion SQLite

Également la caisse de la fourche par 2point0 de le mentionné précédemment verrouillage exemple:

• Android-Base de données-Verrouillage-Collisions-Exemple 2point0 sur GitHub

• Utiliser un Thread ou AsyncTask pour des opérations de longue durée (50ms+). Test de votre application pour voir où c'est. La plupart des opérations (probablement) ne nécessitent pas d'un fil, car la plupart des opérations (probablement) ne concernent que quelques lignes. Utiliser un thread pour les opérations en bloc.
• Partager un SQLiteDatabase instance pour chaque DB sur le disque entre les threads et de mettre en œuvre un système de comptage de garder une trace des connexions ouvertes.

Sont là des pratiques exemplaires pour ces scénarios?

Action d'un champ statique entre toutes vos classes. J'ai utilisé pour garder un singleton autour de cela et d'autres choses qui doivent être partagées. Une méthode de comptage (généralement à l'aide de AtomicInteger) devrait également être utilisées pour vous assurer de ne jamais fermer la base de données du début ou de la laisser ouverte.

Ma solution:

Pour la version la plus récente, voir https://github.com/JakarCo/databasemanager mais je vais essayer de garder le code à jour ici. Si vous voulez comprendre ma solution, regarder le code et lire mes notes. Mes notes sont généralement assez utile.

1. copier/coller le code dans un nouveau fichier nommé DatabaseManager. (ou le télécharger à partir de github)
2. étendre DatabaseManager et de mettre en œuvre onCreate et onUpgrade comme vous le feriez normalement. Vous pouvez créer plusieurs sous-classes de la un DatabaseManager classe afin d'avoir différentes bases de données sur le disque.
3. Instancier votre sous-classe et appel getDb() d'utiliser le SQLiteDatabase classe.
4. Appel close() pour chaque sous-classe, vous instancié

Le code de copier/coller:

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import java.util.concurrent.ConcurrentHashMap;
/** Extend this class and use it as an SQLiteOpenHelper class
*
* DO NOT distribute, sell, or present this code as your own. 
* for any distributing/selling, or whatever, see the info at the link below
*
* Distribution, attribution, legal stuff,
* See https://github.com/JakarCo/databasemanager
* 
* If you ever need help with this code, contact me at [email protected] (or [email protected] )
* 
* Do not sell this. but use it as much as you want. There are no implied or express warranties with this code. 
*
* This is a simple database manager class which makes threading/synchronization super easy.
*
* Extend this class and use it like an SQLiteOpenHelper, but use it as follows:
*  Instantiate this class once in each thread that uses the database. 
*  Make sure to call {@link #close()} on every opened instance of this class
*  If it is closed, then call {@link #open()} before using again.
* 
* Call {@link #getDb()} to get an instance of the underlying SQLiteDatabse class (which is synchronized)
*
* I also implement this system (well, it's very similar) in my <a href="http://androidslitelibrary.com">Android SQLite Libray</a> at http://androidslitelibrary.com
* 
*
*/
abstract public class DatabaseManager {
/**See SQLiteOpenHelper documentation
*/
abstract public void onCreate(SQLiteDatabase db);
/**See SQLiteOpenHelper documentation
*/
abstract public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion);
/**Optional.
* *
*/
public void onOpen(SQLiteDatabase db){}
/**Optional.
* 
*/
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {}
/**Optional
* 
*/
public void onConfigure(SQLiteDatabase db){}
/** The SQLiteOpenHelper class is not actually used by your application.
*
*/
static private class DBSQLiteOpenHelper extends SQLiteOpenHelper {
DatabaseManager databaseManager;
private AtomicInteger counter = new AtomicInteger(0);
public DBSQLiteOpenHelper(Context context, String name, int version, DatabaseManager databaseManager) {
super(context, name, null, version);
this.databaseManager = databaseManager;
}
public void addConnection(){
counter.incrementAndGet();
}
public void removeConnection(){
counter.decrementAndGet();
}
public int getCounter() {
return counter.get();
}
@Override
public void onCreate(SQLiteDatabase db) {
databaseManager.onCreate(db);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
databaseManager.onUpgrade(db, oldVersion, newVersion);
}
@Override
public void onOpen(SQLiteDatabase db) {
databaseManager.onOpen(db);
}
@Override
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
databaseManager.onDowngrade(db, oldVersion, newVersion);
}
@Override
public void onConfigure(SQLiteDatabase db) {
databaseManager.onConfigure(db);
}
}
private static final ConcurrentHashMap<String,DBSQLiteOpenHelper> dbMap = new ConcurrentHashMap<String, DBSQLiteOpenHelper>();
private static final Object lockObject = new Object();
private DBSQLiteOpenHelper sqLiteOpenHelper;
private SQLiteDatabase db;
private Context context;
/** Instantiate a new DB Helper. 
* <br> SQLiteOpenHelpers are statically cached so they (and their internally cached SQLiteDatabases) will be reused for concurrency
*
* @param context Any {@link android.content.Context} belonging to your package.
* @param name The database name. This may be anything you like. Adding a file extension is not required and any file extension you would like to use is fine.
* @param version the database version.
*/
public DatabaseManager(Context context, String name, int version) {
String dbPath = context.getApplicationContext().getDatabasePath(name).getAbsolutePath();
synchronized (lockObject) {
sqLiteOpenHelper = dbMap.get(dbPath);
if (sqLiteOpenHelper==null) {
sqLiteOpenHelper = new DBSQLiteOpenHelper(context, name, version, this);
dbMap.put(dbPath,sqLiteOpenHelper);
}
//SQLiteOpenHelper class caches the SQLiteDatabase, so this will be the same SQLiteDatabase object every time
db = sqLiteOpenHelper.getWritableDatabase();
}
this.context = context.getApplicationContext();
}
/**Get the writable SQLiteDatabase
*/
public SQLiteDatabase getDb(){
return db;
}
/** Check if the underlying SQLiteDatabase is open
*
* @return whether the DB is open or not
*/
public boolean isOpen(){
return (db!=null&&db.isOpen());
}
/** Lowers the DB counter by 1 for any {@link DatabaseManager}s referencing the same DB on disk
*  <br />If the new counter is 0, then the database will be closed.
*  <br /><br />This needs to be called before application exit.
* <br />If the counter is 0, then the underlying SQLiteDatabase is <b>null</b> until another DatabaseManager is instantiated or you call {@link #open()}
*
* @return true if the underlying {@link android.database.sqlite.SQLiteDatabase} is closed (counter is 0), and false otherwise (counter > 0)
*/
public boolean close(){
sqLiteOpenHelper.removeConnection();
if (sqLiteOpenHelper.getCounter()==0){
synchronized (lockObject){
if (db.inTransaction())db.endTransaction();
if (db.isOpen())db.close();
db = null;
}
return true;
}
return false;
}
/** Increments the internal db counter by one and opens the db if needed
*
*/
public void open(){
sqLiteOpenHelper.addConnection();
if (db==null||!db.isOpen()){
synchronized (lockObject){
db = sqLiteOpenHelper.getWritableDatabase();
}
} 
}
}

Dmytro réponse fonctionne très bien pour mon cas.
Je pense que c'est mieux de déclarer à la fonction de synchronisation. au moins pour mon cas, cela permettrait d'invoquer l'exception de pointeur null autrement, par exemple, getWritableDatabase pas encore de retour dans un thread et openDatabse appelé dans un autre thread-temps.

public synchronized SQLiteDatabase openDatabase() {
if(mOpenCounter.incrementAndGet() == 1) {
// Opening new database
mDatabase = mDatabaseHelper.getWritableDatabase();
}
return mDatabase;
}

Ma compréhension de SQLiteDatabase Api, c'est que dans le cas où vous avez un multi threaded application, vous ne pouvez pas se permettre d'avoir plus d'un 1 SQLiteDatabase objet pointant vers une base de données unique.

L'objet peut certainement être créés mais les insertions/mises à jour échouent si différents threads/processus (trop) de commencer à utiliser différents SQLiteDatabase objets (comme la façon dont nous utilisons dans la Connexion JDBC).

La seule solution ici est de coller avec 1 SQLiteDatabase objets et chaque fois qu'un startTransaction() est utilisé dans plus de 1 thread, Android gère le verrouillage à travers les différents threads et permet 1 seul thread à la fois exclusifs de mise à jour des accès.

Vous pouvez aussi le faire "Lit" de la base de données et utiliser le même SQLiteDatabase objet dans un autre thread (tandis qu'un autre thread écrit) et il n'y aurait jamais de corruption de base de données, j'.e "lire fil" ne serait-ce pas lire les données de la base de données jusqu'à l'écriture "thread" engage les données, même si les deux utilisent le même SQLiteDatabase objet.

C'est différent de la façon dont la connexion de l'objet est dans JDBC où si vous passez autour de la (ou de la même) l'objet de connexion entre lire et écrire des sujets puis nous serait probablement l'impression des données non validées trop.

Dans mon enterprise application, je tente d'utiliser le conditionnel vérifie donc que le Thread d'INTERFACE utilisateur de ne jamais avoir à attendre, alors que le BG thread détient le SQLiteDatabase objet (exclusivement). J'ai essayer de prédire les Actions d'INTERFACE utilisateur et de reporter BG thread en cours d'exécution pour 'x' secondes. Aussi on peut maintenir PriorityQueue pour gérer remise SQLiteDatabase objets de Connexion de sorte que le Thread d'INTERFACE utilisateur obtient d'abord.

Avoir eu quelques problèmes, je crois que j'ai compris pourquoi j'ai été mal à l'.

J'avais écrit une base de données de la classe wrapper qui comprenait une close() qui a appelé à l'aide d'un miroir de open() qui appelle getWriteableDatabase puis ont migré vers un ContentProvider. Le modèle de ContentProvider ne pas utiliser SQLiteDatabase.close() je pense que c'est un gros indice que le code n'utilisez getWriteableDatabase, Dans certains cas, je faisais toujours un accès direct à l'écran de validation des requêtes dans le principal donc j'ai migré vers un getWriteableDatabase/rawQuery modèle.

- Je utiliser un singleton, et il est légèrement inquiétant commentaire dans la proximité de la documentation

Près tout ouverte objet de base de données

(mon gras).

Donc j'ai eu des plantages intermittents où je utiliser les threads d'arrière-plan pour accéder à la base de données et ils s'exécuter en même temps que le premier plan.

Donc je pense que close() forces de la base de données pour fermer indépendamment de tous les autres threads holding références - donc close() lui-même n'est pas simplement l'annulation de la correspondance getWriteableDatabase, mais la force de fermeture tout des demandes ouvertes. La plupart du temps ce n'est pas un problème car le code est le thread unique, mais en multi-thread cas, il y a toujours la possibilité de l'ouverture et de la fermeture de la synchronisation.

Avoir lu les commentaires d'ailleurs qui explique que la SqLiteDatabaseHelper code de l'instance de compte, le temps que vous voulez un proche est l'endroit où vous voulez que la situation où vous voulez faire une copie de sauvegarde, et vous voulez que toutes les connexions être fermé et la force de SqLite à écrire loin de toute mise en cache des trucs qui pourraient être s'attarder sur - en d'autres termes arrêter toutes les applications de base de données d'activité, à proximité, juste au cas où l'aide a perdu la trace, n'importe quel fichier du niveau d'activité (sauvegarde/restauration) puis tout recommencer.

Bien que cela semble être une bonne idée d'essayer de fermer de manière contrôlée, la réalité est que Android se réserve le droit à la corbeille de votre VM, donc toute clôture est de réduire le risque de mise en cache des mises à jour qui n'est pas écrit, mais il ne peut pas être garantie si l'appareil est souligné, et si vous avez libérée correctement vos curseurs et des références à des bases de données (qui ne doit pas être statique membres) puis à l'aide d'fermeture de la base de données de toute façon.

Donc, de mon point de vue est que l'approche est la suivante:

Utilisation getWriteableDatabase pour ouvrir à partir d'un singleton wrapper. (J'ai utilisé une application dérivée de la classe afin de fournir le contexte de l'application à partir d'un statique pour résoudre le besoin d'un contexte).

Jamais directement appel à proximité.

Ne rangez jamais la résultante de la base de données dans un objet qui n'est pas évident de la portée et de s'appuyer sur le comptage de référence pour déclencher un implicite close().

Si au niveau du fichier de manutention, d'apporter toutes les activités de base de données à l'arrêt et ensuite appeler à proximité, juste au cas où il y a un emballement fil sur l'hypothèse que vous écrivez bon transactions afin de partir à la dérive thread échouera et la fermeture de la base de données va au moins avoir une bonne transactions plutôt que potentiellement un fichier de copie de niveau d'une transaction partielle.