android - यवस - एक डेटाबेस के साथ एक आवेदन जहाज




संबंधपरक डेटाबेस प्रबंधन प्रणाली (11)

Shipping the app with a database file, in Android Studio 3.0

Shipping the app with a database file is a good idea for me. The advantage is that you don't need to do a complex initialization, which sometimes costs lots of time, if your data set is huge.

Step 1: Prepare database file

Have your database file ready. It can be either a .db file or a .sqlite file. If you use a .sqlite file, all you need to do is to change file extension names. The steps are the same.

In this example, I prepared a file called testDB.db. It has one table and some sample data in it like this

Step 2: Import the file into your project

Create the assets folder if you haven't had one. Then copy and paste the database file into this folder

Step 3: Copy the file to the app's data folder

You need to copy the database file to the app's data folder in order to do further interaction with it. This is a one time action (initialization) to copy the database file. If you call this code multiple times, the database file in data folder will be overwritten by the one in assets folder. This overwrite process is useful when you want to update the database in future during the app update.

Note that during app update, this database file will not be changed in the app's data folder. Only uninstall will delete it.

The database file needs to be copied to /databases folder. Open Device File Explorer. Enter data/data/<YourAppName>/ location. This is the app's default data folder mentioned above. And by default, the database file will be place in another folder called databases under this directory

Now, the copy file process is pretty much like the what Java is doing. Use the following code to do the copy paste. This is the initiation code. It can also be used to update(by overwriting) the database file in future.

//get context by calling "this" in activity or getActivity() in fragment
//call this if API level is lower than 17  String appDataPath = "/data/data/" + context.getPackageName() + "/databases/"
String appDataPath = context.getApplicationInfo().dataDir;

File dbFolder = new File(appDataPath + "/databases");//Make sure the /databases folder exists
dbFolder.mkdir();//This can be called multiple times.

File dbFilePath = new File(appDataPath + "/databases/testDB.db");

try {
    InputStream inputStream = context.getAssets().open("testDB.db");
    OutputStream outputStream = new FileOutputStream(dbFilePath);
    byte[] buffer = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer))>0)
    {
        outputStream.write(buffer, 0, length);
    }
    outputStream.flush();
    outputStream.close();
    inputStream.close();
} catch (IOException e){
    //handle
}

Then refresh the folder to verify the copy process

Step 4: Create database open helper

Create a subclass for SQLiteOpenHelper , with connect, close, path, etc. I named it DatabaseOpenHelper

import android.content.Context;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DatabaseOpenHelper extends SQLiteOpenHelper {
    public static final String DB_NAME = "testDB.db";
    public static final String DB_SUB_PATH = "/databases/" + DB_NAME;
    private static String APP_DATA_PATH = "";
    private SQLiteDatabase dataBase;
    private final Context context;

    public DatabaseOpenHelper(Context context){
        super(context, DB_NAME, null, 1);
        APP_DATA_PATH = context.getApplicationInfo().dataDir;
        this.context = context;
    }

    public boolean openDataBase() throws SQLException{
        String mPath = APP_DATA_PATH + DB_SUB_PATH;
        //Note that this method assumes that the db file is already copied in place
        dataBase = SQLiteDatabase.openDatabase(mPath, null, SQLiteDatabase.OPEN_READWRITE);
        return dataBase != null;
    }

    @Override
    public synchronized void close(){
        if(dataBase != null) {dataBase.close();}
        super.close();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }
}

Step 5: Create top level class to interact with the database

This will be the class that read & write your database file. Also there is a sample query to print out the value in the database.

import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

public class Database {
    private final Context context;
    private SQLiteDatabase database;
    private DatabaseOpenHelper dbHelper;

    public Database(Context context){
        this.context = context;
        dbHelper = new DatabaseOpenHelper(context);
    }

    public Database open() throws SQLException
    {
        dbHelper.openDataBase();
        dbHelper.close();
        database = dbHelper.getReadableDatabase();
        return this;
    }

    public void close()
    {
        dbHelper.close();
    }

