kotlin 如何将Room数据库导出为.db文件到下载文件，以便稍后使用？

wwwo4jvm  于 2023-08-07  发布在  Kotlin
关注(0)|答案(3)|浏览(302)

如何将Room数据库导出为.db文件以便以后使用？我想将其导出到Android设备存储中的下载文件夹。我已经设置导出到.CSV，但现在我需要. db。
这是这样我就可以重新导入它，如果用户正在切换设备，并需要他的数据在其他设备上。
有没有一种方法可以只使用.CSV数据，或者我必须使用.db？

kotlin

3条答案

按热度按时间
jgovgodb

jgovgodb1#

备份数据库文件要简单得多，而且可能比尝试操作CSV数据更快。
还有一个优点是，只需复制文件，就可以在SQLite工具中使用数据库。
P.S.扩展（例如. csv.db）只是文件用途的指示。在示例中使用了.whatever。

  • 一个问题是，恢复数据库后，访问恢复的数据可能会出现问题。
  • 规避此类问题的一种方法是在恢复后自动重新启动应用程序。
  • 另一个问题是，默认情况下，Room使用Write-Ahead Logging（WAL），并且检查点数据库似乎并不那么容易。
  • 作为替代备份单个文件的方法，可以备份和还原3个文件（wal文件和shm文件）请参阅https://www.sqlite.org/wal.html

这里有一个示例/演示应用程序，它使用一个Room数据库，其中只有一个表，只有2列。当应用程序运行时，有一个具有4个UI组件的单个Activity：

  • 允许备份数据库的按钮。
  • 允许还原数据库的按钮。
  • 允许添加某些数据的按钮（3行）。
  • 当前数据的列表。
    • 注意，为了简单和简洁，所有工作都在主线程上进行 *
    • 同样为了简单和简洁，所有数据库代码都在一个文件中RoomEntities*
    • 此外，为简单起见，备份到同一目录data/data/the_package_name/databases *
      RoomEntities（所有数据库代码，包括备份和恢复代码）：-
  1. const val THETABLE_TABLENAME = "theTable"
  2. const val THETABLE_ID_COLUMN = THETABLE_TABLENAME + "_id"
  3. const val TheTABLE_OTHER_COLUMN = THETABLE_TABLENAME + "_other"
  4. const val THEDATABASE_DATABASE_NAME = "thedatabase.whatever"
  5. const val THEDATABASE_DATABASE_BACKUP_SUFFIX = "-bkp"
  6. const val SQLITE_WALFILE_SUFFIX = "-wal"
  7. const val SQLITE_SHMFILE_SUFFIX = "-shm"
  8. @Entity(tableName = THETABLE_TABLENAME)
  9. data class TheTable(
  10.     @PrimaryKey @ColumnInfo(name = THETABLE_ID_COLUMN) var id: Long?=null,
  11.     @ColumnInfo(name = TheTABLE_OTHER_COLUMN) var other: String
  12. )
  13. @Dao
  14. interface AllDAO {
  15.     @Insert(onConflict = OnConflictStrategy.IGNORE)
  16.     fun insert(theTable: TheTable): Long
  17.     @Query("SELECT * FROM $THETABLE_TABLENAME")
  18.     fun getAllFromTheTable(): List<TheTable>
  19. }
  20. @Database(entities = [TheTable::class], exportSchema = false, version = 1)
  21. abstract class TheDatabase: RoomDatabase() {
  22.     abstract fun getAllDao(): AllDAO
  24.     companion object {
  25.         private var instance: TheDatabase? = null
  26.         fun getInstance(context: Context): TheDatabase {
  27.             if (instance==null) {
  28.                 instance = Room.databaseBuilder(context,TheDatabase::class.java,
  29.                     THEDATABASE_DATABASE_NAME)
  30.                     .allowMainThreadQueries()
  31.                     .build()
  32.             }
  33.             return instance as TheDatabase
  34.         }
  35.     }
  37.     /**
  38.      * Backup the database
  39.      */
  40.     fun backupDatabase(context: Context): Int {
  41.         var result = -99
  42.         if (instance==null) return result
  44.         val dbFile = context.getDatabasePath(THEDATABASE_DATABASE_NAME)
  45.         val dbWalFile = File(dbFile.path + SQLITE_WALFILE_SUFFIX)
  46.         val dbShmFile = File(dbFile.path + SQLITE_SHMFILE_SUFFIX)
  47.         val bkpFile = File(dbFile.path + THEDATABASE_DATABASE_BACKUP_SUFFIX)
  48.         val bkpWalFile = File(bkpFile.path + SQLITE_WALFILE_SUFFIX)
  49.         val bkpShmFile = File(bkpFile.path + SQLITE_SHMFILE_SUFFIX)
  50.         if (bkpFile.exists()) bkpFile.delete()
  51.         if (bkpWalFile.exists()) bkpWalFile.delete()
  52.         if (bkpShmFile.exists()) bkpShmFile.delete()
  53.         checkpoint()
  54.         try {
  55.             dbFile.copyTo(bkpFile,true)
  56.             if (dbWalFile.exists()) dbWalFile.copyTo(bkpWalFile,true)
  57.             if (dbShmFile.exists()) dbShmFile.copyTo(bkpShmFile, true)
  58.             result = 0
  59.         } catch (e: IOException) {
  60.             e.printStackTrace()
  61.         }
  62.         return result
  63.     }
  65.     /**
  66.      *  Restore the database and then restart the App
  67.      */
  68.     fun restoreDatabase(context: Context,restart: Boolean = true) {
  69.         if(!File(context.getDatabasePath(THEDATABASE_DATABASE_NAME).path + THEDATABASE_DATABASE_BACKUP_SUFFIX).exists()) {
  70.             return
  71.         }
  72.         if (instance == null) return
  73.         val dbpath = instance!!.getOpenHelper().readableDatabase.path
  74.         val dbFile = File(dbpath)
  75.         val dbWalFile = File(dbFile.path + SQLITE_WALFILE_SUFFIX)
  76.         val dbShmFile = File(dbFile.path + SQLITE_SHMFILE_SUFFIX)
  77.         val bkpFile = File(dbFile.path + THEDATABASE_DATABASE_BACKUP_SUFFIX)
  78.         val bkpWalFile = File(bkpFile.path + SQLITE_WALFILE_SUFFIX)
  79.         val bkpShmFile = File(bkpFile.path + SQLITE_SHMFILE_SUFFIX)
  80.         try {
  81.             bkpFile.copyTo(dbFile, true)
  82.             if (bkpWalFile.exists()) bkpWalFile.copyTo(dbWalFile, true)
  83.             if (bkpShmFile.exists()) bkpShmFile.copyTo(dbShmFile,true)
  84.             checkpoint()
  85.         } catch (e: IOException) {
  86.             e.printStackTrace()
  87.         }
  88.         if (restart) {
  89.             val i = context.packageManager.getLaunchIntentForPackage(context.packageName)
  90.             i!!.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
  91.             context.startActivity(i)
  92.             System.exit(0)
  93.         }
  94.     }
  95.     private fun checkpoint() {
  96.         var db = this.getOpenHelper().writableDatabase
  97.         db.query("PRAGMA wal_checkpoint(FULL);",null)
  98.         db.query("PRAGMA wal_checkpoint(TRUNCATE);",null)
  99.     }
  100. }

