Realm Swift: पूरी गाइड उदाहरणों के साथ

Realm क्या है और इसकी ज़रूरत क्यों है?

Realm एक मोबाइल डेटाबेस है, जिसे Core Data और SQLite के विकल्प के रूप में बनाया गया है। पारंपरिक रिलेशनल डेटाबेस के विपरीत, Realm एक ऑब्जेक्ट-ओरिएंटेड स्टोरेज की तरह काम करता है: आप SQL क्वेरी या NSManagedObject के बजाय Swift के नेटिव ऑब्जेक्ट के साथ काम करते हैं। Realm डेटा को अपने फ़ॉर्मेट में स्टोर करता है, जो रैम के साथ काम करने जैसी स्पीड प्रदान करता है।

Realm के मुख्य फायदे:

• स्पीड: Realm मोबाइल डिवाइसों पर SQLite से 10-100 गुना तेज़ काम करता है।
• सरलता: आप सामान्य Swift ऑब्जेक्ट के साथ काम करते हैं, जो Realm.Object से इनहेरिट होते हैं।
• ऑटोमैटिक अपडेट: क्वेरी के परिणाम (Results) डेटा बदलने पर अपने आप अपडेट हो जाते हैं।
• लाइव ऑब्जेक्ट: Realm ऑब्जेक्ट अपने आप डेटाबेस के साथ सिंक हो जाते हैं।
• क्रॉस-प्लेटफ़ॉर्म: Realm iOS, macOS, tvOS और watchOS पर काम करता है।

Realm उन ऐप्स के लिए एकदम सही है जिन्हें डिवाइस पर तेज़ डेटा एक्सेस की ज़रूरत होती है: टू-डू लिस्ट, मैसेंजर, नेटवर्क से डेटा कैशिंग, नोट्स ऐप और कई अन्य।

Swift में Realm की इंस्टॉलेशन

Swift के लिए Realm को Swift Package Manager (SPM), CocoaPods या Carthage के ज़रिए इंस्टॉल किया जाता है। आइए दो सबसे लोकप्रिय तरीकों पर नज़र डालते हैं।

Swift Package Manager के ज़रिए इंस्टॉलेशन (अनुशंसित)

1. Xcode में अपना प्रोजेक्ट खोलें: File → Add Packages...
2. URL डालें: https://github.com/realm/realm-swift.git
3. वर्ज़न चुनें (नवीनतम स्थिर वर्ज़न अनुशंसित है) और Add Package पर क्लिक करें।
4. दिखाई देने वाली विंडो में अपने टार्गेट बिल्ड के लिए Realm और RealmSwift पैकेज चुनें।

CocoaPods के ज़रिए इंस्टॉलेशन

Podfile में जोड़ें:

target 'YourApp' do
  use_frameworks!
  pod 'RealmSwift'
end

फिर टर्मिनल में चलाएं:

pod install

कोड में इम्पोर्ट करना

import RealmSwift

त्वरित शुरुआत: पहला मॉडल और डेटा सेव करना

चलिए एक सरल टास्क मॉडल बनाते हैं और इसे डेटाबेस में सेव करते हैं।

import RealmSwift

// 1. मॉडल डिफ़ाइन करें
class Task: Object {
    @Persisted var id: String = UUID().uuidString
    @Persisted var title: String = ""
    @Persisted var isCompleted: Bool = false
    @Persisted var createdAt: Date = Date()
    
    // प्राइमरी की (वैकल्पिक, लेकिन अनुशंसित)
    override static func primaryKey() -> String? {
        return "id"
    }
}

// 2. ऑब्जेक्ट सेव करें
let task = Task()
task.title = "सब्ज़ियां खरीदें"
task.isCompleted = false

let realm = try! Realm()
try! realm.write {
    realm.add(task)
}

// 3. सभी टास्क पढ़ें
let tasks = realm.objects(Task.self)
for task in tasks {
    print("\(task.title) - \(task.isCompleted ? "पूरा हुआ" : "अधूरा")")
}

Realm के मुख्य तरीके और फ़ंक्शन

नीचे Realm के साथ काम करने के मुख्य तरीके दिए गए हैं। प्रत्येक तरीके के साथ विवरण, पैरामीटर और एक काम करने का उदाहरण दिया गया है।

1. Realm() — डेटाबेस इनिशियलाइज़ेशन

क्या करता है: Realm डेटाबेस बनाता या खोलता है। डिफ़ॉल्ट रूप से, डेटाबेस फ़ाइल ऐप की Documents डायरेक्टरी में होती है।

पैरामीटर: configuration: Realm.Configuration? — वैकल्पिक कॉन्फ़िगरेशन (फ़ाइल URL, स्कीमा, माइग्रेशन वर्ज़न)।

// स्टैंडर्ड इनिशियलाइज़ेशन
let realm = try! Realm()

// कस्टम URL के साथ इनिशियलाइज़ेशन
let config = Realm.Configuration(fileURL: FileManager.default
    .urls(for: .documentDirectory, in: .userDomainMask)
    .first?.appendingPathComponent("myrealm.realm"))
let customRealm = try! Realm(configuration: config)

2. realm.write(_:) — ट्रांज़ैक्शन में डेटा लिखना