    public void test(){
        try{
            String query ="SELECT value FROM test1";
            Cursor cursor = database.rawQuery(query, null);
            if (cursor.moveToFirst()){
                do{
                    String value = cursor.getString(0);
                    Log.d("db", value);
                }while (cursor.moveToNext());
            }
            cursor.close();
        } catch (SQLException e) {
            //handle
        }
    }
}

Step 6: Test running

Test the code by running the following lines of codes.

Database db = new Database(context);
db.open();
db.test();
db.close();

Hit the run button and cheer!

यदि आपके एप्लिकेशन को डेटाबेस की आवश्यकता है और यह डेटा में निर्मित के साथ आता है, तो उस एप्लिकेशन को शिप करने का सबसे अच्छा तरीका क्या है? क्या मैं:

  1. SQLite डेटाबेस को कम करें और इसे .apk में शामिल करें?

  2. एप्लिकेशन के साथ SQL कमांड शामिल करें और इसे डेटाबेस बनाएं और पहले उपयोग पर डेटा डालें?

मुझे जो दोष दिखता है वह हैं:

  1. संभावित SQLite संस्करण विसंगति समस्याएं पैदा कर सकती है और वर्तमान में मुझे नहीं पता कि डेटाबेस कहां जाना चाहिए और इसे कैसे पहुंचाया जाए।

  2. डिवाइस पर डेटाबेस बनाने और पॉप्युलेट करने में काफी समय लग सकता है।

कोई सुझाव? किसी भी मुद्दे के बारे में दस्तावेज के लिए पॉइंटर्स की सराहना की जाएगी।


SQLiteAssetHelper लाइब्रेरी यह कार्य वास्तव में सरल बनाता है।

एक ग्रेबल निर्भरता के रूप में जोड़ना आसान है (लेकिन एक जार एंट / ग्रहण के लिए भी उपलब्ध है), और दस्तावेज़ीकरण के साथ यह यहां पाया जा सकता है:
github.com/jgilfelt/android-sqlite-asset-helper

दस्तावेज़ीकरण में समझाया गया है:

  1. अपने मॉड्यूल की ग्रेडल बिल्ड फ़ाइल पर निर्भरता जोड़ें:

    dependencies {
        compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+'
    }
    
  2. assets/databases नामक उपनिर्देशिका में डेटाबेस को संपत्ति निर्देशिका में कॉपी assets/databases । उदाहरण के लिए:
    assets/databases/my_database.db

    (वैकल्पिक रूप से, आप एक ज़िप फ़ाइल में डेटाबेस को संपीड़ित कर सकते हैं जैसे कि assets/databases/my_database.zip । इसकी आवश्यकता नहीं है, क्योंकि assets/databases/my_database.zip पहले से ही संपीड़ित है।)

  3. एक वर्ग बनाएं, उदाहरण के लिए:

    public class MyDatabase extends SQLiteAssetHelper {
    
        private static final String DATABASE_NAME = "my_database.db";
        private static final int DATABASE_VERSION = 1;
    
        public MyDatabase(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
        }
    }
    

मुझे लगता है कि आज तक सबसे अच्छा और नवीनतम तरीका SQLiteAssetHelper क्लास का उपयोग कर SQLiteAssetHelper

यह ट्यूटोरियल एंड्रॉइड में बाहरी डेटाबेस आयात और उपयोग के माध्यम से आपको पूरी तरह गाइड करता है

एंड्रॉइड SQLiteAssetHelper लाइब्रेरी आपको अपने डेस्कटॉप कंप्यूटर में अपना SQLite डेटाबेस बनाने और अपने एंड्रॉइड एप्लिकेशन में आयात करने और उपयोग करने की अनुमति देती है। आइए इस लाइब्रेरी के एप्लिकेशन को प्रदर्शित करने के लिए एक सरल एप्लिकेशन बनाएं।

