Java SQLite onUpgrade（）失败

我正在处理一个预填充的数据库。在Mozilla中使用SQLite管理器，现在我有一个虚拟数据库，只是想测试onUpgrade方法，所以我修改了其中一列中的一个字符串，将其导出为一个新数据库，正如您在我的代码中看到的，我试着打开新更新的版本。同样重要的是，我正在代码中手动更新版本号

private static final int DB_VERSION = 3;

在onUpgrade

if (newVersion == 3) {
        Log.e("WORKED!!", "onUpgrade executed");

所以下次我会将这两个数字更新为4。不确定我做得对还是错，但我收到了日志消息，只是没有看到应用程序中更新的数据

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

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;


public class DataBaseHelper extends SQLiteOpenHelper {
    private static String DB_PATH;
    private static final String DB_NAME = "DummyTestOne.sqlite";
    private static final int DB_VERSION = 3;
    private static final String DB_NAME2 = "DummyTestFive.sqlite";
    private SQLiteDatabase mDataBase;
    private final Context mContext;

public static final String DBTABLENAME = "questiontable";
public static final String DBATABLENAME = "answertable";
public static final String COLUMN_ID = "_id";
public static final String COLUMN_NAME = "question";
public static final String COLUMN_CATEGORY = "category";
public static final String COLUMN_FID = "fid";

public static final String COLUMN_ANSWER = "answer";

public DataBaseHelper(Context context) {
    super(context, DB_NAME, null, DB_VERSION);
    this.mContext = context;

    DB_PATH = context.getDatabasePath(DB_NAME).getPath();


}

public void createDataBase() {
    boolean dbExist = checkDataBase();

    if (dbExist) {

    } else {
        this.getReadableDatabase();
        try {
            copyDataBase();
        } catch (IOException e) {
            throw new Error("Error copying database");
        }
    }
}

private boolean checkDataBase() {
    SQLiteDatabase checkDB = null;

    try {
        checkDB = SQLiteDatabase.openDatabase(DB_PATH, null, SQLiteDatabase.OPEN_READWRITE);
    } catch (SQLiteException e) {
        Log.e(this.getClass().toString(), "Error while checking db");
    }

    if (checkDB != null) {
        checkDB.close();
    }

    return checkDB != null ? true : false;
}

private void copyDataBase() throws IOException {
    InputStream externalDbStream = mContext.getAssets().open(DB_NAME);
    OutputStream localDbStream = new FileOutputStream(DB_PATH);

    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = externalDbStream.read(buffer)) > 0) {
        localDbStream.write(buffer, 0, bytesRead);
    }


    localDbStream.flush();
    localDbStream.close();
    externalDbStream.close();
}

public void openDataBase() throws SQLException {


    mDataBase = this.getWritableDatabase();

}

@Override
public synchronized void close() {
    if (mDataBase != null) {
        mDataBase.close();
    }
    super.close();
}

public Cursor getCursorForAllQs() {
    SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
    queryBuilder.setTables(DBTABLENAME);

    String[] asColumnsToReturn = new String[]{COLUMN_ID, COLUMN_NAME, COLUMN_CATEGORY, COLUMN_FID};

    Cursor mCursor = queryBuilder.query(mDataBase, asColumnsToReturn, null,
            null, null, null, "_id");

    return mCursor;
}

public List<String> getAnswersForQ(int questionFid) {
    List<String> answers = new ArrayList<>();
    SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
    queryBuilder.setTables(DBATABLENAME);
    String[] tableColumns = new String[]{DataBaseHelper.COLUMN_ANSWER};
    String where = "fid = ?";
    String[] selectionArgs = new String[]{String.valueOf(questionFid)};
    String orderBy = DataBaseHelper.COLUMN_ID;


    Cursor c = queryBuilder.query(mDataBase, tableColumns, where, selectionArgs, null, null, orderBy);
    if (c.moveToFirst()) {
        do {
            try{
                answers.add(c.getString(c.getColumnIndex(DataBaseHelper.COLUMN_ANSWER)));
            } catch (Exception e) {
                Log.e("FAILED", c.getString((c.getColumnIndex(DataBaseHelper.COLUMN_ANSWER))));
            }

        } while (c.moveToNext());
    }
    Log.d("getAnswersForQ", answers.toString());
    return answers;

}

public String getName(Cursor c) {
    return (c.getString(1));
}



@Override
public void onCreate(SQLiteDatabase db) {

}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    if (newVersion == 3) {
        Log.e("WORKED!!", "onUpgrade executed");
    }
    if (newVersion > oldVersion) {
        InputStream inputStream = null;
        OutputStream outputStream = null;
        String dbFilePath = DB_PATH + DB_NAME;


        try {
            inputStream = mContext.getAssets().open(DB_NAME2);

            outputStream = new FileOutputStream(dbFilePath);

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

            outputStream.flush();
            outputStream.close();
            inputStream.close();
        } catch (IOException e) {
            throw new Error("Problem copying database from resource file.");
        }
    }
}
}

