2011-12-08 41 views
11

Tôi đang tạo một ứng dụng cần một cơ sở dữ liệu. Tôi tạo ra nó bằng cách sử dụng trình duyệt cơ sở dữ liệu sqlite, có nghĩa là các ứng dụng tôi tạo ra, nhập khẩu cơ sở dữ liệu tôi tạo ra vào điện thoại.Làm cách nào để nâng cấp cơ sở dữ liệu mà không xóa dữ liệu mà người dùng nhập vào cơ sở dữ liệu trước đó?

Ứng dụng tôi tạo yêu cầu người dùng nhập dữ liệu vào cơ sở dữ liệu. Khi nâng cấp cơ sở dữ liệu, tôi hy vọng giữ lại dữ liệu mà người dùng đã nhập.


cơ sở dữ liệu mã giúp đỡ của tôi là dưới đây:

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))>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<String> selectData 
    (String tableName, String [] columns, String selection, String[] selectionArgs, 
      String groupBy, String having, String orderBy) { 

    List<String> list = new ArrayList<String>(); 

    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 && !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 
} 

* lưu ý: cơ sở dữ liệu của tôi bao gồm nhiều hơn một bảng. Hai bảng yêu cầu đầu vào của người dùng. Những người khác thì không.

Tôi hy vọng rằng câu trả lời thực sự có thể được đưa ra, thay vì đưa ra trang web không có trong tình huống chính xác mà tôi có, vì tôi bị lẫn lộn dễ dàng.

Trả lời

23

Bạn nên thêm một số mã vào phương thức onUpgrade. Với điều đó, bạn có thể kiểm tra oldVersion và newVersion và thực hiện các câu lệnh ALTER TABLE thích hợp. Như bạn có thể thấy, phiên bản hiện tại là 23 và mã kiểm tra kiểm tra phiên bản cũ là gì. Nếu phiên bản 22 nó chỉ là các câu lệnh v22, nhưng nếu phiên bản 21 nó thực hiện cả câu lệnh v21 và v22. Đây là một phần của ứng dụng Google I/O:

private static final int VER_LAUNCH = 21; 
private static final int VER_SESSION_FEEDBACK_URL = 22; 
private static final int VER_SESSION_NOTES_URL_SLUG = 23; 

private static final int DATABASE_VERSION = VER_SESSION_NOTES_URL_SLUG; 

... 

@Override 
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
    Log.d(TAG, "onUpgrade() from " + oldVersion + " to " + newVersion); 

    // NOTE: This switch statement is designed to handle cascading database 
    // updates, starting at the current version and falling through to all 
    // future upgrade cases. Only use "break;" when you want to drop and 
    // recreate the entire database. 
    int version = oldVersion; 

    switch (version) { 
     case VER_LAUNCH: 
      // Version 22 added column for session feedback URL. 
      db.execSQL("ALTER TABLE " + Tables.SESSIONS + " ADD COLUMN " 
        + SessionsColumns.SESSION_FEEDBACK_URL + " TEXT"); 
      version = VER_SESSION_FEEDBACK_URL; 

     case VER_SESSION_FEEDBACK_URL: 
      // Version 23 added columns for session official notes URL and slug. 
      db.execSQL("ALTER TABLE " + Tables.SESSIONS + " ADD COLUMN " 
        + SessionsColumns.SESSION_NOTES_URL + " TEXT"); 
      db.execSQL("ALTER TABLE " + Tables.SESSIONS + " ADD COLUMN " 
        + SessionsColumns.SESSION_SLUG + " TEXT"); 
      version = VER_SESSION_NOTES_URL_SLUG; 
    } 

    Log.d(TAG, "after upgrade logic, at version " + version); 
    if (version != DATABASE_VERSION) { 
     Log.w(TAG, "Destroying old data during upgrade"); 

     db.execSQL("DROP TABLE IF EXISTS " + Tables.BLOCKS); 

     // ... delete all your tables ... 

     onCreate(db); 
    } 
} 
+0

xin lỗi ... tôi không thể hiểu truy vấn có trong cơ sở dữ liệu vì nó không nêu giá trị của nó là gì. – Jovi

+0

Truy vấn gì? Bạn cần phải hiểu lược đồ của cơ sở dữ liệu để cập nhật nó lên phiên bản mới. –

+0

xin lỗi, ý tôi là truy vấn được hiển thị trong ví dụ. (ví dụ: db.execSQL ("ALTER TABLE" + Tables.SESSIONS + "ADD COLUMN" + SessionsColumns.SESSION_FEEDBACK_URL + "TEXT"); phiên bản = VER_SESSION_FEEDBACK_URL;) làm định nghĩa cho ví dụ: Tables.Session chưa được đưa ra – Jovi

Các vấn đề liên quan