Android
SQLite
サーチ…
前書き
SQLiteはC言語で書かれたリレーショナルデータベース管理システムです。 Androidフレームワーク内でSQLiteデータベースを操作するには、 SQLiteOpenHelperを継承するクラスを定義し、必要に応じてカスタマイズします。
備考
SQLiteOpenHelperクラスは、static onCreate()およびonUpgrade()メソッドを定義します。これらのメソッドは、独自のテーブルでカスタマイズするSQLiteOpenHelperサブクラスの対応するメソッドで呼び出されます。
SQLiteOpenHelperクラスの使用
public class DatabaseHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "Example.db";
private static final int DATABASE_VERSION = 3;
// For all Primary Keys _id should be used as column name
public static final String COLUMN_ID = "_id";
// Definition of table and column names of Products table
public static final String TABLE_PRODUCTS = "Products";
public static final String COLUMN_NAME = "Name";
public static final String COLUMN_DESCRIPTION = "Description";
public static final String COLUMN_VALUE = "Value";
// Definition of table and column names of Transactions table
public static final String TABLE_TRANSACTIONS = "Transactions";
public static final String COLUMN_PRODUCT_ID = "ProductId";
public static final String COLUMN_AMOUNT = "Amount";
// Create Statement for Products Table
private static final String CREATE_TABLE_PRODUCT = "CREATE TABLE " + TABLE_PRODUCTS + " (" +
COLUMN_ID + " INTEGER PRIMARY KEY, " +
COLUMN_DESCRIPTION + " TEXT, " +
COLUMN_NAME + " TEXT, " +
COLUMN_VALUE + " REAL" +
");";
// Create Statement for Transactions Table
private static final String CREATE_TABLE_TRANSACTION = "CREATE TABLE " + TABLE_TRANSACTIONS + " (" +
COLUMN_ID + " INTEGER PRIMARY KEY," +
COLUMN_PRODUCT_ID + " INTEGER," +
COLUMN_AMOUNT + " INTEGER," +
" FOREIGN KEY (" + COLUMN_PRODUCT_ID + ") REFERENCES " + TABLE_PRODUCTS + "(" + COLUMN_ID + ")" +
");";
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
// onCreate should always create your most up to date database
// This method is called when the app is newly installed
db.execSQL(CREATE_TABLE_PRODUCT);
db.execSQL(CREATE_TABLE_TRANSACTION);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// onUpgrade is responsible for upgrading the database when you make
// changes to the schema. For each version the specific changes you made
// in that version have to be applied.
for (int version = oldVersion + 1; version <= newVersion; version++) {
switch (version) {
case 2:
db.execSQL("ALTER TABLE " + TABLE_PRODUCTS + " ADD COLUMN " + COLUMN_DESCRIPTION + " TEXT;");
break;
case 3:
db.execSQL(CREATE_TABLE_TRANSACTION);
break;
}
}
}
}
データをデータベースに挿入する
// You need a writable database to insert data
final SQLiteDatabase database = openHelper.getWritableDatabase();
// Create a ContentValues instance which contains the data for each column
// You do not need to specify a value for the PRIMARY KEY column.
// Unique values for these are automatically generated.
final ContentValues values = new ContentValues();
values.put(COLUMN_NAME, model.getName());
values.put(COLUMN_DESCRIPTION, model.getDescription());
values.put(COLUMN_VALUE, model.getValue());
// This call performs the update
// The return value is the rowId or primary key value for the new row!
// If this method returns -1 then the insert has failed.
final int id = database.insert(
TABLE_NAME, // The table name in which the data will be inserted
null, // String: optional; may be null. If your provided values is empty,
// no column names are known and an empty row can't be inserted.
// If not set to null, this parameter provides the name
// of nullable column name to explicitly insert a NULL
values // The ContentValues instance which contains the data
);
onUpgrade（）メソッド
SQLiteOpenHelperは、データベースの作成とバージョン管理を管理するヘルパークラスです。
このクラスでは、スキーマを変更するときにonUpgrade()メソッドがデータベースのアップグレードを行います。これは、データベースファイルがすでに存在するが、そのバージョンがアプリケーションの現在のバージョンで指定されているバージョンよりも低い場合に呼び出されます。データベースのバージョンごとに、変更内容を適用する必要があります。
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// Loop through each version when an upgrade occurs.
for (int version = oldVersion + 1; version <= newVersion; version++) {
switch (version) {
case 2:
// Apply changes made in version 2
db.execSQL(
"ALTER TABLE " +
TABLE_PRODUCTS +
" ADD COLUMN " +
COLUMN_DESCRIPTION +
" TEXT;"
);
break;
case 3:
// Apply changes made in version 3
db.execSQL(CREATE_TABLE_TRANSACTION);
break;
}
}
}
カーソルからのデータの読み取り
次に、 SQLiteOpenHelperサブクラス内に存在するメソッドの例を示します。これは、 searchTerm Stringを使用して結果をフィルタリングし、Cursorの内容を反復処理し、その内容をProduct ObjectsのListに返します。
まず、データベースから取得した各行のコンテナになるProduct POJOクラスを定義します。
public class Product {
long mId;
String mName;
String mDescription;
float mValue;
public Product(long id, String name, String description, float value) {
mId = id;
mName = name;
mDescription = description;
mValue = value;
}
}
次に、データベースを照会するメソッドを定義し、 Product ObjectsのListを返します。
public List<Product> searchForProducts(String searchTerm) {
// When reading data one should always just get a readable database.
final SQLiteDatabase database = this.getReadableDatabase();
final Cursor cursor = database.query(
// Name of the table to read from
TABLE_NAME,
// String array of the columns which are supposed to be read
new String[]{COLUMN_NAME, COLUMN_DESCRIPTION, COLUMN_VALUE},
// The selection argument which specifies which row is read.
// ? symbols are parameters.
COLUMN_NAME + " LIKE ?",
// The actual parameters values for the selection as a String array.
// ? above take the value from here
new String[]{"%" + searchTerm + "%"},
// GroupBy clause. Specify a column name to group similar values
// in that column together.
null,
// Having clause. When using the GroupBy clause this allows you to
// specify which groups to include.
null,
// OrderBy clause. Specify a column name here to order the results
// according to that column. Optionally append ASC or DESC to specify
// an ascending or descending order.
null
);
// To increase performance first get the index of each column in the cursor
final int idIndex = cursor.getColumnIndex(COLUMN_ID);
final int nameIndex = cursor.getColumnIndex(COLUMN_NAME);
final int descriptionIndex = cursor.getColumnIndex(COLUMN_DESCRIPTION);
final int valueIndex = cursor.getColumnIndex(COLUMN_VALUE);
try {
// If moveToFirst() returns false then cursor is empty
if (!cursor.moveToFirst()) {
return new ArrayList<>();
}
final List<Product> products = new ArrayList<>();
do {
// Read the values of a row in the table using the indexes acquired above
final long id = cursor.getLong(idIndex);
final String name = cursor.getString(nameIndex);
final String description = cursor.getString(descriptionIndex);
final float value = cursor.getFloat(valueIndex);
products.add(new Product(id, name, description, value));
} while (cursor.moveToNext());
return products;
} finally {
// Don't forget to close the Cursor once you are done to avoid memory leaks.
// Using a try/finally like in this example is usually the best way to handle this
cursor.close();
// close the database
database.close();
}
}
AndroidでSQLiteの契約、ヘルパー、プロバイダを作成する
DBContract.java
//Define the tables and columns of your local database
public final class DBContract {
/*Content Authority its a name for the content provider, is convenient to use the package app name to be unique on the device */
public static final String CONTENT_AUTHORITY = "com.yourdomain.yourapp";
//Use CONTENT_AUTHORITY to create all the database URI's that the app will use to link the content provider.
public static final Uri BASE_CONTENT_URI = Uri.parse("content://" + CONTENT_AUTHORITY);
/*the name of the uri that can be the same as the name of your table.
this will translate to content://com.yourdomain.yourapp/user/ as a valid URI
*/
public static final String PATH_USER = "User";
// To prevent someone from accidentally instantiating the contract class,
// give it an empty constructor.
public DBContract () {}
//Intern class that defines the user table
public static final class UserEntry implements BaseColumns {
public static final URI CONTENT_URI = BASE_CONTENT_URI.buildUpon().appendPath(PATH_USER).build();
public static final String CONTENT_TYPE = ContentResolver.CURSOR_DIR_BASE_TYPE+"/"+CONTENT_AUTHORITY+"/"+PATH_USER;
//Name of the table
public static final String TABLE_NAME="User";
//Columns of the user table
public static final String COLUMN_Name="Name";
public static final String COLUMN_Password="Password";
public static Uri buildUri(long id){
return ContentUris.withAppendedId(CONTENT_URI,id);
}
}
DBHelper.java
public class DBHelper extends SQLiteOpenHelper{
//if you change the schema of the database, you must increment this number
private static final int DATABASE_VERSION=1;
static final String DATABASE_NAME="mydatabase.db";
private static DBHelper mInstance=null;
public static DBHelper getInstance(Context ctx){
if(mInstance==null){
mInstance= new DBHelper(ctx.getApplicationContext());
}
return mInstance;
}
public DBHelper(Context context){
super(context,DATABASE_NAME,null,DATABASE_VERSION);
}
public int GetDatabase_Version() {
return DATABASE_VERSION;
}
@Override
public void onCreate(SQLiteDatabase sqLiteDatabase){
//Create the table users
final String SQL_CREATE_TABLE_USERS="CREATE TABLE "+UserEntry.TABLE_NAME+ " ("+
UserEntry._ID+" INTEGER PRIMARY KEY, "+
UserEntry.COLUMN_Name+" TEXT , "+
UserEntry.COLUMN_Password+" TEXT "+
" ); ";
sqLiteDatabase.execSQL(SQL_CREATE_TABLE_USERS);
}
@Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + UserEntry.TABLE_NAME);
}
}
DBProvider.java
public class DBProvider extends ContentProvider {
private static final UriMatcher sUriMatcher = buildUriMatcher();
private DBHelper mDBHelper;
private Context mContext;
static final int USER = 100;
static UriMatcher buildUriMatcher() {
final UriMatcher matcher = new UriMatcher(UriMatcher.NO_MATCH);
final String authority = DBContract.CONTENT_AUTHORITY;
matcher.addURI(authority, DBContract.PATH_USER, USER);
return matcher;
}
@Override
public boolean onCreate() {
mDBHelper = new DBHelper(getContext());
return false;
}
public PeaberryProvider(Context context) {
mDBHelper = DBHelper.getInstance(context);
mContext = context;
}
@Override
public String getType(Uri uri) {
// determine what type of Uri is
final int match = sUriMatcher.match(uri);
switch (match) {
case USER:
return DBContract.UserEntry.CONTENT_TYPE;
default:
throw new UnsupportedOperationException("Uri unknown: " + uri);
}
}
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
Cursor retCursor;
try {
switch (sUriMatcher.match(uri)) {
case USER: {
retCursor = mDBHelper.getReadableDatabase().query(
DBContract.UserEntry.TABLE_NAME,
projection,
selection,
selectionArgs,
null,
null,
sortOrder
);
break;
}
default:
throw new UnsupportedOperationException("Uri unknown: " + uri);
}
} catch (Exception ex) {
Log.e("Cursor", ex.toString());
} finally {
mDBHelper.close();
}
return null;
}
@Override
public Uri insert(Uri uri, ContentValues values) {
final SQLiteDatabase db = mDBHelper.getWritableDatabase();
final int match = sUriMatcher.match(uri);
Uri returnUri;
try {
switch (match) {
case USER: {
long _id = db.insert(DBContract.UserEntry.TABLE_NAME, null, values);
if (_id > 0)
returnUri = DBContract.UserEntry.buildUri(_id);
else
throw new android.database.SQLException("Error at inserting row in " + uri);
break;
}
default:
throw new UnsupportedOperationException("Uri unknown: " + uri);
}
mContext.getContentResolver().notifyChange(uri, null);
return returnUri;
} catch (Exception ex) {
Log.e("Insert", ex.toString());
db.close();
} finally {
db.close();
}
return null;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
final SQLiteDatabase db = DBHelper.getWritableDatabase();
final int match = sUriMatcher.match(uri);
int deletedRows;
if (null == selection) selection = "1";
try {
switch (match) {
case USER:
deletedRows = db.delete(
DBContract.UserEntry.TABLE_NAME, selection, selectionArgs);
break;
default:
throw new UnsupportedOperationException("Uri unknown: " + uri);
}
if (deletedRows != 0) {
mContext.getContentResolver().notifyChange(uri, null);
}
return deletedRows;
} catch (Exception ex) {
Log.e("Insert", ex.toString());
} finally {
db.close();
}
return 0;
}
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
final SQLiteDatabase db = mDBHelper.getWritableDatabase();
final int match = sUriMatcher.match(uri);
int updatedRows;
try {
switch (match) {
case USER:
updatedRows = db.update(DBContract.UserEntry.TABLE_NAME, values, selection, selectionArgs);
break;
default:
throw new UnsupportedOperationException("Uri unknown: " + uri);
}
if (updatedRows != 0) {
mContext.getContentResolver().notifyChange(uri, null);
}
return updatedRows;
} catch (Exception ex) {
Log.e("Update", ex.toString());
} finally {
db.close();
}
return -1;
}
}
使い方：
public void InsertUser() {
try {
ContentValues userValues = getUserData("Jhon","XXXXX");
DBProvider dbProvider = new DBProvider(mContext);
dbProvider.insert(UserEntry.CONTENT_URI, userValues);
} catch (Exception ex) {
Log.e("Insert", ex.toString());
}
}
public ContentValues getUserData(String name, String pass) {
ContentValues userValues = new ContentValues();
userValues.put(UserEntry.COLUMN_Name, name);
userValues.put(UserEntry.COLUMN_Password, pass);
return userValues;
}
テーブル内の行の更新
// You need a writable database to update a row
final SQLiteDatabase database = openHelper.getWritableDatabase();
// Create a ContentValues instance which contains the up to date data for each column
// Unlike when inserting data you need to specify the value for the PRIMARY KEY column as well
final ContentValues values = new ContentValues();
values.put(COLUMN_ID, model.getId());
values.put(COLUMN_NAME, model.getName());
values.put(COLUMN_DESCRIPTION, model.getDescription());
values.put(COLUMN_VALUE, model.getValue());
// This call performs the update
// The return value tells you how many rows have been updated.
final int count = database.update(
TABLE_NAME, // The table name in which the data will be updated
values, // The ContentValues instance with the new data
COLUMN_ID + " = ?", // The selection which specifies which row is updated. ? symbols are parameters.
new String[] { // The actual parameters for the selection as a String[].
String.valueOf(model.getId())
}
);
トランザクションの実行
トランザクションを使用して、データベースに対して複数の変更をアトミックに行うことができます。通常のトランザクションはこのパターンに従います。
// You need a writable database to perform transactions
final SQLiteDatabase database = openHelper.getWritableDatabase();
// This call starts a transaction
database.beginTransaction();
// Using try/finally is essential to reliably end transactions even
// if exceptions or other problems occur.
try {
// Here you can make modifications to the database
database.insert(TABLE_CARS, null, productValues);
database.update(TABLE_BUILDINGS, buildingValues, COLUMN_ID + " = ?", new String[] { String.valueOf(buildingId) });
// This call marks a transaction as successful.
// This causes the changes to be written to the database once the transaction ends.
database.setTransactionSuccessful();
} finally {
// This call ends a transaction.
// If setTransactionSuccessful() has not been called then all changes
// will be rolled back and the database will not be modified.
database.endTransaction();
}
アクティブなトランザクション内でbeginTransaction()呼び出しても効果はありません。
テーブルから行を削除する
テーブルからすべての行を削除するには
//get writable database
SQLiteDatabase db = openHelper.getWritableDatabase();
db.delete(TABLE_NAME, null, null);
db.close();
テーブルからすべての行を削除し、削除された行のカウントを戻り値で取得するには
//get writable database
SQLiteDatabase db = openHelper.getWritableDatabase();
int numRowsDeleted = db.delete(TABLE_NAME, String.valueOf(1), null);
db.close();
WHERE条件で行を削除するには
//get writable database
SQLiteDatabase db = openHelper.getWritableDatabase();
String whereClause = KEY_NAME + " = ?";
String[] whereArgs = new String[]{String.valueOf(KEY_VALUE)};
//for multiple condition, join them with AND
//String whereClause = KEY_NAME1 + " = ? AND " + KEY_NAME2 + " = ?";
//String[] whereArgs = new String[]{String.valueOf(KEY_VALUE1), String.valueOf(KEY_VALUE2)};
int numRowsDeleted = db.delete(TABLE_NAME, whereClause, whereArgs);
db.close();
SQLiteに画像を保存する
データベースの設定
public class DatabaseHelper extends SQLiteOpenHelper {
// Database Version
private static final int DATABASE_VERSION = 1;
// Database Name
private static final String DATABASE_NAME = "database_name";
// Table Names
private static final String DB_TABLE = "table_image";
// column names
private static final String KEY_NAME = "image_name";
private static final String KEY_IMAGE = "image_data";
// Table create statement
private static final String CREATE_TABLE_IMAGE = "CREATE TABLE " + DB_TABLE + "("+
KEY_NAME + " TEXT," +
KEY_IMAGE + " BLOB);";
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
// creating table
db.execSQL(CREATE_TABLE_IMAGE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// on upgrade drop older tables
db.execSQL("DROP TABLE IF EXISTS " + DB_TABLE);
// create new table
onCreate(db);
}
}
データベースに挿入する：
public void addEntry( String name, byte[] image) throws SQLiteException{
SQLiteDatabase database = this.getWritableDatabase();
ContentValues cv = new ContentValues();
cv.put(KEY_NAME, name);
cv.put(KEY_IMAGE, image);
database.insert( DB_TABLE, null, cv );
}
データの取得 ：
byte[] image = cursor.getBlob(1);
注意：
- データベースに挿入する前に、ビットマップイメージをバイト配列に変換してから、データベースクエリを使用して適用する必要があります。
- データベースから検索するときは、確かにバイト配列のイメージがあります。バイト配列を元のイメージに戻すことが必要です。したがって、デコードするにはBitmapFactoryを使用する必要があります。
以下は私があなたに役立つことを望むユーティリティクラスです：
public class DbBitmapUtility {
// convert from bitmap to byte array
public static byte[] getBytes(Bitmap bitmap) {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(CompressFormat.PNG, 0, stream);
return stream.toByteArray();
}
// convert from byte array to bitmap
public static Bitmap getImage(byte[] image) {
return BitmapFactory.decodeByteArray(image, 0, image.length);
}
}
資産フォルダからデータベースを作成する
dbname.sqliteまたはdbname.dbファイルをプロジェクトのassetsフォルダに配置します。
public class Databasehelper extends SQLiteOpenHelper {
public static final String TAG = Databasehelper.class.getSimpleName();
public static int flag;
// Exact Name of you db file that you put in assets folder with extension.
static String DB_NAME = "dbname.sqlite";
private final Context myContext;
String outFileName = "";
private String DB_PATH;
private SQLiteDatabase db;
public Databasehelper(Context context) {
super(context, DB_NAME, null, 1);
this.myContext = context;
ContextWrapper cw = new ContextWrapper(context);
DB_PATH = cw.getFilesDir().getAbsolutePath() + "/databases/";
Log.e(TAG, "Databasehelper: DB_PATH " + DB_PATH);
outFileName = DB_PATH + DB_NAME;
File file = new File(DB_PATH);
Log.e(TAG, "Databasehelper: " + file.exists());
if (!file.exists()) {
file.mkdir();
}
}
/**
* 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
} 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");
}
}
}
/**
* Check if the database already exist to avoid re-copying the file each time you open the application.
*
* @return true if it exists, false if it doesn't
*/
private boolean checkDataBase() {
SQLiteDatabase checkDB = null;
try {
checkDB = SQLiteDatabase.openDatabase(outFileName, null, SQLiteDatabase.OPEN_READWRITE);
} catch (SQLiteException e) {
try {
copyDataBase();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (checkDB != null) {
checkDB.close();
}
return checkDB != null ? true : false;
}
/**
* Copies your database from your local assets-folder to the just created empty database in the
* system folder, from where it can be accessed and handled.
* This is done by transfering bytestream.
*/
private void copyDataBase() throws IOException {
Log.i("Database",
"New database is being copied to device!");
byte[] buffer = new byte[1024];
OutputStream myOutput = null;
int length;
// Open your local db as the input stream
InputStream myInput = null;
try {
myInput = myContext.getAssets().open(DB_NAME);
// transfer bytes from the inputfile to the
// outputfile
myOutput = new FileOutputStream(DB_PATH + DB_NAME);
while ((length = myInput.read(buffer)) > 0) {
myOutput.write(buffer, 0, length);
}
myOutput.close();
myOutput.flush();
myInput.close();
Log.i("Database",
"New database has been copied to device!");
} catch (IOException e) {
e.printStackTrace();
}
}
public void openDataBase() throws SQLException {
//Open the database
String myPath = DB_PATH + DB_NAME;
db = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
Log.e(TAG, "openDataBase: Open " + db.isOpen());
}
@Override
public synchronized void close() {
if (db != null)
db.close();
super.close();
}
public void onCreate(SQLiteDatabase arg0) {
}
@Override
public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) {
}
}
ここであなたの活動にデータベースオブジェクトにアクセスする方法です。
// Create Databasehelper class object in your activity.
private Databasehelper db;
次にonCreateメソッドでそれを初期化し、以下のようにcreateDatabase（）メソッドを呼び出します。
db = new Databasehelper(MainActivity.this);
try {
db.createDataBase();
} catch (Exception e) {
e.printStackTrace();
}
以下のように、挿入、更新、削除、および選択操作をすべて実行します。
String query = "select Max(Id) as Id from " + TABLE_NAME;
db.openDataBase();
int count = db.getId(query);
db.close();
データベースのエクスポートとインポート
たとえば、bacukupsのためにデータベースをインポートおよびエクスポートすることができます。権限について忘れてはいけません。
public void exportDatabase(){
try
{
File sd = Environment.getExternalStorageDirectory();
File data = Environment.getDataDirectory();
String currentDBPath = "//data//MY.PACKAGE.NAME//databases//MY_DATABASE_NAME";
String backupDBPath = "MY_DATABASE_FILE.db";
File currentDB = new File(data, currentDBPath);
File backupDB = new File(sd, backupDBPath);
FileChannel src = new FileInputStream(currentDB).getChannel();
FileChannel dst = new FileOutputStream(backupDB).getChannel();
dst.transferFrom(src, 0, src.size());
src.close();
dst.close();
Toast.makeText(c, c.getResources().getString(R.string.exporterenToast), Toast.LENGTH_SHORT).show();
}
catch (Exception e) {
Toast.makeText(c, c.getResources().getString(R.string.portError), Toast.LENGTH_SHORT).show();
Log.d("Main", e.toString());
}
}
public void importDatabase(){
try
{
File sd = Environment.getExternalStorageDirectory();
File data = Environment.getDataDirectory();
String currentDBPath = "//data//" + "MY.PACKAGE.NAME" + "//databases//" + "MY_DATABASE_NAME";
String backupDBPath = "MY_DATABASE_FILE.db";
File backupDB = new File(data, currentDBPath);
File currentDB = new File(sd, backupDBPath);
FileChannel src = new FileInputStream(currentDB).getChannel();
FileChannel dst = new FileOutputStream(backupDB).getChannel();
dst.transferFrom(src, 0, src.size());
src.close();
dst.close();
Toast.makeText(c, c.getResources().getString(R.string.importerenToast), Toast.LENGTH_LONG).show();
}
catch (Exception e) {
Toast.makeText(c, c.getResources().getString(R.string.portError), Toast.LENGTH_SHORT).show();
}
}
一括挿入
大量のデータを一度に挿入する例を示します。挿入するすべてのデータは、ContentValues配列の内部に集められます。
@Override
public int bulkInsert(Uri uri, ContentValues[] values) {
int count = 0;
String table = null;
int uriType = IChatContract.MessageColumns.uriMatcher.match(uri);
switch (uriType) {
case IChatContract.MessageColumns.MESSAGES:
table = IChatContract.MessageColumns.TABLE_NAME;
break;
}
mDatabase.beginTransaction();
try {
for (ContentValues cv : values) {
long rowID = mDatabase.insert(table, " ", cv);
if (rowID <= 0) {
throw new SQLException("Failed to insert row into " + uri);
}
}
mDatabase.setTransactionSuccessful();
getContext().getContentResolver().notifyChange(uri, null);
count = values.length;
} finally {
mDatabase.endTransaction();
}
return count;
}
次に、その使用方法の例を示します。
ContentResolver resolver = mContext.getContentResolver();
ContentValues[] valueList = new ContentValues[object.size()];
//add whatever you like to the valueList
resolver.bulkInsert(IChatContract.MessageColumns.CONTENT_URI, valueList);
Modified text is an extract of the original Stack Overflow Documentation
ライセンスを受けた CC BY-SA 3.0
所属していない Stack Overflow