字符串

  • 请注意，检查点函数似乎并没有实际检查点（关闭数据库，这将检查数据库，导致Room框架/ Package 器周围的问题）

从代码中可以看出，备份和恢复基本上只是复制文件。
活动的布局是：-

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:tools="http://schemas.android.com/tools"
  4.     android:orientation="vertical"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     tools:context=".MainActivity">
  9.     <TextView
  10.         android:layout_width="wrap_content"
  11.         android:layout_height="wrap_content"
  12.         android:text="Hello World!"
  13.         />
  14.     <Button
  15.         android:id="@+id/backup"
  16.         android:layout_width="wrap_content"
  17.         android:layout_height="wrap_content"
  18.         android:text="BACKUP"
  19.         >
  20.     </Button>
  21.     <Button
  22.         android:id="@+id/restore"
  23.         android:layout_width="wrap_content"
  24.         android:layout_height="wrap_content"
  25.         android:text="RESTORE"
  26.         >
  27.     </Button>
  28.     <Button
  29.         android:id="@+id/addData"
  30.         android:layout_width="wrap_content"
  31.         android:layout_height="wrap_content"
  32.         android:text="ADD DATA"
  33.         >
  34.     </Button>
  35.     <ListView
  36.         android:id="@+id/datalist"
  37.         android:layout_width="wrap_content"
  38.         android:layout_height="wrap_content"
  39.         >
  40.     </ListView>
  41. </LinearLayout>

