Lorsque le SQLiteOpenHelper méthode onCreate est appelé?

J'ai essayé de créer une base de données SQLite et faire des trucs avec elle. Mais j'ai trouvé que ma onCreate méthode n'est même pas invoqué!!

Je suis l'envoi d'un message à LogCat sur le début de la onCreate méthode.

Mon hypothèse est, le (super) constructeur invoquer onCreate méthode. Est ce que le droit?

Mon Code:

import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteDatabase;
import android.content.Context;
import android.database.Cursor;
import android.content.ContentValues;
import android.util.Log;

public class DatabaseHandler extends SQLiteOpenHelper {
    // Static Constants
    /*** Database details ***/
    // Database version
    private static final int DATABASE_VERSION           = 1;

    // Database name
    private static final String DATABASE_NAME           = "database_name";

    /*** Database Tables ***/
    /** Events **/
    // Event table
    private static final String TABLE_EVENT             = "event";

    // Event table columns
    private static final String COLUMN_EVENT_EID        = "_eid";

    private static final String COLUMN_EVENT_CREATION_DATE  = "creation_date";

    private static final String COLUMN_EVENT_TITLE      = "title";
    private static final String COLUMN_EVENT_ICON       = "icon";

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

    @Override
    public void onCreate(SQLiteDatabase db) {
        Log.e("MyApp", "onCreate invoked");
        // Tables creation queries
        String CREATE_EVENT_TABLE = "create table " + TABLE_EVENT + "(" + COLUMN_EVENT_EID + " integer primary key, "
                + COLUMN_EVENT_CREATION_DATE + " text, "
                + COLUMN_EVENT_TITLE + " text, "
                + COLUMN_EVENT_ICON + " text)";

        // Creating tables
        db.execSQL(CREATE_EVENT_TABLE);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.e("MyApp", "onUpgrade invoked");
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_EVENT);
    }
}

MainActivity Code:

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        DatabaseHandler db = new DatabaseHandler(this);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

}

InformationsquelleAutor malhobayyeb | 2013-03-24

android-sqlite sqlite

29

La la documentation dit:

La base de données n'est pas réellement créé ou ouvert jusqu'à ce que l'un de getWritableDatabase() ou getReadableDatabase() est appelé.

InformationsquelleAutor CL.
2

Vous avez raison, le (super) constructeur invoquer la méthode onCreate, MAIS seulement si la base de données n'existe pas.
De http://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html#onCreate%28android.database.sqlite.SQLiteDatabase%29

Une classe d'assistance pour gérer la base de données de création et de gestion de version.

Vous créez une sous-classe de mise en œuvre onCreate(SQLiteDatabase),
onUpgrade(SQLiteDatabase, int, int) et éventuellement
onOpen(SQLiteDatabase), et cette classe prend soin de l'ouverture de la
base de données si elle existe, de la créer si elle n'est pas, et de mise à niveau de ce que
nécessaire.

InformationsquelleAutor Ricardo Rivaldo

Laissez-moi éclaircir la sur la logique de flux. Voici Paresseux-initialisation concept.

Le (super) constructeur, sur DatabaseHandler ne sera pas invoquer la méthode onCreate. L'appel de DatabaseHandler constructeur initialise: le contexte, le nom de base de données, l'usine qui crée la base de données, version de base de données, base de données et gestionnaire d'erreur.

getWritableDatabase() > getDatabaseLocked() > - SQLiteDatabase.créer()

getReadableDatabase() > getDatabaseLocked() > - SQLiteDatabase.créer()

Réponse: Après votre base de données est créé avec succès, vos modifications de configurations, la prochaine fois de nouveau getReadableDatabase() ou getWritableDatabase() appels getDatabaseLocked() et il onCreate(db) méthode à l'intérieur d' getDatabaseLocked() est exécuté.

Lorsque le SQLiteOpenHelper méthode onCreate est appelé?

Explication:

Ci-dessus SQLiteDatabase.create() méthode est responsable de la création d'SQLiteDatabase dans le disque.

Mais le processus de la paresse-initialisation (moyenne, il ne veut pas que tout soit prêt. Il crée ces objets sur l'exécution si vous en avez besoin. Pour cela, il a utilisé beaucoup de if..else consolidés).

Si vous voyez le corps de getDatabaseLocked(), c'est ci-dessous. [Vous pouvez rechercher onCreate() méthode à l'intérieur du corps de getDatabaseLocked()]