चरण 1 : अपने पसंदीदा SQLite डेटाबेस एप्लिकेशन का उपयोग कर डेटाबेस quotes.db बनाएं (SQLite के लिए डीबी ब्राउज़र एक पोर्टेबल क्रॉस प्लेटफ़ॉर्म फ्रीवेयर है, जिसे SQLite डेटाबेस बनाने और संपादित करने के लिए उपयोग किया जा सकता है)। एक कॉलम 'उद्धरण' के साथ एक तालिका 'उद्धरण' बनाएं। तालिका 'उद्धरण' में कुछ यादृच्छिक उद्धरण डालें।

चरण 2 : डेटाबेस को या तो सीधे या जैसा संकुचित फ़ाइल के रूप में प्रोजेक्ट में आयात किया जा सकता है। संपीड़ित फ़ाइल की अनुशंसा की जाती है, यदि आपका डेटाबेस आकार में बहुत बड़ा है। आप या तो एक ZIP संपीड़न या एक GZ संपीड़न बना सकते हैं।

यदि आप quotes.db.gz संपीड़न का उपयोग कर रहे हैं, तो आप संपीड़ित डीबी फ़ाइल का फ़ाइल नाम quotes.db.zip होना चाहिए, यदि आप ज़िप संपीड़न या quotes.db.gz का उपयोग कर रहे हैं।

चरण 3 : पैकेज नाम के साथ एक नया एप्लीकेशन External Database Demo बनाएं com.javahelps.com.javahelps.externaldatabasedemo

चरण 4 : build.gradle (मॉड्यूल: ऐप) फ़ाइल खोलें और निम्न निर्भरता जोड़ें।

dependencies {
    compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+'
}

एक बार जब आप build.gradle फ़ाइल को सहेज build.gradle तो प्रोजेक्ट को अपडेट करने के लिए 'अभी सिंक करें' लिंक पर क्लिक करें। आप build.gradle फ़ाइल पर राइट क्लिक करके build.gradle को सिंक्रनाइज़ कर सकते हैं और Synchronize build.gradle विकल्प को Synchronize build.gradle भी चुन सकते हैं।

चरण 5 : ऐप फ़ोल्डर पर राइट क्लिक करें और नई संपत्ति फ़ोल्डर बनाएं।

चरण 6 : संपत्ति फ़ोल्डर के अंदर एक नया फ़ोल्डर 'डेटाबेस' बनाएँ।

चरण 7 : assets/databases फ़ोल्डर के अंदर quotes.db.zip फ़ाइल कॉपी और पेस्ट करें।

चरण 8 : एक नया वर्ग DatabaseOpenHelper ओपनहेल्पर बनाएं

package com.javahelps.externaldatabasedemo;

import android.content.Context;

import com.readystatesoftware.sqliteasset.SQLiteAssetHelper;

public class DatabaseOpenHelper extends SQLiteAssetHelper {
    private static final String DATABASE_NAME = "quotes.db";
    private static final int DATABASE_VERSION = 1;

    public DatabaseOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
}  Notice that rather than extending SQLiteOpenHelper, the DatabaseOpenHelper extends  SQLiteAssetHelper class.

चरण 9 : एक नया वर्ग DatabaseAccess एक्सेस बनाएं और नीचे दिखाए गए कोड को दर्ज करें। इस कक्षा के बारे में अधिक जानकारी उन्नत एंड्रॉइड डेटाबेस ट्यूटोरियल पर उपलब्ध है।

package com.javahelps.externaldatabasedemo;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

import java.util.ArrayList;
import java.util.List;

public class DatabaseAccess {
    private SQLiteOpenHelper openHelper;
    private SQLiteDatabase database;
    private static DatabaseAccess instance;

    /**
     * Private constructor to aboid object creation from outside classes.
     *
     * @param context
     */
    private DatabaseAccess(Context context) {
        this.openHelper = new DatabaseOpenHelper(context);
    }

    /**
     * Return a singleton instance of DatabaseAccess.
     *
     * @param context the Context
     * @return the instance of DabaseAccess
     */
    public static DatabaseAccess getInstance(Context context) {
        if (instance == null) {
            instance = new DatabaseAccess(context);
        }
        return instance;
    }

    /**
     * Open the database connection.
     */
    public void open() {
        this.database = openHelper.getWritableDatabase();
    }