型
主活动（MainActivity）：

  1. class MainActivity : AppCompatActivity() {
  2.     lateinit var db: TheDatabase
  3.     lateinit var dao: AllDAO
  4.     lateinit var backupButton: Button
  5.     lateinit var restoreButton: Button
  6.     lateinit var addDataButton: Button
  7.     lateinit var listView: ListView
  8.     var listAdapter: SimpleCursorAdapter? = null
  10.     override fun onCreate(savedInstanceState: Bundle?) {
  11.         super.onCreate(savedInstanceState)
  12.         setContentView(R.layout.activity_main)
  13.         backupButton = this.findViewById(R.id.backup)
  14.         restoreButton = this.findViewById(R.id.restore)
  15.         addDataButton = this.findViewById(R.id.addData)
  16.         listView = this.findViewById(R.id.datalist)
  18.         db = TheDatabase.getInstance(this)
  19.         dao = db.getAllDao()
  20.         setButtonListeners()
  21.         setOrRefreshListView()
  22.     }
  24.     fun setButtonListeners() {
  25.         addDataButton.setOnClickListener {
  26.             dao.insert(TheTable(other = "DATA_${System.currentTimeMillis()}"))
  27.             dao.insert(TheTable(other = "DATA_${System.currentTimeMillis()}"))
  28.             dao.insert(TheTable(other = "DATA_${System.currentTimeMillis()}"))
  29.             setOrRefreshListView()
  30.         }
  31.         backupButton.setOnClickListener {
  32.             db.backupDatabase(this)
  33.         }
  34.         restoreButton.setOnClickListener {
  35.             db.restoreDatabase(this)
  36.         }
  38.     }
  40.     fun setOrRefreshListView() {
  41.         var csr = db.getOpenHelper().writableDatabase.query("SELECT $THETABLE_ID_COLUMN AS _id, $TheTABLE_OTHER_COLUMN FROM $THETABLE_TABLENAME")
  42.         if (listAdapter==null) {
  43.             listAdapter = SimpleCursorAdapter(
  44.                 this,
  45.                 android.R.layout.simple_list_item_2,
  46.                 csr,
  47.                 arrayOf("_id", TheTABLE_OTHER_COLUMN),
  48.                 intArrayOf(android.R.id.text1,android.R.id.text2), 0
  49.             )
  50.             listView.adapter = listAdapter
  51.         } else {
  52.             listAdapter!!.swapCursor(csr)
  53.         }
  54.     }
  55. }

型

结果

当第一次运行时，则显示为：-
x1c 0d1x的数据

  • 理想情况下，恢复按钮不应该出现，因为在这个阶段没有什么可以恢复
  • 单击“恢复”按钮可以恢复，因为恢复功能会检查是否有任何恢复文件，如果没有，则会立即返回

如果单击备份按钮，则文件将被备份（即使没有数据（但文件中实际上会有一些数据，例如文件头和系统表））。
如果在单击“备份”按钮后，单击了“恢复”按钮（即使未添加数据），则实际上恢复了数据库并重新启动了应用程序。
如果单击“添加数据”按钮，将添加并显示3行数据（如果再次单击，将添加另外3行数据，依此类推）。


的
因为之前单击了“备份”按钮。单击恢复按钮将恢复到没有数据的备份，并重新启动显示没有数据的应用程序。


的
添加2组数据并单击“备份”按钮


的
添加另外2组数据
x1c4d 1x的
单击恢复，然后数据将恢复为6行数据


型

