title: How do I upgrade a database without removing the data that the user input in the previous database?
body: <p>I am creating an app that needs a database. I created it using sqlite database browser, which means the app I created, imports the database I created into the phone.</p>
  
  <p>The app that I create requires that the user enter data into the database. When upgrading the database, I hope to retain the data that the user had input.</p>
  
  <p><br>My database helper code is below:</p>
  
  <pre><code>public class DatabaseHelper extends SQLiteOpenHelper {
  
  //The Android's default system path of your application database.
  private static String DB_PATH = "/data/data/test.test/databases/";
  
  private static String DB_NAME = "TestDatabase";
  
  private static final int DB_VERSION = 1;
  
  private SQLiteDatabase myDatabase; 
  
  private final Context myContext;
  
  /**
   *  # Constructor #
   * Takes and keeps a reference of the passed context in order to access to the application assets and resources.
   * @param context
   */
  public DatabaseHelper(Context context) {
  
      super(context, DB_NAME, null, DB_VERSION);
      this.myContext = context;
  }//constructor  
  
  /**
   *  # Create Database #
   * Creates a empty database on the system and rewrites it with your own database.
   */
  public void createDatabase() throws IOException {
  
      boolean dbExist = checkDatabase();
  
      if(dbExist)
      {
          //do nothing - database already exist
      }//if
  
      else
      {
          //By calling this method and empty database will be created into the default system path
             //of your application so we are gonna be able to overwrite that database with our database.
          this.getReadableDatabase();
  
          try 
          {
              copyDatabase();
  
          } catch (IOException e) {
  
              throw new Error("Error copying database");
  
          }//catch
      }//else
  
  }//createDatabase
  
  private boolean checkDatabase() {
  
      SQLiteDatabase checkDB = null;
  
      try
      {
          String myPath = DB_PATH + DB_NAME;
          checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
  
      } catch(SQLiteException e) {
  
          //database does't exist yet.
  
      }//catch
  
      if(checkDB != null) 
      { 
          checkDB.close();
  
      }//if
  
      return checkDB != null ? true : false;
  
  }//checkDatabase
  
  
  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[1024];
      int length;
  
      while ((length = myInput.read(buffer))&gt;0)
      {
          myOutput.write(buffer, 0, length);
      }
  
      //Close the streams
      myOutput.flush();
      myOutput.close();
      myInput.close();
  
  }//copyDatabase
  
  // # open database #
  public void openDatabase() throws SQLException {
  
      //Open the database
      String myPath = DB_PATH + DB_NAME;
      myDatabase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
  
  }//openDatabase
  
  @Override
  public synchronized void close() 
  {
      if(myDatabase != null)
          myDatabase.close();
  
      super.close();
  
  }//close
  
  @Override
  public void onCreate(SQLiteDatabase db) {
  
  }
  
  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  
  }
  
  public List&lt;String&gt; selectData
      (String tableName, String [] columns, String selection, String[] selectionArgs,
              String groupBy, String having, String orderBy) {
  
      List&lt;String&gt; list = new ArrayList&lt;String&gt;();
  
      Cursor cursor = this.myDatabase.query(tableName, columns, selection, selectionArgs, groupBy, having, orderBy);
  
      if (cursor.moveToFirst()) 
      {
          do 
          {
              list.add(cursor.getString(0));
          }
  
          while (cursor.moveToNext());
      }
  
      if (cursor != null &amp;&amp; !cursor.isClosed()) 
      {
          cursor.close();
      }
      return list;
  
  }//selectData
  
  public void insertData (String tableName, String nullColumnHack, ContentValues values) {
  
      try
      {
          myDatabase.insert(tableName, nullColumnHack, values);
      } catch (Exception e) {
          Log.e("Error :","unable to insert data");
      }//catch
  
  }//insertData
  
  //edit row
  public void updateData (String tableName, ContentValues values, String whereClause, String[] whereArgs) {
  
      try
      {
          myDatabase.update(tableName, values, whereClause, whereArgs);
      } catch (Exception e) {
          Log.e("Error :","unable to update data");
      }//catch
  }//updateData
  
  public void deleteRow (String tableName, String whereClause, String[] whereArgs) {
  
      try
      {
          myDatabase.delete(tableName, whereClause, whereArgs);
      } catch (Exception e) {
          Log.e("Error :","unable to delete row");
      }//catch
  }//deleteRow
  }
  </code></pre>
  
  <p>*note: My database consist of more than one table. Two tables require user input. The others don't.</p>
  
  <p>I hope that real answer could be given, instead of giving website that is not in the exact situation that I have, as I get confused easily.</p>