    /**
     * Close the database connection.
     */
    public void close() {
        if (database != null) {
            this.database.close();
        }
    }

    /**
     * Read all quotes from the database.
     *
     * @return a List of quotes
     */
    public List<String> getQuotes() {
        List<String> list = new ArrayList<>();
        Cursor cursor = database.rawQuery("SELECT * FROM quotes", null);
        cursor.moveToFirst();
        while (!cursor.isAfterLast()) {
            list.add(cursor.getString(0));
            cursor.moveToNext();
        }
        cursor.close();
        return list;
    }
}  In this class only the `getQuotes` method is implemented to read the data from the database. You have the full freedom to insert,

सामान्य रूप से डेटाबेस में किसी भी पंक्ति को अद्यतन और हटाएं। अधिक जानकारी के लिए, इस लिंक का पालन करें उन्नत एंड्रॉइड डेटाबेस।

सभी डेटाबेस से संबंधित सेटअप पूर्ण हो गए हैं और अब हमें उद्धरण प्रदर्शित करने के लिए एक ListView बनाने की आवश्यकता है।

चरण 10 : अपनी ListView में एक ListView जोड़ें।

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity">

    <ListView
        android:id="@+id/listView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_gravity="center" />
</FrameLayout>  

चरण 11 : MainActivity की MainActivity विधि में ListView की ऑब्जेक्ट MainActivity और डेटाबेस के रूप में पढ़ने वाले कोट्स को फ़ीड करें।

package com.javahelps.externaldatabasedemo;

import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.widget.ArrayAdapter;
import android.widget.ListView;

import java.util.List;


public class MainActivity extends ActionBarActivity {
    private ListView listView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        this.listView = (ListView) findViewById(R.id.listView);
        DatabaseAccess databaseAccess = DatabaseAccess.getInstance(this);
        databaseAccess.open();
        List<String> quotes = databaseAccess.getQuotes();
        databaseAccess.close();

        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1,
quotes);
        this.listView.setAdapter(adapter);
    }
}

चरण 12 : सभी परिवर्तनों को सहेजें और एप्लिकेशन चलाएं।

इस आलेख के अलावा आप here SQLiteAssetHelper डाउनलोड कर सकते here


मेरा समाधान न तो किसी तीसरे पक्ष की लाइब्रेरी का उपयोग करता है और न ही आपको सृजन पर डेटाबेस प्रारंभ करने के लिए SQLiteOpenHelper उप SQLiteOpenHelper पर कस्टम विधियों को कॉल करने के लिए मजबूर करता है। यह डेटाबेस उन्नयन का भी ख्याल रखता है। SQLiteOpenHelper subclass करने के लिए जो कुछ करने की जरूरत है।

शर्त:

  1. वह डेटाबेस जिसे आप ऐप के साथ भेजना चाहते हैं। इसमें एक android_metadata locale नामक एक 1x1 तालिका होनी चाहिए जिसमें आपके ऐप के लिए अद्वितीय सारणी के अलावा मान en_US है।

SQLiteOpenHelper :

  1. Subclass SQLiteOpenHelper
  2. SQLiteOpenHelper उप SQLiteOpenHelper भीतर एक private विधि बनाएँ। इस विधि में 'संपत्ति' फ़ोल्डर में डेटाबेस फ़ाइल से डेटाबेस पैकेज की प्रतिलिपि बनाने के लिए तर्क पैकेज अनुप्रयोग संदर्भ में बनाए गए डेटाबेस में तर्क शामिल है।
  3. onUpgrade , onUpgrade और onOpen विधियों पर SQLiteOpenHelper

पर्याप्त कथन। यहां SQLiteOpenHelper उप SQLiteOpenHelper चला जाता है:

public class PlanDetailsSQLiteOpenHelper extends SQLiteOpenHelper {
    private static final String TAG = "SQLiteOpenHelper";

    private final Context context;
    private static final int DATABASE_VERSION = 1;
    private static final String DATABASE_NAME = "my_custom_db";

