Java 在sqlite中未调用onUpgrade

我正在更新我的应用程序。在这次更新中，我必须在Sqlite数据库的表中添加一个字段

以下是用于管理my DB的单个实例的文件：

DatabaseManager.java

public class DatabaseManager {
private AtomicInteger mOpenCounter = new AtomicInteger();

private static DatabaseManager instance;
private static SQLiteOpenHelper mDatabaseHelper;
private SQLiteDatabase mDatabase;

public static synchronized void initializeInstance(SQLiteOpenHelper helper) {
    if (instance == null) {
        instance = new DatabaseManager();
        mDatabaseHelper = helper;
    }
}

public static synchronized DatabaseManager getInstance() {
    if (instance == null) {
        throw new IllegalStateException(
                DatabaseManager.class.getSimpleName()
                        + " is not initialized, call initializeInstance(..) method first.");
    }

    return instance;
}

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

public synchronized void closeDatabase() {
    if (mOpenCounter.decrementAndGet() == 0) {
        // Closing database
        mDatabase.close();

    }
}

然后，主数据库文件是：

public class PdvHandler extends SQLiteOpenHelper {
private static final String TAG = "com.spmkt.mobile";

// All Static variables
// Database Version
public static final int DATABASE_VERSION = 2;

// Database Name
public static final String DATABASE_NAME = "mydb.db";
....

public void dropAndCreateMetrics() {
    SQLiteDatabase db = DatabaseManager.getInstance().openDatabase();
    db.execSQL("DROP TABLE IF EXISTS " + MetricsHandler.TABLE_METRICS);
    db.execSQL(MetricsHandler.CREATE_TABLE_METRICS);
    DatabaseManager.getInstance().closeDatabase();
}

}

然后，我想在alerta表中添加一列：

AlertaHandler.java

public class AlertaHandler extends SQLiteOpenHelper {

public AlertaHandler(Context context, String name, CursorFactory factory,
        int version) {
    super(context, name, factory, version);
    DatabaseManager.initializeInstance(this);

}

public AlertaHandler(Context context) {
    super(context, PdvHandler.DATABASE_NAME, null,
            PdvHandler.DATABASE_VERSION);
    DatabaseManager.initializeInstance(this);

}

SQLiteDatabase db;

public static final String TABLE_ALERTAS = "alertas";

private static final String ALERTA_ID = "id";
private static final String ALERTA_CAPTURA_ID = "captura_id";
private static final String ALERTA_MENSAJE = "mensaje";
private static final String ALERTA_URGENT = "urgent";  // This is the column to add
private static final String ALERTA_SYNC = "sincronizado";

// private static final String ADD_URGENT_COLUMN =
// "ALTER TABLE "+TABLE_ALERTAS+" ADD COLUMN "+ +" ";

public static String CREATE_ALERTA = "CREATE TABLE " + TABLE_ALERTAS + "("
        + ALERTA_ID + " INTEGER  " + "PRIMARY KEY AUTOINCREMENT,"
        + ALERTA_CAPTURA_ID + " INTEGER," + ALERTA_URGENT
        + " INTEGER DEFAULT 0 NOT NULL, " + ALERTA_MENSAJE + " TEXT" + ", "
        + ALERTA_SYNC + " INTEGER )";

public static String DROP_ALERTA = "DROP TABLE IF EXISTS '" + TABLE_ALERTAS+"'";

public ArrayList<Mensaje> getUnSincronizedMessage() {

    ArrayList<Mensaje> lMensajes = new ArrayList<Mensaje>();
    // Select All Query
    Mensaje message;
    String messageQuery = "SELECT  * FROM " + TABLE_ALERTAS + " WHERE "
            + ALERTA_SYNC + "= 0";

    SQLiteDatabase db = DatabaseManager.getInstance().openDatabase();
    Cursor cursor = db.rawQuery(messageQuery, null);

    // looping through all rows and adding to list
    if (cursor.moveToFirst()) {
        do {
            message = new Mensaje();
            message.setId(cursor.getInt(cursor.getColumnIndex(ALERTA_ID)));
            message.setCapturaId(cursor.getInt(cursor
                    .getColumnIndex(ALERTA_CAPTURA_ID)));
            message.setMessage(cursor.getString(cursor
                    .getColumnIndex(ALERTA_MENSAJE)));
            int urgent = cursor
                    .getInt(cursor.getColumnIndex(ALERTA_URGENT));
            message.setUrgent(urgent == 0 ? false : true);
            message.setSincronizado(cursor.getInt(cursor
                    .getColumnIndex(ALERTA_SYNC)));

            lMensajes.add(message);

        } while (cursor.moveToNext());
    }
    DatabaseManager.getInstance().closeDatabase();
    return lMensajes;
}

public void addMessage(Mensaje m) {
    SQLiteDatabase db = DatabaseManager.getInstance().openDatabase();
    ContentValues values = new ContentValues();
    values.put(ALERTA_CAPTURA_ID, m.getCapturaId());
    values.put(ALERTA_MENSAJE, m.getMessage());
    values.put(ALERTA_URGENT, m.isUrgent() ? 1 : 0);
    values.put(ALERTA_SYNC, m.getSincronizado());

    // Inserting Row
    db.insert(TABLE_ALERTAS, null, values);
    DatabaseManager.getInstance().closeDatabase();
}

@Override
public void onCreate(SQLiteDatabase db) {

}

public boolean existsMensaje(Mensaje m) {
    SQLiteDatabase db = DatabaseManager.getInstance().openDatabase();
    String sql = "SELECT COUNT(*) FROM " + TABLE_ALERTAS + " WHERE "
            + ALERTA_ID + "=" + m.getId();
    Cursor mCount = db.rawQuery(sql, null);
    mCount.moveToFirst();
    int count = mCount.getInt(0);
    mCount.close();
    DatabaseManager.getInstance().closeDatabase();
    if (count == 0)
        return false;
    else
        return true;
}

public void updateMessage(Mensaje m) {
    SQLiteDatabase db = DatabaseManager.getInstance().openDatabase();
    ContentValues values = new ContentValues();
    values.put(ALERTA_ID, m.getId());
    values.put(ALERTA_MENSAJE, m.getMessage());
    values.put(ALERTA_SYNC, m.getSincronizado());
    values.put(ALERTA_URGENT, m.isUrgent());
    values.put(ALERTA_CAPTURA_ID, m.getCapturaId());

    // updating row
    db.update(TABLE_ALERTAS, values, ALERTA_ID + " = ?",
            new String[] { String.valueOf(m.getId()) });
    DatabaseManager.getInstance().closeDatabase();
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    int upgradeTo = oldVersion + 1;
    while (upgradeTo <= newVersion) {
        switch (upgradeTo) {
        case 2:
            try{
                db.execSQL(DROP_ALERTA);
                db.execSQL(CREATE_ALERTA);                  
                Log.e(TAG,DROP_ALERTA);
                Log.e(TAG,CREATE_ALERTA);
            }catch (Exception e) {
                Crashlytics.logException(e);
            }
            break;
        }
        upgradeTo++;
    }
}

公共类AlertaHandler扩展了SQLiteOpenHelper{
公共AlertaHandler（上下文上下文、字符串名称、游标工厂、，
int版本）{
超级（上下文、名称、工厂、版本）；
DatabaseManager.initializeInstance（此）；
}
公共警报处理程序（上下文）{
super（上下文，PdvHandler.DATABASE_NAME，null，
PdvHandler.DATABASE_版本）；
DatabaseManager.initializeInstance（此）；
}
sqlitedb数据库；
公共静态最终字符串表_ALERTAS=“ALERTAS”；
私有静态最终字符串ALERTA_ID=“ID”；
私有静态最终字符串ALERTA\u CAPTURA\u ID=“CAPTURA\u ID”；
私有静态最终字符串ALERTA_MENSAJE=“MENSAJE”；
private static final String ALERTA_URGENT=“URGENT”//这是要添加的列
私有静态最终字符串ALERTA_SYNC=“sincronizado”；
//私有静态最终字符串ADD\u emergency\u列=
//“ALTER TABLE”+TABLE_ALERTAS+“添加列”+”；
公共静态字符串CREATE_ALERTA=“CREATE TABLE”+TABLE_ALERTAS+”（“
+ALERTA_ID+“整数”+“主键自动递增，”
+警报捕获ID+“整数”+“警报紧急”
+整数默认值0不为空，“+ALERTA_MENSAJE+”文本“+”
+ALERTA_SYNC+“整数）”；
公共静态字符串DROP_ALERTA=“DROP TABLE IF EXISTS”“+TABLE_ALERTAS+”；
公共阵列列表getUnSincronizedMessage（）{
ArrayList lMensajes=新的ArrayList（）；
//选择所有查询
门萨耶消息；
String messageQuery=“选择*自”+表格\u ALERTAS+“其中”
+警报同步+“=0”；
SQLiteDatabase db=DatabaseManager.getInstance（）.openDatabase（）；
Cursor Cursor=db.rawQuery（messageQuery，null）；
//循环遍历所有行并添加到列表
if（cursor.moveToFirst（））{
做{
消息=新的Mensaje（）；
message.setId（cursor.getInt（cursor.getColumnIndex（ALERTA_ID））；
message.setCapturaId（cursor.getInt（cursor
.getColumnIndex（ALERTA_CAPTURA_ID））；
message.setMessage（cursor.getString（cursor
.getColumnIndex（ALERTA_MENSAJE））；
int=cursor
.getInt（cursor.getColumnIndex（ALERTA_紧急））；
message.setUrgent（urgent==0？false:true）；
message.setSincronizado（cursor.getInt（cursor
.getColumnIndex（警报同步））；
lMensajes.add（消息）；
}while（cursor.moveToNext（））；
}
DatabaseManager.getInstance（）.closeDatabase（）；
返回lMensajes；
}
公共无效添加消息（Mensaje m）{
SQLiteDatabase db=DatabaseManager.getInstance（）.openDatabase（）；
ContentValues=新的ContentValues（）；
value.put（ALERTA_CAPTURA_ID，m.getCapturaId（））；
value.put（ALERTA_MENSAJE，m.getMessage（））；
value.put（ALERTA_-URGENT，m.isUrgent（）？1:0）；
value.put（ALERTA_SYNC，m.getSincronizado（））；
//插入行
db.insert（表_ALERTAS，null，值）；
DatabaseManager.getInstance（）.closeDatabase（）；
}
@凌驾
public void onCreate（SQLiteDatabase db）{
}
公共布尔存在（Mensaje m）{
SQLiteDatabase db=DatabaseManager.getInstance（）.openDatabase（）；
String sql=“从“+表\u ALERTAS+”中选择计数（*），其中”
+ALERTA_ID+“=”+m.getId（）；
游标mCount=db.rawQuery（sql，null）；
mCount.moveToFirst（）；
int count=mCount.getInt（0）；
mCount.close（）；
DatabaseManager.getInstance（）.closeDatabase（）；
如果（计数=0）
返回false；
其他的
返回true；
}
公共无效更新消息（Mensaje m）{
SQLiteDatabase db=DatabaseManager.getInstance（）.openDatabase（）；
ContentValues=新的ContentValues（）；
value.put（ALERTA_ID，m.getId（））；
value.put（ALERTA_MENSAJE，m.getMessage（））；
value.put（ALERTA_SYNC，m.getSincronizado（））；
value.put（ALERTA_-URGENT，m.isUrgent（））；
value.put（ALERTA_CAPTURA_ID，m.getCapturaId（））；
//更新行
数据库更新（表ALERTAS、值、ALERTAID+“=？”，
新字符串[]{String.valueOf（m.getId（））}；
DatabaseManager.getInstance（）.closeDatabase（）；
}
@凌驾
public void onUpgrade（SQLiteDatabase db，int-oldVersion，int-newVersion）{
int upgradeTo=旧版本+1；
while（升级到）
我是否应该在PdvHandler中更改我的表，因为它是定义DB版本的文件？我是否应该在每个处理程序文件中更改我的表？（我有1个处理程序x表=10个处理程序）

每个数据库文件应该只有一个
SQLiteOpenHelper

onUpgrade（）当使用提供给
SQLiteOpenHelper
构造函数的参数请求的数据库架构版本大于存储在数据库文件中的架构版本时，将调用
。如果数据库文件已由一个处理同一数据库文件的sqlite helper升级到请求的版本，
onUpgrade（）
不会在其他帮助程序上调用

另外，您不应该在
onCreate（）
或
onUpgrade（）
中捕获异常。如果有问题，应该将异常抛出方法之外

另请参见：
ok。我有10个扩展SQliteOpenHelper的处理程序。因此解决方案应该是，我的所有处理程序只扩展一个扩展SQliteOpenHelper的超类？？？不。您仍然有10个不同的帮助程序。只需有一个扩展
SQliteOpenHelper
的类。您可以将特定于表的操作拆分为单独的类但是每个数据库文件只能有一个helper类。那么我应该将我的实例存储到我的SQLiteOpenHelper类的何处呢？我尝试了myApplication类（扩展应用程序的类），但是我