展开查看全部
赞(0）分享  回复(0）举报  2023-08-07
omqzjyyz

omqzjyyz2#

这是一个CSV解决方案，将备份和恢复所有非系统/房间/Android表但是，它不处理BLOB（这是更复杂的）它可能有空间问题，它可能有问题，如果外键约束包括在内（备份文件是建议的方式，因为它是远远不太可能遇到问题，除了建议的应用程序重新启动，这只是一个不便）。
此外，为了简洁和方便起见，

  • a）在主线程上运行
  • B）将备份放在数据库文件夹中，而不是其他地方

它围绕着4个函数，在这个例子中，在@Database注解类（TheDatabase）中。这些职能是：

getTableColumnnames（参见示例/演示）

  • 这将使用提供的SupportSQLiteDatabase（均从createAutoCSV函数传递）返回提供的表名中的列列表
  • 列表被返回到调用函数。
    createAutoCSV（参见示例/演示）
  • 此函数从逐步构建的StringBuffer生成并返回CSV文件作为字符串。
  • 不确定大小限制（参见MaxCapacity of StringBuilder）
  • 直接执行writeText可能更安全
  • 除了实际数据之外，CSV还有一个开始和结束指示符（实际上并不需要，因为它们只是被跳过了）以及每个表的指示符，该指示符位于该表的数据之前（请参阅restoreFromCSV函数）。
  • 如果数据包含逗号，逗号将替换为{COMMA}（值可以很容易地更改），就像许多值是常量一样。

String this返回的CSV示例如下：-

  1. {START}
  2. {TABLE},theTable
  3. 1,DATA1{COMMA}_1659427794369
  4. ....
  5. {TABLE},theOtherTable
  6. 1,OTHERDATA1_1659427794{COMMA},{COMMA}1659427794398{COMMA},     
  7. ....
  8. {END}

字符串

  • 用于测试BLOB的注解用于theOtherTable中的第3列（但BLOB未正确处理）
  • 可以看出，{START}和{END}表示数据的开始和结束（实际上不需要）。
  • 如图所示，表由{TABLE}表示，后面跟着逗号和表名本身。
    backupAsCSV()（参见示例演示）
  • 这只是写入数据，删除任何以前的版本（该示例仅使用单个备份文件，因此恢复只是到最新的备份）。
    restoreFromCSV（参见示例/演示）
  • 这，在一个单一的事务（所以应该只有一个写入数据库文件本身，尽管它可能有很多页）为每个表遇到（应该是所有非SQLite/房间/Android表）：-
  • 删除所有现有行，然后
  • 依次插入每行
  • 请注意，对于从以前的备份文件恢复到已更改的模式（这很可能导致插入时失败（例如NOT NULL冲突）或后续失败）
  • 注意，也没有考虑关系的任何顺序逻辑（确保外键父项在子项之前填充）
  • 简而言之，正如建议的那样，备份数据库文件是一种方法，因为使用CSV文件的所有陷阱都是无关紧要的。唯一的缺点是建议在通过文件恢复后重新启动应用程序。
    工作示例/演示

下面是完整的代码：

  • 在两个ListView（每个表一个）中显示来自2个表的数据（按照上面的CSV示例）。
  • 允许通过单击按钮（2个按钮）备份数据：-
  • 数据库文件的副本，和/或
  • CSV文件
  • 允许恢复数据，通过点击按钮（2按钮）从：-
  • 数据库的文件副本
  • 注意：重启应用程序以确保数据库的完整性
  • 和/或CSV文件
  • 请注意，BLOB未正确备份/恢复（需要更复杂的处理来处理BLOB）

文件/类：-

RoomEntities.kt（为了方便/简洁起见，所有数据库代码都在一个文件中）

  1. /* Database level */
  2. const val THEDATABASE_DATABASE_NAME = "thedatabase.whatever"
  3. const val THEDATABASE_DATABASE_BACKUP_SUFFIX = "-bkp"
  4. const val THEDATBASE_DATABASE_BACKUP_CSV_SUFFIX = ".csv"
  5. const val SQLITE_WALFILE_SUFFIX = "-wal"
  6. const val SQLITE_SHMFILE_SUFFIX = "-shm"
  7. /* Tables */
  8. const val THETABLE_TABLENAME = "theTable"
  9. const val THEOTHERTABLE_TABLENAME = "theOtherTable"
  10. /* Columns  TheTable */
  11. const val THETABLE_ID_COLUMN = THETABLE_TABLENAME + "_id"
  12. const val THETABLE_OTHER_COLUMN = THEOTHERTABLE_TABLENAME + "_other"
  13. /* Columns TheOtherTable */
  14. const val THEOTHERTABLE_ID_COLUMN = THEOTHERTABLE_TABLENAME + "_id"
  15. const val THEOTHERTABLE_OTHER_COLUMN = THEOTHERTABLE_TABLENAME + "_other"
  16. const val THEOTHERTABLE_ANOTHER_COLUMN = THEOTHERTABLE_TABLENAME + "_another"
  17. const val THEOTHERTABLE_YETANOTHER_COLUMN = THEOTHERTABLE_TABLENAME + "_yetanother"
  18. /*CSV level */
  19. const val CSV_NEWLINE = "\n"
  20. const val CSV_INDICATOR_START = "{START}"
  21. const val CSV_INDICATOR_END = "{END}"
  22. const val CSV_INDICATOR_TABLE = "{TABLE}"
  23. const val CSV_COMMA_REPLACE = "{COMMA}"
  25. @Entity(tableName = THETABLE_TABLENAME)
  26. data class TheTable(
  27.     @PrimaryKey @ColumnInfo(name = THETABLE_ID_COLUMN) var id: Long?=null,
  28.     @ColumnInfo(name = THETABLE_OTHER_COLUMN) var other: String
  29. )
  30. @Entity(tableName = THEOTHERTABLE_TABLENAME)
  31. data class TheOtherTable(
  32.     @PrimaryKey @ColumnInfo(name = THEOTHERTABLE_ID_COLUMN) var id: Long? = null,
  33.     @ColumnInfo(name = THEOTHERTABLE_OTHER_COLUMN) var other: String,
  34.     @ColumnInfo(name = THEOTHERTABLE_ANOTHER_COLUMN) var another: String,
  35.     @ColumnInfo(name = THEOTHERTABLE_YETANOTHER_COLUMN ) var yetanother: ByteArray = byteArrayOf(1,2,3,4,5,127,-127)
  36. )
  37. @Dao
  38. interface AllDAO {
  39.     @Insert(onConflict = OnConflictStrategy.IGNORE)
  40.     fun insert(theTable: TheTable): Long
  41.     @Insert(onConflict = OnConflictStrategy.IGNORE)
  42.     fun insert(theOtherTable: TheOtherTable): Long
  43.     @Query("SELECT * FROM $THETABLE_TABLENAME")
  44.     fun getAllFromTheTable(): List<TheTable>
  45.     @Query("SELECT * FROM $THEOTHERTABLE_TABLENAME")
  46.     fun getAllFromTheOtherTable(): List<TheOtherTable>
  47. }
  48. @Database(entities = [TheTable::class,TheOtherTable::class], exportSchema = false, version = 1)
  49. abstract class TheDatabase: RoomDatabase() {
  50.     abstract fun getAllDao(): AllDAO
  52.     companion object {
  53.         private var instance: TheDatabase? = null
  54.         fun getInstance(context: Context): TheDatabase {
  55.             if (instance==null) {
  56.                 instance = Room.databaseBuilder(context,TheDatabase::class.java,
  57.                     THEDATABASE_DATABASE_NAME)
  58.                     .allowMainThreadQueries()
  59.                     .build()
  60.             }
  61.             return instance as TheDatabase
  62.         }
  63.     }
  64.     /**
  65.      * Backup the database
  66.      */
  67.     fun backupDatabase(context: Context): Int {
  68.         var result = -99
  69.         if (instance==null) return result
  70.         val dbFile = context.getDatabasePath(THEDATABASE_DATABASE_NAME)
  71.         val dbWalFile = File(dbFile.path + SQLITE_WALFILE_SUFFIX)
  72.         val dbShmFile = File(dbFile.path + SQLITE_SHMFILE_SUFFIX)
  73.         val bkpFile = File(dbFile.path + THEDATABASE_DATABASE_BACKUP_SUFFIX)
  74.         val bkpWalFile = File(bkpFile.path + SQLITE_WALFILE_SUFFIX)
  75.         val bkpShmFile = File(bkpFile.path + SQLITE_SHMFILE_SUFFIX)
  76.         if (bkpFile.exists()) bkpFile.delete()
  77.         if (bkpWalFile.exists()) bkpWalFile.delete()
  78.         if (bkpShmFile.exists()) bkpShmFile.delete()
  79.         try {
  80.             dbFile.copyTo(bkpFile,true)
  81.             if (dbWalFile.exists()) dbWalFile.copyTo(bkpWalFile,true)
  82.             if (dbShmFile.exists()) dbShmFile.copyTo(bkpShmFile, true)
  83.             result = 0
  84.         } catch (e: IOException) {
  85.             e.printStackTrace()
  86.         }
  87.         return result
  88.     }
  89.     /**
  90.      *  Restore the database and then restart the App
  91.      */
  92.     fun restoreDatabase(context: Context,restart: Boolean = true) {
  93.         if(!File(context.getDatabasePath(THEDATABASE_DATABASE_NAME).path + THEDATABASE_DATABASE_BACKUP_SUFFIX).exists()) {
  94.             return
  95.         }
  96.         if (instance == null) return
  97.         val dbpath = instance!!.getOpenHelper().readableDatabase.path
  98.         val dbFile = File(dbpath)
  99.         val dbWalFile = File(dbFile.path + SQLITE_WALFILE_SUFFIX)
  100.         val dbShmFile = File(dbFile.path + SQLITE_SHMFILE_SUFFIX)
  101.         val bkpFile = File(dbFile.path + THEDATABASE_DATABASE_BACKUP_SUFFIX)
  102.         val bkpWalFile = File(bkpFile.path + SQLITE_WALFILE_SUFFIX)
  103.         val bkpShmFile = File(bkpFile.path + SQLITE_SHMFILE_SUFFIX)
  104.         dbShmFile.delete() /* ADDED for VACUUM BACKUP */
  105.         dbWalFile.delete() /* ADDED for VACUUM BACKUP */
  106.         try {
  107.             bkpFile.copyTo(dbFile, true)
  108.             if (bkpWalFile.exists()) bkpWalFile.copyTo(dbWalFile, true)
  109.             if (bkpShmFile.exists()) bkpShmFile.copyTo(dbShmFile,true)
  110.         } catch (e: IOException) {
  111.             e.printStackTrace()
  112.         }
  113.         if (restart) {
  114.             val i = context.packageManager.getLaunchIntentForPackage(context.packageName)
  115.             i!!.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
  116.             context.startActivity(i)
  117.             System.exit(0)
  118.         }
  119.     }
  120.     fun backupAsCSV() {
  121.         val csvFile = File(instance!!.getOpenHelper().writableDatabase.path + THEDATBASE_DATABASE_BACKUP_CSV_SUFFIX)
  122.         csvFile.delete()
  123.         csvFile.writeText(createAutoCSV())
  124.     }
  125.     fun restoreFromCSV() {
  126.         var db = instance!!.getOpenHelper().writableDatabase
  127.         db.beginTransaction() /* want to run in a single transaction */
  128.         var currentTableName = ""
  129.         val TAG = "CSVRESTORE"
  130.         val csvFile = File(instance!!.getOpenHelper().writableDatabase.path + THEDATBASE_DATABASE_BACKUP_CSV_SUFFIX)
  131.         csvFile.forEachLine {
  132.             /* if Start header then skip */
  133.             if (it.equals(CSV_INDICATOR_START)) {
  134.                 Log.d(TAG,"START INDICATED")
  135.             } else {
  136.                 /* if  end header then skip */
  137.                 if (it.equals(CSV_INDICATOR_END)) {
  138.                     Log.d(TAG, "END INDICATED")
  139.                 } else {
  140.                     /* If table header then delete all rows for the table */
  141.                     if (it.substring(0, CSV_INDICATOR_TABLE.length).equals(CSV_INDICATOR_TABLE)) {
  142.                         currentTableName = it.substring(CSV_INDICATOR_TABLE.length + 1)
  143.                         Log.d("CSVRESTORE","NEW TABLE INDICATED. TableName is $currentTableName")
  144.                         db.execSQL("DELETE FROM $currentTableName")
  145.                         Log.d(TAG,"$currentTableName cleared of data")
  146.                     } else {
  147.                         /* Otherwise it is actual data for a row so insert the data */
  148.                         /* Note replacing the comma replacement string with a comma */
  149.                         Log.d(TAG,"Actual Data is $it")
  150.                         /* split the CSV into individual elements (column data) */
  151.                         val splitdata = it.split(",")
  152.                         var resolvedData: ArrayList<String> = arrayListOf()
  153.                         val sql = StringBuilder().append("INSERT INTO $currentTableName VALUES(")
  154.                         var afterFirstData = false
  155.                         /* For each split element (column) */
  156.                         /* 1. add a ? for parameter binding */
  157.                         /* 2. add the resolved (commas reinstated) values for the parameters */
  158.                         for (s in splitdata) {
  159.                             if (afterFirstData) sql.append(",")
  160.                             afterFirstData = true
  161.                             sql.append("?")
  162.                             resolvedData.add(s.replace(CSV_COMMA_REPLACE,","))
  163.                         }
  164.                         sql.append(");")
  165.                         db.execSQL(sql.toString(),resolvedData.toArray())
  166.                     }
  167.                 }
  168.             }
  169.         }
  170.         db.setTransactionSuccessful()
  171.         db.endTransaction()
  172.     }
  174.     private fun createAutoCSV(): String {
  175.         val replaceCommaInData = CSV_COMMA_REPLACE /* commas in the data will be replaced by this */
  176.         val rv = StringBuilder().append(CSV_INDICATOR_START)
  177.         val sql = StringBuilder()
  178.         var afterFirstTable = false
  179.         var afterFirstColumn = false
  180.         var afterFirstRow = false
  181.         val suppDb = instance!!.getOpenHelper().writableDatabase
  182.         var currentTableName: String = ""
  183.         val csr = instance!!.query(
  184.             "SELECT name FROM sqlite_master " +
  185.                     "WHERE type='table' " +
  186.                     "AND name NOT LIKE('sqlite_%') " +
  187.                     "AND name NOT LIKE('room_%') " +
  188.                     "AND name NOT LIKE('android_%')",
  189.             null
  190.         )
  191.         while (csr.moveToNext()) {
  192.             sql.clear()
  193.             sql.append("SELECT ")
  194.             currentTableName = csr.getString(0)
  195.             //if (afterFirstTable) rv.append("$CSV_NEWLINE")
  196.             afterFirstTable = true
  197.             afterFirstColumn = false
  198.             rv.append(CSV_NEWLINE).append("$CSV_INDICATOR_TABLE,$currentTableName")
  199.             for (columnName in getTableColumnNames(currentTableName,suppDb)) {
  200.                 if (afterFirstColumn) sql.append("||','||")
  201.                 afterFirstColumn = true
  202.                 sql.append("replace(`$columnName`,',','$replaceCommaInData')")
  203.             }
  204.             sql.append(" FROM `${currentTableName}`")
  205.             val csr2 = instance!!.query(sql.toString(),null)
  206.             afterFirstRow = false
  207.             while (csr2.moveToNext()) {
  208.                 //if (!afterFirstRow) rv.append("$CSV_NEWLINE")
  209.                 afterFirstRow = true
  210.                 rv.append(CSV_NEWLINE).append(csr2.getString(0))
  211.             }
  212.         }
  213.         rv.append(CSV_NEWLINE).append("$CSV_INDICATOR_END")
  214.         return rv.toString()
  215.     }
  216.     private fun getTableColumnNames(tableName: String, suppDB: SupportSQLiteDatabase): List<String> {
  217.         val rv = arrayListOf<String>()
  218.         val csr = suppDB.query("SELECT name FROM pragma_table_info('${tableName}')",null)
  219.         while (csr.moveToNext()) {
  220.             rv.add(csr.getString(0))
  221.         }
  222.         csr.close()
  223.         return rv.toList()
  224.     }
  225. }

型

MainActivity（布局应该很容易构建-请参阅lateinit）

  1. class MainActivity : AppCompatActivity() {
  2.     lateinit var db: TheDatabase
  3.     lateinit var dao: AllDAO
  4.     lateinit var backupButton: Button
  5.     lateinit var csvBackupButton: Button
  6.     lateinit var restoreButton: Button
  7.     lateinit var restoreFromCSVButton: Button
  8.     lateinit var addDataButton: Button
  9.     lateinit var listView: ListView
  10.     lateinit var listViewOther: ListView
  11.     var listAdapter: SimpleCursorAdapter? = null
  12.     var listAdapterOther: SimpleCursorAdapter? = null
  14.     override fun onCreate(savedInstanceState: Bundle?) {
  15.         super.onCreate(savedInstanceState)
  16.         setContentView(R.layout.activity_main)
  17.         backupButton = this.findViewById(R.id.backup)
  18.         csvBackupButton = this.findViewById(R.id.csvBackup)
  19.         restoreButton = this.findViewById(R.id.restore)
  20.         restoreFromCSVButton = this.findViewById(R.id.restoreFromCSV)
  21.         addDataButton = this.findViewById(R.id.addData)
  22.         listView = this.findViewById(R.id.datalist)
  23.         listViewOther = this.findViewById(R.id.datalistOther)
  25.         db = TheDatabase.getInstance(this)
  26.         dao = db.getAllDao()
  27.         setButtonListeners()
  28.         setOrRefreshListView()
  29.     }
  31.     fun setButtonListeners() {
  32.         addDataButton.setOnClickListener {
  33.             dao.insert(TheTable(other = "DATA1,_${System.currentTimeMillis()}"))
  34.             dao.insert(TheTable(other = "DATA2_,${System.currentTimeMillis()}"))
  35.             dao.insert(TheTable(other = ",DATA3_${System.currentTimeMillis()}"))
  36.             /*******************************************************************************************************/
  37.             /* Note for CSV backup/restore BLOBS are NOT handled properly (that would entail even more complexity) */
  38.             /*******************************************************************************************************/
  39.             dao.insert(
  40.                 TheOtherTable(
  41.                     other = "OTHERDATA1_${System.currentTimeMillis() / 1000},",
  42.                     another = ",${System.currentTimeMillis()},",
  43.                     yetanother = byteArrayOf(0,0,0,0,0)
  44.                 )
  45.             )
  46.             dao.insert(
  47.                 TheOtherTable(
  48.                     other = "OTHERDATA2_${System.currentTimeMillis() / 1000},",
  49.                     another = "${System.currentTimeMillis()}")
  50.             )
  51.             dao.insert(
  52.                 TheOtherTable(
  53.                     other = "OTHER,DATA3_${System.currentTimeMillis() / 1000}",
  54.                     another = "${System.currentTimeMillis()}",
  55.                     yetanother = byteArrayOf(0x00,0x10,0x20,0x30,0x40,0x50,0x60,0x70))
  56.             )
  57.             dao.insert(
  58.                 TheOtherTable(other = "OTHERDATA,4_${System.currentTimeMillis() / 1000}",
  59.                     another = "${System.currentTimeMillis()}")
  60.             )
  61.             setOrRefreshListView()
  62.         }
  63.         backupButton.setOnClickListener {
  64.             db.backupDatabase(this)
  65.         }
  66.         csvBackupButton.setOnClickListener {
  67.             db.backupAsCSV()
  68.         }
  69.         restoreButton.setOnClickListener {
  70.             db.restoreDatabase(this)
  71.             setOrRefreshListView()
  72.         }
  73.         restoreFromCSVButton.setOnClickListener {
  74.             db.restoreFromCSV()
  75.             setOrRefreshListView()
  76.         }
  77.     }
  79.     /* initialise or refresh the 2 ListViews */
  80.     private fun setOrRefreshListView() {
  81.         var csr = db.getOpenHelper().writableDatabase.query("SELECT $THETABLE_ID_COLUMN AS ${BaseColumns._ID}, $THETABLE_OTHER_COLUMN FROM $THETABLE_TABLENAME")
  82.         if (listAdapter==null) {
  83.             listAdapter = SimpleCursorAdapter(
  84.                 this,
  85.                 android.R.layout.simple_list_item_2,
  86.                 csr,
  87.                 arrayOf("_id", THETABLE_OTHER_COLUMN),
  88.                 intArrayOf(android.R.id.text1,android.R.id.text2), 0
  89.             )
  90.             listView.adapter = listAdapter
  91.         } else {
  92.             listAdapter!!.swapCursor(csr)
  93.         }
  94.         var csr2 = db.getOpenHelper().writableDatabase.query("SELECT $THEOTHERTABLE_ID_COLUMN AS ${BaseColumns._ID}, $THEOTHERTABLE_OTHER_COLUMN, $THEOTHERTABLE_ANOTHER_COLUMN FROM $THEOTHERTABLE_TABLENAME;")
  95.         if (listAdapterOther==null) {
  96.             listAdapterOther = SimpleCursorAdapter(
  97.                 this,
  98.                 android.R.layout.simple_list_item_2,
  99.                 csr2,
  100.                 arrayOf(THEOTHERTABLE_OTHER_COLUMN, THEOTHERTABLE_ANOTHER_COLUMN),
  101.                 intArrayOf(android.R.id.text1,android.R.id.text2),
  102.                 0
  103.             )
  104.             listViewOther.adapter = listAdapterOther
  105.         } else {
  106.             listAdapterOther!!.swapCursor(csr2)
  107.         }
  108.     }
  109. }

型
单击一次【添加数据】（第一个表3行，第二个表4行），然后单击【备份】和【CSV备份】按钮后运行。
x1c 0d1x的数据
然后再次点击【添加数据】按钮，在备份后添加一些数据。


的
然后点击【CSV恢复】按钮


的
再次单击一次或多次“添加数据”，然后单击“恢复”按钮（从文件备份恢复）


的

  • 因此返回到原始数据，注意应用程序已重新启动。
展开查看全部
赞(0）分享  回复(0）举报  2023-08-07
fruv7luv

fruv7luv3#

1.运行应用程序
1.在应用程序中执行操作以创建数据库，并填充所需的数据

  1. Android Studio >设备文件资源管理器


的数据
1.在下拉菜单中，选择具有要导出的数据库的设备。对我来说就是这个模拟器


的
1.导航到data/data/your.app.package.name/databases
1.右键单击DB文件>保存为


的

展开查看全部
赞(0）分享  回复(0）举报  2023-08-07
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com