    private boolean createDb = false, upgradeDb = false;

    public PlanDetailsSQLiteOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        this.context = context;
    }

    /**
     * Copy packaged database from assets folder to the database created in the
     * application package context.
     * 
     * @param db
     *            The target database in the application package context.
     */
    private void copyDatabaseFromAssets(SQLiteDatabase db) {
        Log.i(TAG, "copyDatabase");
        InputStream myInput = null;
        OutputStream myOutput = null;
        try {
            // Open db packaged as asset as the input stream
            myInput = context.getAssets().open("path/to/shipped/db/file");

            // Open the db in the application package context:
            myOutput = new FileOutputStream(db.getPath());

            // Transfer db file contents:
            byte[] buffer = new byte[1024];
            int length;
            while ((length = myInput.read(buffer)) > 0) {
                myOutput.write(buffer, 0, length);
            }
            myOutput.flush();

            // Set the version of the copied database to the current
            // version:
            SQLiteDatabase copiedDb = context.openOrCreateDatabase(
                DATABASE_NAME, 0, null);
            copiedDb.execSQL("PRAGMA user_version = " + DATABASE_VERSION);
            copiedDb.close();

        } catch (IOException e) {
            e.printStackTrace();
            throw new Error(TAG + " Error copying database");
        } finally {
            // Close the streams
            try {
                if (myOutput != null) {
                    myOutput.close();
                }
                if (myInput != null) {
                    myInput.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
                throw new Error(TAG + " Error closing streams");
            }
        }
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        Log.i(TAG, "onCreate db");
        createDb = true;
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.i(TAG, "onUpgrade db");
        upgradeDb = true;
    }

    @Override
    public void onOpen(SQLiteDatabase db) {
        Log.i(TAG, "onOpen db");
        if (createDb) {// The db in the application package
            // context is being created.
            // So copy the contents from the db
            // file packaged in the assets
            // folder:
            createDb = false;
            copyDatabaseFromAssets(db);

        }
        if (upgradeDb) {// The db in the application package
            // context is being upgraded from a lower to a higher version.
            upgradeDb = false;
            // Your db upgrade logic here:
        }
    }
}

Finally, to get a database connection, just call getReadableDatabase() or getWritableDatabase() on the SQLiteOpenHelper subclass and it will take care of creating a db, copying db contents from the specified file in the 'assets' folder, if the database does not exist.

In short, you can use the SQLiteOpenHelper subclass to access the db shipped in the assets folder just as you would use for a database that is initialized using SQL queries in the onCreate() method.


Android already provides a version-aware approach of database management. This approach has been leveraged in the BARACUS framework for Android applications.

It enables you to manage the database along the entire version lifecycle of an app, beeing able to update the sqlite database from any prior version to the current one.

Also, it allows you to run hot-backups and hot-recovery of the SQLite.

I am not 100% sure, but a hot-recovery for a specific device may enable you to ship a prepared database in your app. But I am not sure about the database binary format which might be specific to certain devices, vendors or device generations.

Since the stuff is Apache License 2, feel free to reuse any part of the code, which can be found on github

EDIT :

If you only want to ship data, you might consider instantiating and persisting POJOs at the applications first start. BARACUS got a built-in support to this (Built-in key value store for configuration infos, eg "APP_FIRST_RUN" plus a after-context-bootstrap hook in order to run post-launch operations on the context). This enables you to have tight coupled data shipped with your app; in most cases this fitted to my use cases.


Currently there is no way to precreate an SQLite database to ship with your apk. The best you can do is save the appropriate SQL as a resource and run them from your application. Yes, this leads to duplication of data (same information exists as a resrouce and as a database) but there is no other way right now. The only mitigating factor is the apk file is compressed. My experience is 908KB compresses to less than 268KB.

The thread below has the best discussion/solution I have found with good sample code.

http://groups.google.com/group/android-developers/msg/9f455ae93a1cf152

I stored my CREATE statement as a string resource to be read with Context.getString() and ran it with SQLiteDatabse.execSQL().