क्या करता है: ब्लॉक के अंदर सभी बदलावों को एक ट्रांज़ैक्शन में निष्पादित करता है। डेटा जोड़ने, अपडेट करने या डिलीट करने के लिए ज़रूरी है।

पैरामीटर: withoutNotifying: [NotificationToken] — उन नोटिफिकेशन की सूची जिन्हें इस राइट के दौरान ब्लॉक किया जाना चाहिए।

try! realm.write {
    realm.add(newTask)
    existingTask.title = "अपडेटेड टाइटल"
    realm.delete(oldTask)
}

3. realm.objects(_:) — सभी ऑब्जेक्ट प्राप्त करना

क्या करता है: किसी विशिष्ट प्रकार के सभी ऑब्जेक्ट को Results कलेक्शन के रूप में लौटाता है। Results एक लाइव कलेक्शन है जो अपने आप अपडेट होता है।

पैरामीटर: _ type: Object.Type — ऑब्जेक्ट का प्रकार (जैसे Task.self)।

let allTasks = realm.objects(Task.self)
print("कुल टास्क: \(allTasks.count)")

4. .filter(_:) — डेटा फ़िल्टर करना

क्या करता है: Results को NSPredicate फ़ॉर्मेट में फ़िल्टर करता है। आप शर्तों के आधार पर डेटा को फ़िल्टर कर सकते हैं।

पैरामीटर: _ predicate: String — प्रेडिकेट स्ट्रिंग (जैसे "isCompleted == true")।

let completedTasks = realm.objects(Task.self).filter("isCompleted == true")
let highPriorityTasks = realm.objects(Task.self).filter("priority > 5 AND isCompleted == false")

5. .sorted(by:) — डेटा सॉर्ट करना

क्या करता है: Results को एक या अधिक प्रॉपर्टी के आधार पर सॉर्ट करता है।

पैरामीटर: by keyPath: String, ascending: Bool — प्रॉपर्टी का नाम और सॉर्टिंग ऑर्डर।

let sortedTasks = realm.objects(Task.self).sorted(byKeyPath: "createdAt", ascending: false)
let multiSorted = realm.objects(Task.self).sorted(by: [
    SortDescriptor(keyPath: "priority", ascending: false),
    SortDescriptor(keyPath: "title", ascending: true)
])

6. realm.delete(_:) — ऑब्जेक्ट डिलीट करना

क्या करता है: डेटाबेस से एक या अधिक ऑब्जेक्ट को डिलीट करता है। हमेशा realm.write ब्लॉक के अंदर उपयोग करें।

पैरामीटर: _ object: Object या _ objects: Results — डिलीट करने के लिए ऑब्जेक्ट या ऑब्जेक्ट की सूची।

try! realm.write {
    // एक ऑब्जेक्ट डिलीट करें
    realm.delete(taskToDelete)
    
    // सभी पूरे हुए टास्क डिलीट करें
    let completedTasks = realm.objects(Task.self).filter("isCompleted == true")
    realm.delete(completedTasks)
}

7. realm.object(ofType:forPrimaryKey:) — प्राइमरी की से ऑब्जेक्ट ढूंढना

क्या करता है: प्राइमरी की के आधार पर एक विशिष्ट ऑब्जेक्ट ढूंढता है। अगर ऑब्जेक्ट मौजूद नहीं है तो nil लौटाता है।

पैरामीटर: ofType: Object.Type — ऑब्जेक्ट का प्रकार, forPrimaryKey: Any — प्राइमरी की वैल्यू।

if let task = realm.object(ofType: Task.self, forPrimaryKey: "some-uuid-here") {
    print("टास्क मिला: \(task.title)")
} else {
    print("टास्क नहीं मिला")
}

8. .observe(on:_:) — डेटा में बदलाव देखना

क्या करता है: Results या ऑब्जेक्ट में बदलावों को ट्रैक करने के लिए एक नोटिफिकेशन ब्लॉक जोड़ता है। जब भी डेटा बदलता है, ब्लॉक कॉल होता है।

पैरामीटर: on queue: DispatchQueue? — वैकल्पिक क्यू जहाँ ब्लॉक चलाया जाए, _ block: @escaping (RealmCollectionChange) -> Void — बदलाव हैंडल करने वाला ब्लॉक।

let notificationToken = realm.objects(Task.self).observe { changes in
    switch changes {
    case .initial:
        print("शुरुआती डेटा लोड हुआ")
    case .update(_, let deletions, let insertions, let modifications):
        print("\(insertions.count) नए टास्क जोड़े गए")
        print("\(deletions.count) टास्क डिलीट हुए")
        print("\(modifications.count) टास्क अपडेट हुए")
    case .error(let error):
        print("एरर: \(error)")
    }
}

// नोटिफिकेशन बंद करने के लिए:
// notificationToken.invalidate()

निष्कर्ष

Realm Swift एक शक्तिशाली और तेज़ डेटाबेस है जो iOS ऐप डेवलपमेंट को आसान बनाता है। इस गाइड में दिए गए तरीकों और उदाहरणों के साथ, आप अपने Swift ऐप में Realm को आसानी से इंटीग्रेट कर सकते हैं। अधिक जानकारी के लिए, आधिकारिक Realm Swift डॉक्यूमेंटेशन देखें।