private SQLiteDatabase getDatabaseLocked(boolean writable) {
if (mDatabase != null) {
if (!mDatabase.isOpen()) {
// Darn!  The user closed the database by calling mDatabase.close().
mDatabase = null;
} else if (!writable || !mDatabase.isReadOnly()) {
// The database is already open for business.
return mDatabase;
}
}
if (mIsInitializing) {
throw new IllegalStateException("getDatabase called recursively");
}
SQLiteDatabase db = mDatabase;
try {
mIsInitializing = true;
if (db != null) {
if (writable && db.isReadOnly()) {
db.reopenReadWrite();
}
} else if (mName == null) {
db = SQLiteDatabase.create(null);
} else {
try {
if (DEBUG_STRICT_READONLY && !writable) {
final String path = mContext.getDatabasePath(mName).getPath();
db = SQLiteDatabase.openDatabase(path, mFactory,
SQLiteDatabase.OPEN_READONLY, mErrorHandler);
} else {
db = mContext.openOrCreateDatabase(mName, mEnableWriteAheadLogging ?
Context.MODE_ENABLE_WRITE_AHEAD_LOGGING : 0,
mFactory, mErrorHandler);
}
} catch (SQLiteException ex) {
if (writable) {
throw ex;
}
Log.e(TAG, "Couldn't open " + mName
+ " for writing (will try read-only):", ex);
final String path = mContext.getDatabasePath(mName).getPath();
db = SQLiteDatabase.openDatabase(path, mFactory,
SQLiteDatabase.OPEN_READONLY, mErrorHandler);
}
}
onConfigure(db);
final int version = db.getVersion();
if (version != mNewVersion) {
if (db.isReadOnly()) {
throw new SQLiteException("Can't upgrade read-only database from version " +
db.getVersion() + " to " + mNewVersion + ": " + mName);
}
db.beginTransaction();
try {
if (version == 0) {
onCreate(db);
} else {
if (version > mNewVersion) {
onDowngrade(db, version, mNewVersion);
} else {
onUpgrade(db, version, mNewVersion);
}
}
db.setVersion(mNewVersion);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
}
onOpen(db);
if (db.isReadOnly()) {
Log.w(TAG, "Opened " + mName + " in read-only mode");
}
mDatabase = db;
return db;
} finally {
mIsInitializing = false;
if (db != null && db != mDatabase) {
db.close();
}
}
}

Veuillez noter, à l'intérieur du corps de getDatabaseLocked() méthode, il y a tellement de if.. else cas. Ces if.. else cas détermine votre environnement actuel (configuration), et en fonction de votre environnement actuel, ils appellent des méthodes appropriées pour initialiser/configurer tout ce qui est nécessaire.

Également, note: Tous les rappels des méthodes dans votre DatabaseHandler (classe mis en œuvre SQLiteOpenHelper) sont appelés à l'intérieur de la getDatabaseLocked() corps.

Code Source SQLiteOpenHelper.java:
https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/database/sqlite/SQLiteOpenHelper.java

Code Source SQLiteDatabase.java:
https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/database/sqlite/SQLiteDatabase.java

Exemple à suivre: https://github.com/uddhavgautam/SQLiteBasicSample

InformationsquelleAutor Uddhav Gautam

1

Que les documents officiels dit, "getWritableDatabase () Créer et/ou ouvrir une base de données qui sera utilisé pour la lecture et l'écriture. La première fois, ceci est appelé, la base de données sera ouvert et onCreate(SQLiteDatabase), onUpgrade(SQLiteDatabase, int, int) et/ou onOpen(SQLiteDatabase) sera appelée."

Une fois ouvert avec succès, la base de données est mise en cache, de sorte que vous pouvez appeler cette méthode à chaque fois, vous devez écrire à la base de données. (Assurez-vous d'appeler close() lorsque vous n'avez plus besoin de la base de données.) Des erreurs telles que les mauvaises permissions ou un disque plein peut causer cette méthode échoue, mais les futures tentatives peut réussir que si le problème est résolu.

http://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html#getWritableDatabase()

InformationsquelleAutor Sam003

Vous devez vous connecter pour publier un commentaire.