I stored the data for my inserts in res/raw/inserts.sql (I created the sql file, 7000+ lines). Using the technique from the link above I entered a loop, read the file line by line and concactenated the data onto "INSERT INTO tbl VALUE " and did another SQLiteDatabase.execSQL(). No sense in saving 7000 "INSERT INTO tbl VALUE "s when they can just be concactenated on.

It takes about twenty seconds on the emulator, I do not know how long this would take on a real phone, but it only happens once, when the user first starts the application.


From what I've seen you should be be shipping a database that already has the tables setup and data. However if you want (and depending on the type of application you have) you can allow "upgrade database option". Then what you do is download the latest sqlite version, get the latest Insert/Create statements of a textfile hosted online, execute the statements and do a data transfer from the old db to the new one.


I wrote a library to simplify this process.

dataBase = new DataBase.Builder(context, "myDb").
//        setAssetsPath(). // default "databases"
//        setDatabaseErrorHandler().
//        setCursorFactory().
//        setUpgradeCallback()
//        setVersion(). // default 1
build();

It will create a dataBase from assets/databases/myDb.db file. In addition you will get all those functionality:

  • Load database from file
  • Synchronized access to the database
  • Using sqlite-android by requery, Android specific distribution of the latest versions of SQLite.

Clone it from library .


If the required data is not too large (limits I don´t know, would depend on a lot of things), you might also download the data (in XML, JSON, whatever) from a website/webapp. AFter receiving, execute the SQL statements using the received data creating your tables and inserting the data.

If your mobile app contains lots of data, it might be easier later on to update the data in the installed apps with more accurate data or changes.


In November 2017 Google released the Room Persistence Library

दस्तावेज़ीकरण से:

The Room persistence library provides an abstraction layer over SQLite to allow fluent database access while harnessing the full power of SQLite.

The library helps you create a cache of your app's data on a device that's running your app. This cache, which serves as your app's single source of truth, allows users to view a consistent copy of key information within your app, regardless of whether users have an internet connection.

The Room database has a callback when the database is first created or opened. You can use the create callback to populate your database.

Room.databaseBuilder(context.applicationContext,
        DataDatabase::class.java, "Sample.db")
        // prepopulate the database after onCreate was called
        .addCallback(object : Callback() {
            override fun onCreate(db: SupportSQLiteDatabase) {
                super.onCreate(db)
                // moving to a new thread
                ioThread {
                    getInstance(context).dataDao()
                                        .insert(PREPOPULATE_DATA)
                }
            }
        })
        .build()

Code from this blog post .


मैंने वर्ग और प्रश्न के उत्तर संशोधित किए और एक कक्षा लिखी जो डेटाबेस को DB_VERSION के माध्यम से अद्यतन करने की अनुमति देता है।

import android.content.Context;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class DatabaseHelper extends SQLiteOpenHelper {
    private static String DB_NAME = "info.db";
    private static String DB_PATH = "";
    private static final int DB_VERSION = 1;

    private SQLiteDatabase mDataBase;
    private final Context mContext;
    private boolean mNeedUpdate = false;

    public DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
        if (android.os.Build.VERSION.SDK_INT >= 17)
            DB_PATH = context.getApplicationInfo().dataDir + "/databases/";
        else
            DB_PATH = "/data/data/" + context.getPackageName() + "/databases/";
        this.mContext = context;

        copyDataBase();

        this.getReadableDatabase();
    }

    public void updateDataBase() throws IOException {
        if (mNeedUpdate) {
            File dbFile = new File(DB_PATH + DB_NAME);
            if (dbFile.exists())
                dbFile.delete();

            copyDataBase();

            mNeedUpdate = false;
        }
    }

    private boolean checkDataBase() {
        File dbFile = new File(DB_PATH + DB_NAME);
        return dbFile.exists();
    }

    private void copyDataBase() {
        if (!checkDataBase()) {
            this.getReadableDatabase();
            this.close();
            try {
                copyDBFile();
            } catch (IOException mIOException) {
                throw new Error("ErrorCopyingDataBase");
            }
        }
    }

    private void copyDBFile() throws IOException {
        InputStream mInput = mContext.getAssets().open(DB_NAME);
        //InputStream mInput = mContext.getResources().openRawResource(R.raw.info);
        OutputStream mOutput = new FileOutputStream(DB_PATH + DB_NAME);
        byte[] mBuffer = new byte[1024];
        int mLength;
        while ((mLength = mInput.read(mBuffer)) > 0)
            mOutput.write(mBuffer, 0, mLength);
        mOutput.flush();
        mOutput.close();
        mInput.close();
    }

    public boolean openDataBase() throws SQLException {
        mDataBase = SQLiteDatabase.openDatabase(DB_PATH + DB_NAME, null, SQLiteDatabase.CREATE_IF_NECESSARY);
        return mDataBase != null;
    }

    @Override
    public synchronized void close() {
        if (mDataBase != null)
            mDataBase.close();
        super.close();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        if (newVersion > oldVersion)
            mNeedUpdate = true;
    }
}

