CRUD operation on firebase dataset

📖 Theory

ચારેય operations, સાથે મળીને

તમે હવે Realtime Database માં લખી શકો છો અને એમાંથી વાંચી શકો છો. એમાં updating અને deleting ઉમેરો એટલે તમને પૂરું CRUD મળે છે: Create, Read, Update, Delete, એટલે કે કોઈ પણ app data સાથે જે કંઈ કરે તે બધું જ. FestConnect ચારેય વાપરે છે: registration ઉમેરવું, registrations ની યાદી બતાવવી, event સુધારવો, registration રદ કરવું.

આ પાઠ તમે અગાઉ જોયેલા ટુકડાઓમાંથી CRUD ને ભેગું કરે છે અને બે નવી બાબતો ઉમેરે છે: કોઈ ચોક્કસ item ને બદલવું અને એને કાઢી નાખવું. Update અને delete માટેની એક જ પૂર્વશરત એટલે item ની key જાણવી, એટલે શરૂઆત ત્યાંથી જ કરીએ.

📖 Theory

તમને item ની key જોઈએ

કોઈ ચોક્કસ item ને update કે delete કરવા માટે તમારે એનો ચોક્કસ path નિશાન બનાવવો પડે, એટલે કે એની key જાણવી પડે. એ મેળવવાની બે રીત છે: item બનાવતી વખતે push() એ પાછી આપેલી key તમે સાચવી રાખી હોય, અથવા listening કરતી વખતે snapshot.key માંથી એ વાંચી લો (દરેક child snapshot પોતાની key જાણે છે).

Key હાથમાં હોય એટલે તમે એ item નું reference બનાવો છો, eventsRef.child(key), અને એના પર કામ કરો છો. એટલા માટે જ વાંચતી વખતે ઘણી વાર દરેક item ને એની key સાથે જ સાચવવામાં આવે છે: જેથી UI પછીથી એ ચોક્કસ entry માટે edit અને delete આપી શકે. Key નહીં, તો નિશાનવાળું update કે delete પણ નહીં.

⌨️ Practical

કોઈ ચોક્કસ item ને update અને delete કરવું

val eventsRef = FirebaseDatabase.getInstance().getReference("events")

// UPDATE specific fields without overwriting the whole node:
eventsRef.child(key).updateChildren(mapOf("seats" to 40))

// (or replace the whole item with setValue)
// eventsRef.child(key).setValue(updatedEvent)

// DELETE the item entirely:
eventsRef.child(key).removeValue()

// CREATE was: eventsRef.push().setValue(event)
// READ was:   eventsRef.addValueEventListener(...)

✏️ Formula

updateChildren fields બદલે છે; setValue આખો node બદલી નાખે છે

Update માટે એક મહત્ત્વનો ભેદ છે. updateChildren(map) ફક્ત તમે યાદીમાં આપેલાં fields જ બદલે છે અને item નો બાકીનો ભાગ એમનો એમ રહેવા દે છે, એટલે updateChildren(mapOf("seats" to 40)) ફક્ત seats બદલે છે અને name તથા date સાચવી રાખે છે. Item ના node પર setValue કરવાથી આખું item બદલાઈ જાય છે, એટલે જો તમે ફક્ત seats માટે setValue કરો, તો બાકીનાં fields ભૂંસાઈ જાય.

એટલે થોડાં fields સુધારવાં હોય ત્યારે updateChildren પસંદ કરો; setValue ત્યારે જ વાપરો જ્યારે તમારે ખરેખર આખું item બદલી નાખવું હોય. આ બંનેની ભેળસેળ કરવી એ અજાણતાં data ભૂંસી નાખવાની જાણીતી રીત છે. Fields updateChildren થી બદલો; nodes setValue થી બદલો.

🧩 Quiz

તમારે event ના ફક્ત 'seats' field ને બદલવું છે, એના name કે date ને અસર થયા વગર. તમારે કઈ method વાપરવી જોઈએ?

1. Event ના node પર setValue(mapOf("seats" to 40)), કારણ કે એ સૌથી સહેલું છે
2. Event ના node પર updateChildren(mapOf("seats" to 40)), જે ફક્ત એ જ field બદલે છે અને બાકીનું એમનું એમ રહેવા દે છે
3. removeValue(), કારણ કે એ કિંમત બદલી આપે છે
4. push(), કારણ કે એ item ને સુધારે છે

💭 Think first

updateChildren અને setValue વચ્ચેનો ભેદ આટલો બધો કેમ મહત્ત્વનો છે?

બંને data લખે છે. તો પણ એ બંનેની ભેળસેળ ગંભીર અને data નો નાશ કરનારી ભૂલ કેમ ગણાય? વિચારીને પછી tap કરો.

✅ Summary

Key takeaways

• Realtime Database પર પૂરું CRUD: push().setValue થી Create, listener થી Read, ચોક્કસ path પર Update, અને removeValue થી Delete.
• કોઈ ચોક્કસ item ને update કે delete કરવા માટે એની key જોઈએ, જે push() માંથી સાચવેલી હોય કે snapshot.key માંથી વાંચેલી હોય.
• ref.child(key) વડે item નું reference બનાવો, પછી એના પર કામ કરો.
• updateChildren(map) ફક્ત જણાવેલાં fields બદલે છે અને બાકીનું એમનું એમ રહેવા દે છે.
• Item ના node પર setValue આખું item બદલી નાખે છે, એટલે તમે છોડી દીધેલાં fields ભૂંસાઈ શકે છે.
• removeValue() item ને પૂરેપૂરું કાઢી નાખે છે.
• યાદ રાખવાની કડી: push એટલે create, listen એટલે read, આંશિક સુધારા માટે updateChildren (setValue તો બદલી નાખે), removeValue એટલે delete.