Storing Android application data using Database (MySQL or SQLite): connecting Android app with database; CRUD operations using app; create and insert data; read, update and delete data

📖 Theory

App બંધ થાય તો પણ ટકી રહેતો data

FestConnect Mobile registrations લે તો છે, પણ user app બંધ કરે એટલે એ ગાયબ થઈ જાય છે: બધું memory માં જ હતું. ખરી app યાદ રાખે છે.

Android દરેક ઉપકરણમાં બરાબર આ કામ માટે જ એક database સાથે આવે છે: SQLite, એટલે કે એવું હલકું relational database જે data ને ફોન પર જ સ્થાનિક રીતે સંઘરે છે, અને એને કોઈ server ની જરૂર પડતી નથી. BCA205 અને BCA303 માંથી તમે SQL તો જાણો જ છો; SQLite એ જ SQL છે, જે ઉપકરણ પર ચાલે છે. આ પાઠ FestConnect Mobile ને ટકાઉ storage આપે છે: table બનાવવું, અને પૂરું CRUD (insert, read, update, delete) જેથી registrations એક વપરાશથી બીજા વપરાશ સુધી ટકે. (Slug માં MySQL નો પણ ઉલ્લેખ છે: એ server વાળું database છે જેની પાસે app network દ્વારા API થી પહોંચે છે; અહીં ઉપકરણ પરની પસંદગી SQLite છે.)

📖 Theory

SQLite અને SQLiteOpenHelper

SQLite એ Android ની અંદર જ બેઠેલું relational database છે, જે ઉપકરણ પર એક file તરીકે સંઘરાય છે. એને વાપરવા માટે તમે SQLiteOpenHelper ને લંબાવતો helper class બનાવો છો, જે database બનાવવાનું અને એની આવૃત્તિ સંભાળવાનું કામ કરે છે:

• onCreate(db): database પહેલી વાર બને ત્યારે એક જ વાર ચાલે છે: તમારું CREATE TABLE વાળું SQL અહીં મૂકો
• onUpgrade(db, old, new): તમે database ની આવૃત્તિ વધારો ત્યારે schema ના ફેરફારો સંભાળે છે

Helper તમને SQLiteDatabase પદાર્થ આપે છે જેના પર ક્રિયાઓ ચલાવાય. સ્થાનિક અને server વગરનું હોવાથી SQLite ફોન માટે બરાબર બંધ બેસે છે: ઝડપી, offline પણ ચાલે એવું, અને ફક્ત એ જ app પૂરતું ખાનગી. (Registrations કે cache જેવો ઉપકરણ પરનો data અહીં રહે છે; users વચ્ચે વહેંચાતો data server પર રહે છે, જ્યાં API દ્વારા પહોંચાય છે.)

⌨️ Practical

Table બનાવવું અને CRUD કરવું

class DbHelper(context: Context) :
    SQLiteOpenHelper(context, "fest.db", null, 1) {

    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL("CREATE TABLE regs(id INTEGER PRIMARY KEY, name TEXT, event TEXT)")
    }
    override fun onUpgrade(db: SQLiteDatabase, old: Int, new: Int) {
        db.execSQL("DROP TABLE IF EXISTS regs")
        onCreate(db)
    }
}

// ContentValues સાથે INSERT:
fun addReg(db: SQLiteDatabase, name: String, event: String) {
    val values = ContentValues().apply {
        put("name", name)
        put("event", event)
    }
    db.insert("regs", null, values)
}

// Parameterized query સાથે READ (injection સામે સલામત):
fun findByEvent(db: SQLiteDatabase, event: String): List<String> {
    val names = mutableListOf<String>()
    val cursor = db.rawQuery("SELECT name FROM regs WHERE event = ?", arrayOf(event))
    while (cursor.moveToNext()) {
        names.add(cursor.getString(0))
    }
    cursor.close()          // cursor હંમેશા બંધ કરો
    return names
}

📖 Theory

CRUD, cursors અને સલામતી

SQLiteDatabase પર ચાર ક્રિયાઓ થાય છે:

• insert: db.insert(table, null, contentValues), જ્યાં ContentValues એટલે column અને એની કિંમતની જોડી
• read: db.query(...) કે db.rawQuery(sql, args) એક Cursor પાછું આપે છે જેના પર તમે ફરો છો (cursor.moveToNext(), cursor.getString(index)), અને પછી એને બંધ કરો છો
• update: db.update(table, values, whereClause, whereArgs)
• delete: db.delete(table, whereClause, whereArgs)

