Android
Android में ORMLite

SQLite उदाहरण पर Android OrmLite

ORMLite एक ऑब्जेक्ट रिलेशनल मैपिंग पैकेज है, जो अधिक मानक ORM पैकेज की जटिलता और ओवरहेड से बचने के लिए SQL डेटाबेस में जावा ऑब्जेक्ट्स को बनाए रखने के लिए सरल और हल्की कार्यक्षमता प्रदान करता है।

Android के लिए बोलते हुए, OrmLite को आउट-ऑफ-द-बॉक्स समर्थित डेटाबेस, SQLite पर लागू किया जाता है। यह SQLite तक पहुँचने के लिए एपीआई के लिए प्रत्यक्ष कॉल करता है।

ग्रेड सेटअप

आरंभ करने के लिए आपको पैकेज को बिल्ड ग्रेडेल में शामिल करना चाहिए।

 // https://mvnrepository.com/artifact/com.j256.ormlite/ormlite-android
compile group: 'com.j256.ormlite', name: 'ormlite-android', version: '5.0'
POJO configuration

फिर आपको डेटाबेस में बने रहने के लिए POJO को कॉन्फ़िगर करना चाहिए। यहां एनोटेशन पर ध्यान दिया जाना चाहिए:

• प्रत्येक वर्ग के शीर्ष पर @DatabaseTable एनोटेशन जोड़ें। आप @Entity का भी उपयोग कर सकते हैं।
• प्रत्येक फ़ील्ड को बनाए रखने से ठीक पहले @DatabaseField एनोटेशन जोड़ें। आप @ कॉलम और अन्य का भी उपयोग कर सकते हैं।
• कम से कम पैकेज दृश्यता के साथ प्रत्येक वर्ग में एक नो-लॉजिक कंस्ट्रक्टर जोड़ें।

 @DatabaseTable(tableName = "form_model")
 public class FormModel implements Serializable {

    @DatabaseField(generatedId = true)
    private Long id;
    @DatabaseField(dataType = DataType.SERIALIZABLE)
    ArrayList<ReviewItem> reviewItems;

    @DatabaseField(index = true)
    private String username;

    @DatabaseField
    private String createdAt;

    public FormModel() {
    }

    public FormModel(ArrayList<ReviewItem> reviewItems, String username, String createdAt) {
        this.reviewItems = reviewItems;
        this.username = username;
        this.createdAt = createdAt;
    }
}

ऊपर के उदाहरण में 4 क्षेत्रों के साथ एक तालिका (form_model) है।

आईडी फ़ील्ड ऑटो जनरेट इंडेक्स है।

उपयोगकर्ता नाम डेटाबेस का एक सूचकांक है।

एनोटेशन के बारे में अधिक जानकारी आधिकारिक दस्तावेज में पाई जा सकती है।

डेटाबेस हेल्पर

इसे जारी रखने के लिए, आपको एक डेटाबेस हेल्पर क्लास बनाने की आवश्यकता होगी, जो OrmLiteSqliteOpenHelper क्लास का विस्तार करे।

यह वर्ग डेटाबेस बनाता है और अपग्रेड करता है जब आपका एप्लिकेशन इंस्टॉल होता है और आपके अन्य वर्गों द्वारा उपयोग किए जाने वाले DAO कक्षाएं भी प्रदान कर सकता है।

डीएओ डेटा एक्सेस ऑब्जेक्ट के लिए खड़ा है और यह सभी स्क्रैम कार्यक्षमता प्रदान करता है और एकल निरंतर कक्षा को संभालने में माहिर है।

सहायक वर्ग को निम्नलिखित दो विधियों को लागू करना चाहिए:

• onCreate (SQLiteDatabase sqliteDatabase, ConnectionSource connectionSource);

  जब आपका ऐप पहले इंस्टॉल हो जाता है, तो onCreate डेटाबेस बनाता है

• onUpgrad (SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion);

  जब आप अपने ऐप को एक नए संस्करण में अपग्रेड करते हैं, तो onUpgrad डेटाबेस तालिकाओं के उन्नयन को संभालता है

डेटाबेस हेल्पर वर्ग उदाहरण:

  public class OrmLite extends OrmLiteSqliteOpenHelper {
    
        //Database name
        private static final String DATABASE_NAME = "gaia";
        //Version of the database. Changing the version will call {@Link OrmLite.onUpgrade}
        private static final int DATABASE_VERSION = 2;
    
        /**
         * The data access object used to interact with the Sqlite database to do C.R.U.D operations.
         */
        private Dao<FormModel, Long> todoDao;
    
    
    
        public OrmLite(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION,
                    /**
                     * R.raw.ormlite_config is a reference to the ormlite_config2.txt file in the
                     * /res/raw/ directory of this project
                     * */
                    R.raw.ormlite_config2);
        }
    
        @Override
        public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
            try {
    
                /**
                 * creates the database table
                 */
                TableUtils.createTable(connectionSource, FormModel.class);
    
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (java.sql.SQLException e) {
                e.printStackTrace();
            }
        }
        /*
            It is called when you construct a SQLiteOpenHelper with version newer than the version of the opened database.
         */
        @Override
        public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource,
                              int oldVersion, int newVersion) {
            try {
                /**
                 * Recreates the database when onUpgrade is called by the framework
                 */
                TableUtils.dropTable(connectionSource, FormModel.class, false);
                onCreate(database, connectionSource);
    
            } catch (SQLException | java.sql.SQLException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * Returns an instance of the data access object
         * @return
         * @throws SQLException
         */
        public Dao<FormModel, Long> getDao() throws SQLException {
            if(todoDao == null) {
                try {
                    todoDao = getDao(FormModel.class);
                } catch (java.sql.SQLException e) {
                    e.printStackTrace();
                }
            }
            return todoDao;
        }
    }

SQLite के लिए स्थायी वस्तु

अंत में, वह वर्ग जो डेटाबेस के लिए ऑब्जेक्ट को बनाए रखता है।

     public class ReviewPresenter {
    Dao<FormModel, Long> simpleDao;


    public ReviewPresenter(Application application) {
        this.application = (GaiaApplication) application;
        simpleDao = this.application.getHelper().getDao();
    }

    public void storeFormToSqLite(FormModel form) {

        try {
            simpleDao.create(form);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        List<FormModel> list = null;
        try {
// query for all of the data objects in the database
            list = simpleDao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
        }
// our string builder for building the content-view
        StringBuilder sb = new StringBuilder();
        int simpleC = 1;
        for (FormModel simple : list) {
            sb.append('#').append(simpleC).append(": ").append(simple.getUsername()).append('\n');
            simpleC++;
        }
        System.out.println(sb.toString());
    }
    
    //Query to database to get all forms by username
    public List<FormModel> getAllFormsByUsername(String username) {
        List<FormModel> results = null;
        try {
            results = simpleDao.queryBuilder().where().eq("username", PreferencesManager.getInstance().getString(Constants.USERNAME)).query();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return results;
    }
}

उपरोक्त वर्ग के निर्माता पर डीओए का अभिगमन निम्न के रूप में परिभाषित किया गया है:

 private OrmLite dbHelper = null;

/*
Provides the SQLite Helper Object among the application
 */
public OrmLite getHelper() {
    if (dbHelper == null) {
        dbHelper = OpenHelperManager.getHelper(this, OrmLite.class);
    }
    return dbHelper;
}