एक वर्ग का उपयोग करना

गतिविधि वर्ग में, चर घोषित करें।

private DatabaseHelper mDBHelper;
private SQLiteDatabase mDb;

ऑनक्रेट विधि में, निम्न कोड लिखें।

mDBHelper = new DatabaseHelper(this);

try {
    mDBHelper.updateDataBase();
} catch (IOException mIOException) {
    throw new Error("UnableToUpdateDatabase");
}

try {
    mDb = mDBHelper.getWritableDatabase();
} catch (SQLException mSQLException) {
    throw mSQLException;
}

यदि आप फ़ोल्डर res / raw में डेटाबेस फ़ाइल जोड़ते हैं तो कक्षा के निम्न संशोधन का उपयोग करें।

import android.content.Context;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class DatabaseHelper extends SQLiteOpenHelper {
    private static String DB_NAME = "info.db";
    private static String DB_PATH = "";
    private static final int DB_VERSION = 1;

    private SQLiteDatabase mDataBase;
    private final Context mContext;
    private boolean mNeedUpdate = false;

    public DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
        if (android.os.Build.VERSION.SDK_INT >= 17)
            DB_PATH = context.getApplicationInfo().dataDir + "/databases/";
        else
            DB_PATH = "/data/data/" + context.getPackageName() + "/databases/";
        this.mContext = context;

        copyDataBase();

        this.getReadableDatabase();
    }

    public void updateDataBase() throws IOException {
        if (mNeedUpdate) {
            File dbFile = new File(DB_PATH + DB_NAME);
            if (dbFile.exists())
                dbFile.delete();

            copyDataBase();

            mNeedUpdate = false;
        }
    }

    private boolean checkDataBase() {
        File dbFile = new File(DB_PATH + DB_NAME);
        return dbFile.exists();
    }

    private void copyDataBase() {
        if (!checkDataBase()) {
            this.getReadableDatabase();
            this.close();
            try {
                copyDBFile();
            } catch (IOException mIOException) {
                throw new Error("ErrorCopyingDataBase");
            }
        }
    }

    private void copyDBFile() throws IOException {
        //InputStream mInput = mContext.getAssets().open(DB_NAME);
        InputStream mInput = mContext.getResources().openRawResource(R.raw.info);
        OutputStream mOutput = new FileOutputStream(DB_PATH + DB_NAME);
        byte[] mBuffer = new byte[1024];
        int mLength;
        while ((mLength = mInput.read(mBuffer)) > 0)
            mOutput.write(mBuffer, 0, mLength);
        mOutput.flush();
        mOutput.close();
        mInput.close();
    }

    public boolean openDataBase() throws SQLException {
        mDataBase = SQLiteDatabase.openDatabase(DB_PATH + DB_NAME, null, SQLiteDatabase.CREATE_IF_NECESSARY);
        return mDataBase != null;
    }

    @Override
    public synchronized void close() {
        if (mDataBase != null)
            mDataBase.close();
        super.close();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        if (newVersion > oldVersion)
            mNeedUpdate = true;
    }
}

http://blog.harrix.org/article/6784





android-database