BCA504 માંથી સલામતીનો એક નિયમ અહીં પણ લાગુ પડે છે: parameterized queries વાપરો (? વાળી જગ્યાઓ સાથે selectionArgs કે arrayOf(...)), અને user નું input જોડીને બનાવેલી string ક્યારેય નહીં, જેથી SQL injection અટકે. SQLite ખરું SQL database છે, એટલે એમાં injection નું એ જ જોખમ છે અને એ જ બચાવ પણ. (આધુનિક Android ઘણી વાર Room વાપરે છે, જે SQLite ને ઓછા લખાણ સાથે વીંટતી library છે; એ છે એટલું જાણી રાખો.)

🧩 Quiz

SQLite એ FestConnect Mobile નો registration data ક્યાં સંઘરે છે, અને એને ફોનની app માટે અનુકૂળ શું બનાવે છે?

1. દૂરના server પર, જ્યાં દરેક વાચન માટે internet જોઈએ
2. ઉપકરણ પર જ સ્થાનિક રીતે, એવા અંદરથી બેઠેલા database તરીકે જેને server ની જરૂર નથી: ઝડપી, offline ચાલે એવું અને app પૂરતું ખાનગી
3. ફક્ત cloud માં
4. એ data ટકાઉ રીતે સંઘરી શકતું જ નથી

💭 Think first

SQLite કે server વાળું database (MySQL)?

FestConnect Mobile registrations ને ઉપકરણ પરના SQLite માં પણ સંઘરી શકે અને server ના MySQL database માં પણ (API દ્વારા, જેમ કે BCA504 વાળું back end). દરેક ક્યારે યોગ્ય ગણાય? વિચારીને પછી tap કરો.

⚠️ Watch out

SQLite ના ફાંદા

String જોડીને queries બનાવવી: parameterized queries વાપરો (? અને args); injection નું જોખમ SQLite માં પણ ખરેખરું છે (BCA504 વાળો પાઠ).

Cursor બંધ ન કરવો: વાંચ્યા પછી હંમેશા cursor.close() કરો, નહીં તો leak થાય.

UI thread પર ભારે database નું કામ: database ની ક્રિયાઓ મુખ્ય thread ની બહાર કરો, નહીં તો app થીજી જાય.

onUpgrade ભૂલી જવું: schema બદલાય તો આવૃત્તિ વધારવી પડે અને onUpgrade સંભાળવું પડે.

SQLite (સ્થાનિક) અને MySQL (server) ને ભેળવી દેવાં: SQLite ઉપકરણ પર છે; server વાળા database સુધી API દ્વારા પહોંચાય છે.

📖 Theory

એ યાદ રાખે છે; હવે ઉપકરણની શક્તિઓ

FestConnect Mobile હવે SQLite વડે data ને સ્થાનિક રીતે ટકાવે છે. આ એકમના છેલ્લા બે પાઠ ફોનના hardware ને અડે છે: user નું વર્તમાન સ્થાન મેળવવું (નજીકનાં fest નાં સ્થળો બતાવવા), અને કૅમેરાથી છબી લેવી (પ્રોફાઈલ કે event ના ફોટા માટે). Permissions થી નિયંત્રિત આ ઉપકરણની ક્ષમતાઓ જ mobile app ને નાની website કરતાં કંઈક વધારે બનાવે છે. પહેલાં સ્થાન, પછી કૅમેરા.

✅ Summary

Key takeaways

• SQLite એ Android માં અંદરથી મળતું, ઉપકરણ પરનું relational database છે (file, server વગર): ઝડપી, offline અને app પૂરતું ખાનગી.
• SQLiteOpenHelper ને લંબાવો: onCreate માં CREATE TABLE ચાલે છે; onUpgrade schema અને આવૃત્તિના ફેરફારો સંભાળે છે.
• SQLiteDatabase પર CRUD: insert (ContentValues), query કે rawQuery (Cursor પાછું આપે), update અને delete.
• Cursor પર moveToNext() અને getString(index) વડે ફરો; અને એને હંમેશા બંધ કરો.
• Parameterized queries વાપરો (? અને args), જોડેલું input ક્યારેય નહીં: SQL injection નું જોખમ BCA504 માંથી અહીં પણ ચાલુ રહે છે.
• SQLite સ્થાનિક data માટે છે; વહેંચાયેલા કે કેન્દ્રિય data માટે server વાળું database (API દ્વારા MySQL); અને Room SQLite ને ઓછા લખાણ સાથે વીંટે છે.
• યાદ રાખવાની કડી: SQLite એટલે ઉપકરણ પરનું SQL database; helper tables બનાવે, db દ્વારા CRUD, અને queries parameterized રાખો.