导入android.content.Context；
导入android.database.Cursor；
导入android.database.sqlite.SQLiteDatabase；
导入android.database.sqlite.SQLiteException；
导入android.database.sqlite.SQLiteOpenHelper；
导入android.database.sqlite.SQLiteQueryBuilder；
导入android.util.Log；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.sql.SQLException；
导入java.util.ArrayList；
导入java.util.List；
公共类DataBaseHelper扩展了SQLiteOpenHelper{
私有静态字符串DB_路径；
私有静态最终字符串DB_NAME=“DummyTestOne.sqlite”；
私有静态最终int DB_版本=3；
私有静态最终字符串DB_NAME2=“DummyTestFive.sqlite”；
私有SQLITE数据库mDataBase；
私有最终上下文mContext；
公共静态最终字符串DBTABLENAME=“questiontable”；
公共静态最终字符串DBATABLENAME=“answertable”；
公共静态最终字符串列_ID=“_ID”；
公共静态最终字符串列\u NAME=“问题”；
公共静态最终字符串列\u CATEGORY=“CATEGORY”；
公共静态最终字符串列\u FID=“FID”；
公共静态最终字符串列\u ANSWER=“ANSWER”；
公共数据库助手（上下文）{
super（上下文，数据库名称，空，数据库版本）；
this.mContext=上下文；
DB_PATH=context.getDatabasePath（DB_NAME）.getPath（）；
}
公共数据库（）{
布尔值dbExist=checkDataBase（）；
if（dbExist）{
}否则{
这是.getReadableDatabase（）；
试一试{
copyDataBase（）；
}捕获（IOE异常）{
抛出新错误（“复制数据库时出错”）；
}
}
}
私有布尔校验数据库（）{
SQLiteDatabase checkDB=null；
试一试{
checkDB=SQLiteDatabase.openDatabase（DB\u PATH，null，SQLiteDatabase.OPEN\u READWRITE）；
}catch（sqlitee异常）{
Log.e（this.getClass（）.toString（），“检查数据库时出错”）；
}
if（checkDB！=null）{
checkDB.close（）；
}
return checkDB！=null？true:false；
}
私有void copyDataBase（）引发IOException{
InputStream externalDbStream=mContext.getAssets（）.open（DB_NAME）；
OutputStream localDbStream=新文件OutputStream（DB_路径）；
字节[]缓冲区=新字节[1024]；
int字节读取；
而（（bytesRead=externalDbStream.read（buffer））>0）{
写（缓冲区，0，字节读）；
}
localDbStream.flush（）；
localDbStream.close（）；
externalDbStream.close（）；
}
public void openDataBase（）引发SQLException{
mDataBase=this.getWritableDatabase（）；
}
@凌驾
公共同步作废关闭（）{
if（mDataBase！=null）{
mDataBase.close（）；
}
super.close（）；
}
公共游标getCursorForAllQs（）{
SQLiteQueryBuilder queryBuilder=newsqlitequerybuilder（）；
setTables（DBTABLENAME）；
String[]asColumnsToReturn=新字符串[]{COLUMN\u ID，COLUMN\u NAME，COLUMN\u CATEGORY，COLUMN\u FID}；
Cursor mCursor=queryBuilder.query（mDataBase，asColumnsToReturn，null，
空，空，空，“_id”）；
返回mCursor；
}
公共列表获取答案（内部问题FID）{
列表答案=新建ArrayList（）；
SQLiteQueryBuilder queryBuilder=newsqlitequerybuilder（）；
setTables（DBATABLENAME）；
String[]tableColumns=新字符串[]{DataBaseHelper.COLUMN_ANSWER}；
字符串，其中=“fid=？”；
String[]selectionArgs=新字符串[]{String.valueOf（questionFid）}；
字符串orderBy=DataBaseHelper.COLUMN\u ID；
Cursor c=queryBuilder.query（mDataBase、tableColumns、where、selectionArgs、null、null、orderBy）；
if（c.moveToFirst（））{
做{
试一试{
add（c.getString（c.getColumnIndex（DataBaseHelper.COLUMN_ANSWER））；
}捕获（例外e）{
Log.e（“失败”，c.getString（（c.getColumnIndex（DataBaseHelper.COLUMN_-ANSWER）））；
}
}而（c.moveToNext（））；
}
Log.d（“getAnswersForQ”，answers.toString（））；
返回答案；
}
公共字符串getName（游标c）{
返回（c.getString（1））；
}
@凌驾
public void onCreate（SQLiteDatabase db）{
}
@凌驾
public void onUpgrade（SQLiteDatabase db，int-oldVersion，int-newVersion）{
如果（新版本==3）{
Log.e（“已工作！！”，“已执行onUpgrade”）；
}
如果（新版本>旧版本）{
InputStream InputStream=null；
OutputStream OutputStream=null；
字符串dbFilePath=DB_PATH+DB_NAME；
试一试{
inputStream=mContext.getAssets（）.open（DB_NAME2）；
outputStream=新文件outputStream（dbFilePath）；
字节[]缓冲区=新字节[1024]；
整数长度；
而（（长度=inputStream.read（缓冲区））>0）{
写入（缓冲区，0，长度）；
}
outputStream.flush（）；
outputStream.close（）；
inputStream.close（）；
}捕获（IOE异常）{
抛出新错误（“从资源文件复制数据库时出现问题”）；
}
}
}
}

升级数据库意味着对其进行适当的更改，同时尽可能保持旧数据的完整性。 因此，如果要添加或重命名列，必须在

onUpgrade

回调中执行适当的SQL命令

（注意：使使用预填充数据库更容易，您应该使用它，b