यह मानते हुए कि आप किसी मौजूदा पूर्व-मौजूदा डेटाबेस को दूसरी प्रति से बदलना चाहते हैं, आपके पास कई समस्याएं हैं।
आप जिस समस्या का सामना कर रहे हैं वह यह है कि चूंकि डेटाबेस मौजूद है तो प्रतिलिपि आगे नहीं बढ़ेगी यानी checkDatabase() सच लौटेगा।
यदि आप केवल copyDatabase() . का आह्वान करते हैं तब डेटाबेस को हर बार ऐप के चलने पर कॉपी किया जाएगा, जो कि अक्षम और विनाशकारी होगा यदि डेटाबेस को उपयोगकर्ता द्वारा संशोधित किया जा सकता है।
आपको जो करने की आवश्यकता है उसके पास एक संकेतक है, जिसका परीक्षण किया जा सकता है, यह देखने के लिए कि क्या पहले से मौजूद डेटाबेस को बदल दिया गया है। कई तरीके हैं लेकिन SQLite user_version का उपयोग करने के लिए सबसे संभावित/सामान्य तरीका होगा . यह एक पूर्णांक मान है और इसका उपयोग अक्सर अपग्रेड पर . के माध्यम से वर्तमान डेटाबेस को अद्यतन करने के लिए किया जाता है विधि।
डेटाबेस को खोलने के भाग के रूप में, SQLiteOpenHelper (और इसलिए उसका एक उपवर्ग) यह डेटाबेस में संग्रहीत user_version की आपूर्ति संस्करण संख्या (SQLiteOpenHelper सुपर कॉल के लिए चौथा पैरामीटर) के विरुद्ध तुलना करता है और यदि बाद वाला मान इसमें संग्रहीत मान से अधिक है डेटाबेस तो ऑनअपग्रेड विधि को कॉल किया जाता है। (यदि उल्टा है तो डाउनग्रेड पर विधि को कॉल किया जाएगा और इसे कोड किए बिना एक अपवाद होता है)।
User_version को SQLite प्रबंधन उपकरण उपयोगकर्ता SQL PRAGMA user_version = n में सेट किया जा सकता है ।
एक और मुद्दा यह है कि एंड्रॉइड 9 से, डेटाबेस डिफ़ॉल्ट रूप से WAL (राइट-अहेड लॉगिंग) मोड में खोला जाता है। उपरोक्त कोड this.getReadableDatabase(); . का उपयोग करके परिणाम -shm और -wal फाइलें बनाई जा रही हैं। उनके अस्तित्व के परिणामस्वरूप एक फंसी हुई त्रुटि होती है (क्योंकि वे तब कॉपी किए गए डेटाबेस से मेल नहीं खाते हैं) जिसके परिणामस्वरूप SQLiteOpenHelper एक खाली (सैद्धांतिक रूप से प्रयोग करने योग्य डेटाबेस) बनाता है जो मूल रूप से कॉपी किए गए डेटाबेस को मिटा देता है (मेरा मानना है कि ऐसा होता है )।
कारण this.getReadableDatabase(); उपयोग किया गया है कि यह इस मुद्दे के आसपास है कि जब कोई ऐप डेटा नहीं होता है, तो डेटाबेस फ़ोल्डर/निर्देशिका मौजूद नहीं है और उपरोक्त का उपयोग करके इसे बनाता है। यदि डेटाबेस मौजूद नहीं है तो डेटाबेस निर्देशिका/फ़ोल्डर बनाने का सही तरीका है। जैसे -wal और -shm फ़ाइलें नहीं बनाई जाती हैं।
निम्नलिखित एक उदाहरण डेटाबेस हेल्पर है जो मुद्दों पर काबू पाता है और अतिरिक्त रूप से उपयोगकर्ता_संस्करण को बदलने के आधार पर पहले से मौजूद डेटाबेस के संशोधित संस्करणों को कॉपी करने की अनुमति देता है।
public class DBHelperV001 extends SQLiteOpenHelper {
public static final String DBNAME = "test.db"; //<<<<<<<<<< obviously change accordingly
//
private static int db_user_version, asset_user_version, user_version_offset = 60, user_version_length = 4;
private static String stck_trc_msg = " (see stack-trace above)";
private static String sqlite_ext_journal = "-journal";
private static String sqlite_ext_shm = "-shm";
private static String sqlite_ext_wal = "-wal";
private static int copy_buffer_size = 1024 * 8; //Copy data in 8k chucks, change if wanted.
SQLiteDatabase mDB;
/**
* Instantiate the DBHelper, copying the databse from the asset folder if no DB exists
* or if the user_version is greater than the user_version of the current database.
* NOTE The pre-existing database copied into the assets folder MUST have the user version set
* to 1 or greater. If the user_version in the assets folder is increased above the
*
* @param context
*/
public DBHelperV001(Context context) {
// Note get the version according to the asset file
// avoid having to maintain the version number passed
super(context, DBNAME, null, setUserVersionFromAsset(context,DBNAME));
if (!ifDbExists(context,DBNAME)) {
copyDBFromAssets(context, DBNAME,DBNAME);
} else {
setUserVersionFromAsset(context,DBNAME);
setUserVersionFromDB(context,DBNAME);
if (asset_user_version > db_user_version) {
copyDBFromAssets(context,DBNAME,DBNAME);
}
}
// Force open (and hence copy attempt) when constructing helper
mDB = this.getWritableDatabase();
}
@Override
public void onCreate(SQLiteDatabase db) {
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
@Override
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
/**
* Check to see if the databse file exists
* @param context The Context
* @param dbname The databse name
* @return true id database file exists, else false
*/
private static boolean ifDbExists(Context context, String dbname) {
File db = context.getDatabasePath(dbname);
if (db.exists()) return true;
if (!db.getParentFile().exists()) {
db.getParentFile().mkdirs();
}
return false;
}
/**
* set the db_user_version according to the user_version obtained from the current database file
* @param context The Context
* @param dbname The database (file) name
* @return The user_version
*/
private static int setUserVersionFromDB(Context context, String dbname) {
File db = context.getDatabasePath(dbname);
InputStream is;
try {
is = new FileInputStream(db);
} catch (IOException e) {
throw new RuntimeException("IOError Opening " + db.getPath() + " as an InputStream" + stck_trc_msg);
}
db_user_version = getUserVersion(is);
Log.d("DATABASEUSERVERSION","Obtained user_version from current DB, it is " + String.valueOf(db_user_version)); //TODO remove for live App
return db_user_version;
}
/**
* set the asset_user_version according to the user_version from the asset file
* @param context
* @param assetname
* @return
*/
private static int setUserVersionFromAsset(Context context, String assetname) {
InputStream is;
try {
is = context.getAssets().open(assetname);
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("IOError Getting asset " + assetname + " as an InputStream" + stck_trc_msg);
}
asset_user_version = getUserVersion(is);
Log.d("ASSETUSERVERSION","Obtained user_version from asset, it is " + String.valueOf(asset_user_version)); //TODO remove for Live App
return asset_user_version;
}
/**
* Retrieve SQLite user_version from the provied InputStream
* @param is The InputStream
* @return the user_version
*/
private static int getUserVersion(InputStream is) {
String ioerrmsg = "Reading DB header bytes(60-63) ";
int rv;
byte[] buffer = new byte[user_version_length];
byte[] header = new byte[64];
try {
is.skip(user_version_offset);
is.read(buffer,0,user_version_length);
ByteBuffer bb = ByteBuffer.wrap(buffer);
rv = ByteBuffer.wrap(buffer).getInt();
ioerrmsg = "Closing DB ";
is.close();
return rv;
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("IOError " + ioerrmsg + stck_trc_msg);
}
}
/**
* Copy the database file from the assets
* Note backup of existing files may not be required
* @param context The Context
* @param dbname The database (file)name
* @param assetname The asset name (may therefore be different but )
*/
private static void copyDBFromAssets(Context context, String dbname, String assetname) {
String tag = "COPYDBFROMASSETS";
Log.d(tag,"Copying Database from assets folder");
String backup_base = "bkp_" + String.valueOf(System.currentTimeMillis());
String ioerrmsg = "Opening Asset " + assetname;
// Prepare Files that could be used
File db = context.getDatabasePath(dbname);
File dbjrn = new File(db.getPath() + sqlite_ext_journal);
File dbwal = new File(db.getPath() + sqlite_ext_wal);
File dbshm = new File(db.getPath() + sqlite_ext_shm);
File dbbkp = new File(db.getPath() + backup_base);
File dbjrnbkp = new File(db.getPath() + backup_base);
File dbwalbkp = new File(db.getPath() + backup_base);
File dbshmbkp = new File(db.getPath() + backup_base);
byte[] buffer = new byte[copy_buffer_size];
int bytes_read = 0;
int total_bytes_read = 0;
int total_bytes_written = 0;
// Backup existing sqlite files
if (db.exists()) {
db.renameTo(dbbkp);
dbjrn.renameTo(dbjrnbkp);
dbwal.renameTo(dbwalbkp);
dbshm.renameTo(dbshmbkp);
}
// ALWAYS delete the additional sqlite log files
dbjrn.delete();
dbwal.delete();
dbshm.delete();
//Attempt the copy
try {
ioerrmsg = "Open InputStream for Asset " + assetname;
InputStream is = context.getAssets().open(assetname);
ioerrmsg = "Open OutputStream for Databse " + db.getPath();
OutputStream os = new FileOutputStream(db);
ioerrmsg = "Read/Write Data";
while((bytes_read = is.read(buffer)) > 0) {
total_bytes_read = total_bytes_read + bytes_read;
os.write(buffer,0,bytes_read);
total_bytes_written = total_bytes_written + bytes_read;
}
ioerrmsg = "Flush Written data";
os.flush();
ioerrmsg = "Close DB OutputStream";
os.close();
ioerrmsg = "Close Asset InputStream";
is.close();
Log.d(tag,"Databsse copied from the assets folder. " + String.valueOf(total_bytes_written) + " bytes were copied.");
// Delete the backups
dbbkp.delete();
dbjrnbkp.delete();
dbwalbkp.delete();
dbshmbkp.delete();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException("IOError attempting to " + ioerrmsg + stck_trc_msg);
}
}
}
उदाहरण उपयोग
निम्नलिखित संपत्ति फ़ाइलों (sqlite डेटाबेस) पर विचार करें (चेतावनी के रूप में वे ऐप विफल हो जाएंगे ) :-
तो दो डेटाबेस हैं (PRAGMA user_version = 1 का उपयोग करके सेट किए गए उपयोगकर्ता_वर्जन के समान बार) और PRAGMA user_version = 2 क्रमशः/फ़ाइल नामों के अनुसार) एकदम नए के लिए, पहली बार ऐप चलाएं (यानी अनइंस्टॉल किया गया) फिर फ़ाइल test.dbV1 का नाम बदलकर test.db . कर दिया गया है और निम्न गतिविधि का उपयोग किया जाता है :-
public class MainActivity extends AppCompatActivity {
DBHelperV001 mDbhlpr;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mDbhlpr = new DBHelperV001(this);
DatabaseUtils.dumpCursor(
mDbhlpr.getWritableDatabase().query(
"sqlite_master",
null,null,null,null,null,null
)
);
}
}
- यह बस डेटाबेस हेल्पर (जो डेटाबेस को कॉपी या उपयोग करेगा) को इंस्टेंट करता है और फिर sqlite_master टेबल को डंप कर देता है।
लॉग में शामिल हैं :-
04-02 12:55:36.258 644-644/aaa.so55441840 D/ASSETUSERVERSION: Obtained user_version from asset, it is 1
04-02 12:55:36.258 644-644/aaa.so55441840 D/COPYDBFROMASSETS: Copying Database from assets folder
04-02 12:55:36.262 644-644/aaa.so55441840 D/COPYDBFROMASSETS: Databsse copied from the assets folder. 69632 bytes were copied.
04-02 12:55:36.265 644-644/aaa.so55441840 I/System.out: >>>>> Dumping cursor [email protected]
04-02 12:55:36.265 644-644/aaa.so55441840 I/System.out: 0 {
04-02 12:55:36.265 644-644/aaa.so55441840 I/System.out: type=table
04-02 12:55:36.265 644-644/aaa.so55441840 I/System.out: name=android_metadata
04-02 12:55:36.265 644-644/aaa.so55441840 I/System.out: tbl_name=android_metadata
04-02 12:55:36.265 644-644/aaa.so55441840 I/System.out: rootpage=3
04-02 12:55:36.265 644-644/aaa.so55441840 I/System.out: sql=CREATE TABLE android_metadata (locale TEXT)
04-02 12:55:36.266 644-644/aaa.so55441840 I/System.out: }
04-02 12:55:36.266 644-644/aaa.so55441840 I/System.out: 1 {
04-02 12:55:36.266 644-644/aaa.so55441840 I/System.out: type=table
04-02 12:55:36.266 644-644/aaa.so55441840 I/System.out: name=shops
..........
जब डीबी का नया संस्करण पेश किया जाता है, जिसमें 2 का user_version होता है
- अर्थात test.db जो test.dbV1 . था का नाम बदलकर test.dbV1 . कर दिया गया है और फिर,
- (इसे प्रभावी ढंग से हटा रहा है)
- test.dbV2 फिर इसका नाम बदल दिया जाता है test.db
- (नई संपत्ति फ़ाइल को प्रभावी ढंग से पेश करते हुए) :-
और ऐप को फिर से चलाया जाता है तो लॉग में होता है :-
04-02 13:04:25.044 758-758/? D/ASSETUSERVERSION: Obtained user_version from asset, it is 2
04-02 13:04:25.046 758-758/? D/ASSETUSERVERSION: Obtained user_version from asset, it is 2
04-02 13:04:25.046 758-758/? D/DATABASEUSERVERSION: Obtained user_version from current DB, it is 1
04-02 13:04:25.047 758-758/? D/COPYDBFROMASSETS: Copying Database from assets folder
04-02 13:04:25.048 758-758/? D/COPYDBFROMASSETS: Databsse copied from the assets folder. 69632 bytes were copied.
04-02 13:04:25.051 758-758/? I/System.out: >>>>> Dumping cursor [email protected]
04-02 13:04:25.052 758-758/? I/System.out: 0 {
04-02 13:04:25.052 758-758/? I/System.out: type=table
04-02 13:04:25.052 758-758/? I/System.out: name=android_metadata
04-02 13:04:25.052 758-758/? I/System.out: tbl_name=android_metadata
04-02 13:04:25.052 758-758/? I/System.out: rootpage=3
04-02 13:04:25.052 758-758/? I/System.out: sql=CREATE TABLE android_metadata (locale TEXT)
04-02 13:04:25.052 758-758/? I/System.out: }
04-02 13:04:25.052 758-758/? I/System.out: 1 {
04-02 13:04:25.052 758-758/? I/System.out: type=table
04-02 13:04:25.052 758-758/? I/System.out: name=shops
अंत में, बाद में चलने के साथ यानी कोई अद्यतन संपत्ति नहीं, लॉग दिखाता है :-
04-02 13:05:50.197 840-840/aaa.so55441840 D/ASSETUSERVERSION: Obtained user_version from asset, it is 2
04-02 13:05:50.198 840-840/aaa.so55441840 D/ASSETUSERVERSION: Obtained user_version from asset, it is 2
04-02 13:05:50.198 840-840/aaa.so55441840 D/DATABASEUSERVERSION: Obtained user_version from current DB, it is 2
04-02 13:05:50.201 840-840/aaa.so55441840 I/System.out: >>>>> Dumping cursor [email protected]
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: 0 {
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: type=table
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: name=android_metadata
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: tbl_name=android_metadata
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: rootpage=3
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: sql=CREATE TABLE android_metadata (locale TEXT)
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: }
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: 1 {
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: type=table
04-02 13:05:50.202 840-840/aaa.so55441840 I/System.out: name=shops
यानी कोई कॉपी नहीं की गई क्योंकि संपत्ति प्रभावी रूप से समान है
