title: Why is onUpgrade() not being invoked on Android sqlite database?
body: <p>I want to upgrade my database when it is installed onto my android emulator.
  I have set the db version in my DbHelper which inherits from SQLiteOpenHelper to +1.</p>
  
  <p>However, when my 1st activity loads, I instantiate my DbHelper, which I would expect SQLiteOpenHelper to call onUpgrade as the db version is now newer. However it is never called. I'm wondering if there is something I am missing.  Where is the version that the DbHelper is using stored to compare against the new version?  Why is this not working?</p>
  
  <p>I am actually copying the database from the assets folder into the data folder rather than re-creating the schema.</p>
  
  <pre><code>public class DbHelper extends SQLiteOpenHelper {
      private static final String TAG = "DbHelper";
  
      static final String DB_NAME = "caddata.sqlite";
      static final int DB_VERSION = 4;
  
      private static String DB_PATH = "";
      private Context myContext;
      private SQLiteDatabase myDataBase;
  
      public DbHelper(Context context) {
          super(context, DB_NAME, null, DB_VERSION);
          this.myContext = context;
  
          DB_PATH = "/data/data/"
                  + context.getApplicationContext().getPackageName()
                  + "/databases/";            
      }
  
      public DbHelper open() throws SQLException {        
          myDataBase =  getWritableDatabase();
  
          Log.d(TAG, "DbHelper Opening Version: " +  this.myDataBase.getVersion());
          return this;
      }
  
      @Override
      public synchronized void close() {
  
          if (myDataBase != null)
              myDataBase.close();
  
          super.close();
  
      }
  
      @Override
      public void onCreate(SQLiteDatabase db) {
          Log.d(TAG, "onCreate called");
  
          try {           
              createDataBase();
          } catch (IOException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
          }
      }
  
      @Override
      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
          if ( newVersion &gt; oldVersion)
          {
              Log.d(TAG, "New database version exists for upgrade.");         
              try {
                  Log.d(TAG, "Copying database...");
                  copyDataBase();
              } catch (IOException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              }       
          }
      }
  
      public void createDataBase() throws IOException {
  
          boolean dbExist = checkDataBase();
  
          if (!dbExist) {         
  
              try {
                  copyDataBase();
              } catch (IOException e) {
                  throw new Error("Error copying database");
              }
          }
  
          openDataBaseForRead();
      }
  
  
      private boolean checkDataBase() {
  
          SQLiteDatabase checkDB = null;
  
          try {
              String myPath = DB_PATH + DB_NAME;
              checkDB = SQLiteDatabase.openDatabase(myPath, null,
                      SQLiteDatabase.OPEN_READONLY
                              | SQLiteDatabase.NO_LOCALIZED_COLLATORS);
              Log.d(TAG, "db exists");
          } catch (SQLiteException e) {
              // database does't exist yet.
              Log.d(TAG, "db doesn't exist");
  
          }
  
          if (checkDB != null) {
              checkDB.close();            
          }
  
          return checkDB != null ? true : false;
      }
  
  
      private void copyDataBase() throws IOException {
  
          // Open your local db as the input stream
          InputStream myInput = myContext.getAssets().open(DB_NAME);
  
          // Path to the just created empty db
          String outFileName = DB_PATH + DB_NAME;
  
          // Open the empty db as the output stream
          OutputStream myOutput = new FileOutputStream(outFileName);
  
          // transfer bytes from the inputfile to the outputfile
          byte[] buffer = new byte[2048];
          int length;
          while ((length = myInput.read(buffer)) &gt; 0) {
              myOutput.write(buffer, 0, length);
          }
  
          // Close the streams
          myOutput.flush();
          myOutput.close();
          myInput.close();
  
          myDataBase.setVersion(DB_VERSION);
      }
  
      public void openDataBaseForRead() throws SQLException {
  
          // Open the database
          String myPath = DB_PATH + DB_NAME;      
          myDataBase = SQLiteDatabase.openDatabase(myPath, null,  SQLiteDatabase.OPEN_READONLY);
      }
  
      public void openDataBaseForWrite() throws SQLException {
  
          // Open the database
          String myPath = DB_PATH + DB_NAME;      
          myDataBase = SQLiteDatabase.openDatabase(myPath, null,  SQLiteDatabase.OPEN_READWRITE | SQLiteDatabase.NO_LOCALIZED_COLLATORS );
      }
  
  
  }
  </code></pre>