์ค๋ ๋ฉ - Swift SDK
์ด ํ์ด์ง์ ๋ด์ฉ
- ๋ฐ๋ผ์ผ ํ ์ธ ๊ฐ์ง ๊ท์น
- ๋ฐฑ๊ทธ๋ผ์ด๋ ์ฐ๊ธฐ ์ํ
- ๋น๋๊ธฐ ์ฐ๊ธฐ๊ฐ ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๊ธฐ
- ๋น๋๊ธฐ ์ฐ๊ธฐ ์ปค๋ฐ ๋๋ ์ทจ์
- ์ค๋ ๋ ๊ฐ ์ปค๋ฎค๋์ผ์ด์
- ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ Realm์ ์ฌ์ฉํ๊ธฐ ์ํ ์ง๋ ฌ ๋๊ธฐ์ด ๋ง๋ค๊ธฐ
- ์ค๋ ๋ ๊ฐ ์ธ์คํด์ค ์ ๋ฌ
- ์ฌ๋ฌ ์ค๋ ๋์์ ๋์ผํ Realm ์ฌ์ฉ
- Realm ์๋ก๊ณ ์นจ
- ๋๊ฒฐ๋ ๊ฐ์ฒด
- Realm์ ์ค๋ ๋ฉ ๋ชจ๋ธ ์ฌ์ธต ๋ถ์
- Git๊ณผ ๋น๊ต ๋ฐ ๋์กฐ
- ๋ด๋ถ ๊ตฌ์กฐ
- ์์ฝ
- ์ ์ก ๊ฐ๋ฅ, ์ ์ก ๋ถ๊ฐ๋ฅ ๋ฐ ์ค๋ ๋ ์ ํ ์ ํ
iOS ๋ฐ tvOS ์ฑ์ ๋น ๋ฅด๊ณ ์๋ต์ฑ์ด ๋ฐ์ด๋๊ฒ ๋ง๋ค๋ ค๋ฉด ์๊ฐ ์๋ฃ๋ฅผ ๋ฐฐ์นํ๊ณ ์ฌ์ฉ์ ์ํธ์์ฉ์ ์ฒ๋ฆฌํ๋ ๋ฐ ํ์ํ ์ปดํจํ ์๊ฐ๊ณผ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ณ ๋น์ฆ๋์ค ๋ก์ง์ ์คํํ๋ ๋ฐ ํ์ํ ์๊ฐ์ ๊ท ํ์ ๋ง์ถฐ์ผ ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ฑ ๊ฐ๋ฐ์๋ ๋ชจ๋ ์ฌ์ฉ์ ์ธํฐํ์ด์ค ๊ด๋ จ ์์ ์ ์ํ ๋ฉ์ธ ์ค๋ ๋ ๋๋ UI ์ค๋ ๋, ํ๋ ์ ํ ์ด์ ์ ์ํด UI ์ค๋ ๋๋ก ์ ์กํ๊ธฐ ์ ์ ๋ ๋ง์ ์ํฌ๋ก๋๋ฅผ ๊ณ์ฐํ๋ ํ๋ ์ด์์ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋ ๋ฑ ์ฌ๋ฌ ์ค๋ ๋๋ก ์์ ์ ๋ถ์ฐํฉ๋๋ค. ๋ง์ ์์ ์ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋๋ก ์คํ๋ก๋ํจ์ผ๋ก์จ UI ์ค๋ ๋๋ ์ํฌ๋ก๋์ ํฌ๊ธฐ์ ์๊ด์์ด ๋์ ๋ฐ์์ฑ์ ์ ์งํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ต์ฐฉ ์ํ ๋ฐ ๊ฒฝ์ ์ํ์ ๊ฐ์ ๋ฌธ์ ๋ฅผ ๋ฐฉ์งํ๋ฉด์ ์ค๋ ๋๋ก๋ถํฐ ์์ ํ๊ณ ์ฑ๋ฅ์ด ๋ฐ์ด๋๋ฉฐ ์ ์ง ๊ด๋ฆฌ๊ฐ ๊ฐ๋ฅํ ๋ฉํฐ์ค๋ ๋ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ์ ๋งค์ฐ ์ด๋ ค์ธ ์ ์์ต๋๋ค. Realm์ ์ด ๊ณผ์ ์ ๊ฐ์ํํ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค.
ํ
๋ค์๋ ์ฐธ์กฐํ์ธ์.
10.26.0 ๊ธฐ์ค์ผ๋ก, Realm ์ ๋ฐฐ๊ฒฝ ์ฐ๊ธฐ๋ฅผ ์ํํ๊ธฐ ์ํด ๋น๋๊ธฐ ์ฐ๊ธฐ (write) ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค. ๋ฐฑ๊ทธ๋ผ์ด๋ ์ฐ๊ธฐ ์ํ์ ์ฐธ์กฐํ์ธ์. ๋น๋๊ธฐ ์ฐ๊ธฐ (write) ๋ฅผ ์ฌ์ฉํ๋ฉด ์ค๋ ๋ ์ธ์ดํ ์ฐธ์กฐ ๋๋ ๋๊ฒฐ๋ ๊ฐ์ฒด ๋ฅผ ์ ๋ฌํ ํ์๊ฐ ์์ต๋๋ค.
์ด ํ์ด์ง์์๋ ์ค๋ ๋ ์ ์ฒด์์ ์์ญ ํ์ผ๊ณผ ๊ฐ์ฒด๋ฅผ ์๋์ผ๋ก ๊ด๋ฆฌ ํ๋ ๋ฐฉ๋ฒ์ ์ค๋ช ํฉ๋๋ค. Realm ์ Swift ํ์์ ์ฌ์ฉ๋ ์ง์ํฉ๋๋ค. Swift ๋์์ฑ ๊ธฐ๋ฅ์ ์ฌ์ฉํ์ฌ ์์ญ ์ก์ธ์ค ๋ฅผ ๊ด๋ฆฌ ํฉ๋๋ค. Realm์ ํ์์ ์ง์ ์ ๋ํ ๊ฐ์๋ ํ์์์ Realm ์ฌ์ฉ - Swift SDK ๋ฅผ ์ฐธ์กฐํ์ธ์.
๋ฐ๋ผ์ผ ํ ์ธ ๊ฐ์ง ๊ท์น
๋ฉํฐ์ค๋ ๋ ์ฑ์ ์ํ Realm์ ๋๊ตฌ๋ฅผ ์ดํด๋ณด๊ธฐ ์ ์ ๋ค์ ์ธ ๊ฐ์ง ๊ท์น์ ์ดํดํ๊ณ ๋ฐ๋ผ์ผ ํฉ๋๋ค.
- ์ฝ๊ธฐ ์ํด ๋ฝํ์ง ์๋๋ก ํฉ๋๋ค.
- Realm์ MVCC(Multiversion Concurrency Control) ์ํคํ ์ฒ๋ ์ฝ๊ธฐ ์์ ์ ์ ๊ธ ํ์๊ฐ ์์ต๋๋ค. ์ฝ์ ๊ฐ์ ์ ๋๋ก ์์๋๊ฑฐ๋ ๋ถ๋ถ์ ์ผ๋ก ์์ ๋ ์ํ๊ฐ ๋์ง ์์ต๋๋ค. ์ ๊ธ์ด๋ ๋ฎคํ ์ค ์์ด๋ ๋ชจ๋ ์ค๋ ๋์์ ๋์ผํ Realm ํ์ผ์ ์์ ๋กญ๊ฒ ์ฝ์ ์ ์์ต๋๋ค. ๊ฐ ์ค๋ ๋๊ฐ ์ฝ๊ธฐ ์ ์ ์ฐจ๋ก๋ฅผ ๊ธฐ๋ค๋ ค์ผ ํ ์ ์์ผ๋ฏ๋ก ๋ถํ์ํ๊ฒ ์ ๊ทธ๋ ๊ฒ์ ์ฑ๋ฅ ๋ณ๋ชฉ ํ์์ด ๋ ์ ์์ต๋๋ค.
- ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ ์์ฑํ๋ ๊ฒฝ์ฐ UI ์ค๋ ๋์์ ๋๊ธฐ์ ์ฐ๊ธฐ๋ฅผ ๋ฐฉ์งํฉ๋๋ค.
- ๋ชจ๋ ์ค๋ ๋์์ Realm ํ์ผ์ ์ธ ์ ์์ง๋ง ํ ๋ฒ์ ํ๋์ ์์ฑ์๋ง ์์ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ๋๊ธฐ์ ์ฐ๊ธฐ ํธ๋์ญ์ (write transaction)์ ์๋ก๋ฅผ ์ฐจ๋จํฉ๋๋ค. UI ์ค๋ ๋์์ ๋๊ธฐ์ ์ฐ๊ธฐ๋ฅผ ์ํํ๋ฉด ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ ์ฐ๊ธฐ๊ฐ ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๋ ๋์ ์ฑ์ด ์๋ตํ์ง ์๋ ๊ฒ์ฒ๋ผ ๋ณด์ผ ์ ์์ต๋๋ค. Device Sync ๋ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ ์ฐ๊ธฐ๋ฅผ ์ํํ๋ฏ๋ก ๋๊ธฐํ๋ Realm์ด ์๋ UI ์ค๋ ๋์์๋ ๋๊ธฐ์ ์ฐ๊ธฐ๋ฅผ ํผํด์ผ ํฉ๋๋ค.
- ๋ผ์ด๋ธ ๊ฐ์ฒด, ์ปฌ๋ ์ ๋๋ ์์ญ์ ๋ค๋ฅธ ์ค๋ ๋์ ์ ๋ฌํ์ง ์๋๋ก ํฉ๋๋ค.
- ๋ผ์ด๋ธ ๊ฐ์ฒด, ์ปฌ๋ ์ ๋ฐ Realm ์ธ์คํด์ค๋ ์ค๋ ๋์ ํ์ ๋์ด ์์ผ๋ฏ๋ก ํด๋น ์ธ์คํด์ค๊ฐ ์์ฑ๋ ์ค๋ ๋์์๋ง ์ ํจํฉ๋๋ค. ์ค์ง์ ์ผ๋ก ์ด๋ ๋ผ์ด๋ธ ์ธ์คํด์ค๋ฅผ ๋ค๋ฅธ ์ค๋ ๋๋ก ์ ๋ฌํ ์ ์์์ ์๋ฏธํฉ๋๋ค. ๊ทธ๋ฌ๋ Realm์ ์ค๋ ๋ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ณต์ ํ๊ธฐ ์ํ ๋ช ๊ฐ์ง ๋ฉ์ปค๋์ฆ์ ์ ๊ณตํฉ๋๋ค.
๋ฐฑ๊ทธ๋ผ์ด๋ ์ฐ๊ธฐ ์ํ
๋ฒ์ 10.26.0์ ์๋ก์ด ๊ธฐ๋ฅ
writeAsync
์ ์ฌ์ฉํ๋ฉด ์ค๋ ๋ ์ธ์ดํ ์ฐธ์กฐ ๋๋ ๋๊ฒฐ๋ ๊ฐ์ฒด ๋ฅผ ์ ๋ฌํ ํ์๊ฐ ์์ต๋๋ค. ๋์ realm.writeAsync
์(๋ฅผ) ํธ์ถํฉ๋๋ค. ์ฐ๊ธฐ๊ฐ ์๋ฃ๋๊ฑฐ๋ ์คํจํ ํ ์์ค ์ค๋ ๋์์ ์คํํ ๋ฉ์๋์ ์๋ฃ ์ฐจ๋จ์ ์ ๊ณตํ ์ ์์ต๋๋ค.
๋ฐฑ๊ทธ๋ผ์ด๋ ์ฐ๊ธฐ๋ฅผ ์ํํ ๋ ๊ณ ๋ คํด์ผ ํ ์ฌํญ์ ๋๋ค.
๋น๋๊ธฐ ์ฐ๊ธฐ ์ฐจ๋จ์ ์์ญ์ ๋ซ๊ฑฐ๋ ๋ฌดํจํํฉ๋๋ค.
ํธ๋์ญ์ ์ ๋ช ์์ ์ผ๋ก ์ปค๋ฐํ๊ฑฐ๋ ์ทจ์ํ ์ ์์ต๋๋ค.
let realm = try! Realm() // Query for a specific person object on the main thread let people = realm.objects(Person.self) let thisPerson = people.where { $0.name == "Dachary" }.first // Perform an async write to add dogs to that person's dog list. // No need to pass a thread-safe reference or frozen object. realm.writeAsync { thisPerson?.dogs.append(objectsIn: [ Dog(value: ["name": "Ben", "age": 13]), Dog(value: ["name": "Lita", "age": 9]), Dog(value: ["name": "Maui", "age": 1]) ]) } onComplete: { _ in // Confirm the three dogs were successfully added to the person's dogs list XCTAssertEqual(thisPerson!.dogs.count, 3) // Query for one of the dogs we added and see that it is present let dogs = realm.objects(Dog.self) let benDogs = dogs.where { $0.name == "Ben" } XCTAssertEqual(benDogs.count, 1) }
๋น๋๊ธฐ ์ฐ๊ธฐ๊ฐ ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๊ธฐ
SDK๋ ์์ญ ์ด ํ์ฌ ๋น๋๊ธฐ ์ฐ๊ธฐ (write) ๋ฅผ ์ํํ๊ณ ์๋์ง ์ฌ๋ถ๋ฅผ ๋ํ๋ด๋ Bool
์(๋ฅผ) ์ ๊ณตํฉ๋๋ค. isPerformingAsynchronousWriteOperations ๋ณ์๋ ๋ค์ ์ค ํ๋๋ฅผ ํธ์ถํ ํ true
์ด(๊ฐ) ๋ฉ๋๋ค.
writeAsync
beginAsyncWrite
commitAsyncWrite
์์ฝ๋ ๋ชจ๋ ๋น๋๊ธฐ ์ฐ๊ธฐ ์์ ์ด ์๋ฃ๋ ๋๊น์ง ์ด ์ํ๊ฐ ์ ์ง๋ฉ๋๋ค. ์ด ๊ฒฝ์ฐ ์์ญ์ด ๋ซํ๊ฑฐ๋ ๋ฌดํจํ๋๋ ๊ฒ์ ์ฐจ๋จ๋ฉ๋๋ค.
๋น๋๊ธฐ ์ฐ๊ธฐ ์ปค๋ฐ ๋๋ ์ทจ์
๋น๋๊ธฐ ์ฐ๊ธฐ๋ฅผ ์๋ฃํ๋ ค๋ฉด ์ฌ์ฉ์ ๋๋ SDK๊ฐ ๋ ์ค ํ๋๋ฅผ ํธ์ถํด์ผ ํฉ๋๋ค:
writeAsync
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด SDK๊ฐ ํธ๋์ญ์
์ปค๋ฐ ๋๋ ์ทจ์๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค. ์ด๋ ๊ฐ์ฒด ๋ฒ์์ ์ฐ๊ฒฐ๋ ์ํ๋ฅผ ์๋์ผ๋ก ์ ์งํ ํ์ ์์ด ๋น๋๊ธฐ ์ฐ๊ธฐ์ ํธ๋ฆฌํจ์ ์ ๊ณตํฉ๋๋ค. ๊ทธ๋ฌ๋ writeAsync
์ฐจ๋จ ์ค์ ๋ช
์์ ์ผ๋ก ํธ์ถํ๊ฑฐ๋ commitAsyncWrite
cancelAsyncWrite
์(๋ฅผ) ์ํํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๋ฉ์๋ ์ค ํ๋๋ฅผ ํธ์ถํ์ง ์๊ณ ๋ฐํํ๋ฉด writeAsync
๋ ๋ฐํ๋ฉ๋๋ค.
์ฐ๊ธฐ ์ฐจ๋จ์ ์ง์นจ์ ์คํํ ํ ์ฐ๊ธฐ๋ฅผ ์ปค๋ฐํฉ๋๋ค.
์ค๋ฅ๋ฅผ ๋ฐํํฉ๋๋ค.
๋ ๊ฒฝ์ฐ ๋ชจ๋ writeAsync
์์
์ด ์๋ฃ๋ฉ๋๋ค.
๋น๋๊ธฐ ์ฐ๊ธฐ ํธ๋์ญ์
(write transaction)์ ์ปค๋ฐํ๊ฑฐ๋ ์ทจ์ํ ์๊ธฐ๋ฅผ ๋ ํจ๊ณผ์ ์ผ๋ก ์ ์ดํ๋ ค๋ฉด beginAsyncWrite
๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ธ์. ์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ํธ๋์ญ์
์ ๋ช
์์ ์ผ๋ก ์ปค๋ฐํด์ผ ํฉ๋๋ค. ๋น๋๊ธฐ ์ฐ๊ธฐ๋ฅผ ์ปค๋ฐํ์ง ์๊ณ ๋ฐํํ๋ฉด ํธ๋์ญ์
์ด ์ทจ์๋ฉ๋๋ค. beginAsyncWrite
์(๋) cancelAsyncWrite
์ ์ ๋ฌํ ์ ์๋ ID๋ฅผ ๋ฐํํฉ๋๋ค.
commitAsyncWrite
์ฐ๊ธฐ ํธ๋์ญ์
(write transaction)์ ๋น๋๊ธฐ์ ์ผ๋ก ์ปค๋ฐํฉ๋๋ค. ์ด ๋จ๊ณ๋ ๋ฐ์ดํฐ๋ฅผ ์์ญ์ ์ ์งํ๋ ๋จ๊ณ์
๋๋ค. commitAsyncWrite
์(๋) onComplete
๋ธ๋ก์ ๊ฐ์ง ์ ์์ต๋๋ค. ์ด ์ฐจ๋จ์ ์ปค๋ฐ์ด ์๋ฃ๋๊ฑฐ๋ ์ค๋ฅ๋ก ์ธํด ์คํจํ๋ฉด ์์ค ์ค๋ ๋์์ ์คํ๋ฉ๋๋ค.
commitAsyncWrite
์(๋ฅผ) ํธ์ถํ๋ฉด ์ฆ์ ๋ฐํ๋ฉ๋๋ค. ์ด๋ฅผ ํตํด SDK๊ฐ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ I/O๋ฅผ ์ํํ๋ ๋์ ํธ์ถ์๊ฐ ๊ณ์ ์งํํ ์ ์์ต๋๋ค. ์ด ๋ฉ์๋๋ cancelAsyncWrite
์ ์ ๋ฌํ ์ ์๋ ID๋ฅผ ๋ฐํํฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ณด๋ฅ ์ค์ธ ์๋ฃ ์ฐจ๋จ ํธ์ถ์ด ์ทจ์๋ฉ๋๋ค. ์ปค๋ฐ ์์ฒด๋ฅผ ์ทจ์ํ์ง๋ ์์ต๋๋ค.
commitAsyncWrite
์ ๋ํ ์์ฐจ์ ํธ์ถ์ ๊ทธ๋ฃนํํ ์ ์์ต๋๋ค. ํนํ ๋ฐฐ์น๋ ํธ๋์ญ์
์ด ์์ ๊ฒฝ์ฐ ์ด๋ฌํ ํธ์ถ์ ๋ฐฐ์นํ๋ฉด ์ฐ๊ธฐ ์ฑ๋ฅ์ด ํฅ์๋ฉ๋๋ค. ํธ๋์ญ์
๊ทธ๋ฃนํ๋ฅผ ํ์ฉํ๋ ค๋ฉด isGroupingAllowed
๋งค๊ฐ ๋ณ์๋ฅผ true
(์ผ)๋ก ์ค์ ํฉ๋๋ค.
beginAsyncWrite
๋๋ commitAsyncWrite
์์ cancelAsyncWrite
์(๋ฅผ) ํธ์ถํ ์ ์์ต๋๋ค. beginAsyncWrite
์์ ํธ์ถํ๋ฉด ์ ์ฒด ์ฐ๊ธฐ ํธ๋์ญ์
(write transaction)์ด ์ทจ์๋ฉ๋๋ค. commitAsyncWrite
์์ ํธ์ถํ๋ฉด commitAsyncWrite
์ ์ ๋ฌํ์ ์ ์๋ onComplete
์ฐจ๋จ๋ง ์ทจ์๋ฉ๋๋ค. ์ปค๋ฐ ์์ฒด๋ฅผ ์ทจ์ํ์ง๋ ์์ต๋๋ค. ์ทจ์ํ๋ ค๋ beginAsyncWrite
๋๋ commitAsyncWrite
์ ID๊ฐ ํ์ํฉ๋๋ค.
์ค๋ ๋ ๊ฐ ์ปค๋ฎค๋์ผ์ด์
๋ค๋ฅธ ์ค๋ ๋์์ ๋์ผํ Realm ํ์ผ์ ์ก์ธ์คํ๋ ค๋ฉด ์ก์ธ์ค๊ฐ ํ์ํ ๋ชจ๋ ์ค๋ ๋์์ ์์ญ ์ธ์คํด์ค๋ฅผ ์ธ์คํด์คํํด์ผ ํฉ๋๋ค. ๋์ผํ ๊ตฌ์ฑ์ ์ง์ ํ๋ ํ ๋ชจ๋ ์์ญ ์ธ์คํด์ค๋ ๋์คํฌ์ ๋์ผํ ํ์ผ์ ๋งคํ๋ฉ๋๋ค.
๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ Realm์ผ๋ก ์์ ํ ๋ ์ฃผ์ ๊ท์น ์ค ํ๋๋ ๊ฐ์ฒด๋ ์ค๋ ๋์ ํ์ ๋์ด ์๋ค๋ ๊ฒ์ ๋๋ค. ์ฆ, ๋ค๋ฅธ ์ค๋ ๋์์ ์์๋ Realm, ์ปฌ๋ ์ ๋๋ ๊ฐ์ฒด์ ์ธ์คํด์ค์ ์ก์ธ์คํ ์ ์์ต๋๋ค. Realm์ MVCC(Multiversion Concurrency Control) ์ํคํ ์ฒ๋ ๊ฐ์ฒด์ ํ์ฑ ๋ฒ์ ์ด ์ธ์ ๋ ์ง ์ฌ๋ฌ ๊ฐ์ผ ์ ์์์ ์๋ฏธํฉ๋๋ค. ์ค๋ ๋ ์ ํ์ ํด๋น ์ค๋ ๋์ ๋ชจ๋ ์ธ์คํด์ค๊ฐ ๋์ผํ ๋ด๋ถ ๋ฒ์ ์ธ์ง ํ์ธํฉ๋๋ค.
์ค๋ ๋ ๊ฐ์ ํต์ ํด์ผ ํ๋ ๊ฒฝ์ฐ ์ฌ์ฉ ์ฌ๋ก์ ๋ฐ๋ผ ์ฌ๋ฌ ๊ฐ์ง ์ต์ ์ด ์์ต๋๋ค.
๋ ๊ฐ์ ์ค๋ ๋์์ ๊ฐ์ฒด๋ฅผ ์์ ํ๋ ค๋ฉด ๋ ์ค๋ ๋ ๋ชจ๋์์ ๊ฐ์ฒด๋ฅผ ์ฟผ๋ฆฌํฉ๋๋ค.
์ค๋ ๋์ ๋ณ๊ฒฝ ์ฌํญ์ ๋์ํ๋ ค๋ฉด Realm์ ์๋ฆผ์์ฌ์ฉํ์ธ์.
ํ์ฌ ์ค๋ ๋์ ์์ญ ์ธ์คํด์ค์ ์๋ ๋ค๋ฅธ ์ค๋ ๋์์ ์ผ์ด๋ ๋ณํ๋ฅผ ๋ณด๋ ค๋ฉด ์์ญ ์ธ์คํด์ค๋ฅผ ์๋ก ๊ณ ์นจํฉ๋๋ค.
๊ฐ์ฒด์ ๋น ๋ฅธ ์ฝ๊ธฐ ์ ์ฉ ๋ณด๊ธฐ๋ฅผ ๋ค๋ฅธ ์ค๋ ๋๋ก ๋ณด๋ด๋ ค๋ฉด ๊ฐ์ฒด๋ฅผ '๋๊ฒฐ'ํฉ๋๋ค.
์ฑ์์ ๊ฐ์ฒด์ ๋ง์ ์ฝ๊ธฐ ์ ์ฉ ๋ทฐ๋ฅผ ์ ์งํ๊ณ ๊ณต์ ํ๋ ค๋ฉด ์์ญ์์ ๊ฐ์ฒด๋ฅผ ๋ณต์ฌํฉ๋๋ค.
Realm ๋๋ ํน์ ๊ฐ์ฒด์ ์ธ์คํด์ค๋ฅผ ๋ค๋ฅธ ์ค๋ ๋์ ๊ณต์ ํ๊ฑฐ๋ ํ์์ ๊ฒฝ๊ณ๋ฅผ ๋์ด ๊ณต์ ํ๋ ค๋ฉด Realm ์ธ์คํด์ค ๋๋ ๊ฐ์ฒด์ ๋ํ ์ค๋ ๋ ์ธ์ดํ ์ฐธ์กฐ ๋ฅผ ๊ณต์ ํฉ๋๋ค. ์์ธํ ๋ด์ฉ ์ ThreadSafeReference ์ ๋ฌ์ ์ฐธ์กฐํ์ธ์.
๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ Realm์ ์ฌ์ฉํ๊ธฐ ์ํ ์ง๋ ฌ ๋๊ธฐ์ด ๋ง๋ค๊ธฐ
๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ Realm์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์ง๋ ฌ ๋๊ธฐ์ด์ ๋ง๋ญ๋๋ค. Realm์ global()
๋๊ธฐ์ด๊ณผ ๊ฐ์ ๋์ ๋๊ธฐ์ด์์์ ์์ญ ์ฌ์ฉ์ ์ง์ํ์ง ์์ต๋๋ค.
// Initialize a serial queue, and // perform realm operations on it let serialQueue = DispatchQueue(label: "serial-queue") serialQueue.async { let realm = try! Realm(configuration: .defaultConfiguration, queue: serialQueue) // Do something with Realm on the non-main thread }
์ค๋ ๋ ๊ฐ ์ธ์คํด์ค ์ ๋ฌ
Realm
, Results
, List
๋ฐ ๊ด๋ฆฌ๋๋ Objects
์ธ์คํด์ค๋ ์ค๋ ๋๋ก ์ ํ๋ฉ๋๋ค. ์ฆ, ํด๋น ํญ๋ชฉ์ ๋ง๋ ์ค๋ ๋์์๋ง ์ฌ์ฉํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ Realm์ ์ค๋ ๋ ์ธ์ดํ ์ฐธ์กฐ ๋ฉ์ปค๋์ฆ์ ์ ๊ณตํ์ฌ ํ ์ค๋ ๋์์ ์์ฑ๋ ์ธ์คํด์ค๋ฅผ ๋ค๋ฅธ ์ค๋ ๋๋ก ๋ณต์ฌํ ์ ์์ต๋๋ค.
์ ์ก ๊ฐ๋ฅ ์ ํฉ์ฑ
๋ฒ์ 10.20.0์ ์๋ก์ด ๊ธฐ๋ฅ: @ThreadSafe ๋ํผ(wrapper) ๋ฐ ThreadSafeReference๋ Sendable
์ Sendable
์ค์ํฉ๋๋ค.
Swift ์ด์์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ 5.6 @ThreadSafe ์์ฑ ๋ํผ ์ ThreadSafeReference ๊ฐ ๋ชจ๋ Sendable์ ์ค์ํฉ๋๋ค.
@ThreadSafe ๋ํผ(wrapper) ์ฌ์ฉ
๋ฒ์ 10.17.0์ ์๋ก์ด ๊ธฐ๋ฅ
๋ค์๊ณผ ๊ฐ์ด ์ค๋ ๋์ ํ์ ๋ ์ธ์คํด์ค๋ฅผ ๋ค๋ฅธ ์ค๋ ๋๋ก ์ ๋ฌํ ์ ์์ต๋๋ค.
@ThreadSafe
์์ฑ ๋ํผ(wrapper)๋ฅผ ์ฌ์ฉํ์ฌ ์๋ณธ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ๋ณ์๋ฅผ ์ค์ ํฉ๋๋ค. ๋น์ฐํ@ThreadSafe
๋ํ๋ ๋ณ์๋ ํญ์ ์ ํ ์ฌํญ์ ๋๋ค.@ThreadSafe
๋ํ๋ ๋ณ์๋ฅผ ๋ค๋ฅธ ์ค๋ ๋์ ์ ๋ฌํฉ๋๋ค.๋ค๋ฅธ ์ ํ์ฌํญ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก
@ThreadSafe
๋ํ๋ ๋ณ์๋ฅผ ์ฌ์ฉํ์ธ์. ๋ง์ฝ ์ฐธ์กฐ๋ ๊ฐ์ฒด๊ฐ์์ญ์์ ์ ๊ฑฐ๋๋ฉด ์ฐธ์กฐํ๋ ๋ณ์๋ nil์ด ๋ฉ๋๋ค.
let realm = try! Realm() let person = Person(name: "Jane") try! realm.write { realm.add(person) } // Create thread-safe reference to person var personRef = person // @ThreadSafe vars are always optional. If the referenced object is deleted, // the @ThreadSafe var will be nullified. print("Person's name: \(personRef?.name ?? "unknown")") // Pass the reference to a background thread DispatchQueue(label: "background", autoreleaseFrequency: .workItem).async { let realm = try! Realm() try! realm.write { // Resolve within the transaction to ensure you get the // latest changes from other threads. If the person // object was deleted, personRef will be nil. guard let person = personRef else { return // person was deleted } person.name = "Jane Doe" } }
๋ค๋ฅธ ์ค๋ ๋์์ ๊ฐ์ฒด๋ก ์์
ํ๋ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ํด๋น ์ค๋ ๋์์ ๊ฐ์ฒด๋ฅผ ๋ค์ ์ฟผ๋ฆฌํ๋ ๊ฒ์
๋๋ค. ๊ทธ๋ฌ๋ ๊ฐ์ฒด์ ํ๋ผ์ด๋จธ๋ฆฌ ํค๊ฐ ์๋ ๊ฒฝ์ฐ ์ด๋ฅผ ์ฟผ๋ฆฌํ๋ ๊ฒ์ ๊ฐ๋จํ์ง ์์ต๋๋ค. ๊ธฐ๋ณธ ํค๊ฐ ์๋์ง ์ฌ๋ถ์ ๊ด๊ณ์์ด ๋ชจ๋ ๊ฐ์ฒด์ @ThreadSafe
๋ํผ(wrapper)๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์์
๋ค์ ์์์๋ ํจ์ ๋งค๊ฐ๋ณ์์ @ThreadSafe
๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค. ์ด๋ ๋น๋๊ธฐ์ ์ผ๋ก ๋๋ ๋ค๋ฅธ ์ค๋ ๋์์ ์คํ๋ ์ ์๋ ํจ์์ ์ ์ฉํฉ๋๋ค.
ํ
์ฑ์ด async/await
์ปจํ
์คํธ์์ Realm์ ์ก์ธ์คํ๋ ๊ฒฝ์ฐ ์ฝ๋๋ฅผ @MainActor
(์ผ)๋ก ํ์ํ์ฌ ์ค๋ ๋ ๊ด๋ จ ์ถฉ๋์ ๋ฐฉ์งํฉ๋๋ค.
func someLongCallToGetNewName() async -> String { return "Janet" } func loadNameInBackground( person: Person?) async { let newName = await someLongCallToGetNewName() let realm = try! await Realm() try! realm.write { person?.name = newName } } func createAndUpdatePerson() async { let realm = try! await Realm() let person = Person(name: "Jane") try! realm.write { realm.add(person) } await loadNameInBackground(person: person) } await createAndUpdatePerson()
ThreadSafeReference ์ฌ์ฉ(๋ ๊ฑฐ์ ์ค์ํํธ/์ค๋ธ์ ํฐ๋ธ-C)
Realm Swift SDK ๋ฒ์ 10.17.0 ์ด์ ๋๋ ์ค๋ธ์ ํฐ๋ธ-C์์๋ ๋ค์๊ณผ ๊ฐ์ด ์ค๋ ๋์ ํ์ ๋ ์ธ์คํด์ค๋ฅผ ๋ค๋ฅธ ์ค๋ ๋๋ก ์ ๋ฌํ ์ ์์ต๋๋ค.
์ค๋ ๋์ ํ์ ๋ ๊ฐ์ฒด๋ก ThreadSafeReference๋ฅผ ์ด๊ธฐํํฉ๋๋ค.
๋ค๋ฅธ ์ค๋ ๋ ๋๋ ๋๊ธฐ์ด์ ์ฐธ์กฐ๋ฅผ ์ ๋ฌํฉ๋๋ค.
Realm.resolve(_:) ๋ฅผ ํธ์ถํ์ฌ ๋ค๋ฅธ ์ค๋ ๋์ Realm์ ๋ํ ์ฐธ์กฐ๋ฅผ ํด๊ฒฐํฉ๋๋ค. ๋ฐํ๋ ๊ฐ์ฒด๋ฅผ ์ ์์ ์ผ๋ก ์ฌ์ฉํฉ๋๋ค.
์ค์
ThreadSafeReference
๋ ์ ํํ ํ ๋ฒ๋ง ํด๊ฒฐํด์ผ ํฉ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์ฐธ์กฐ ํ ๋น์ด ํด์ ๋ ๋๊น์ง ์์ค ์์ญ์ด ๊ณ ์ ๋ ์ํ๋ก ์ ์ง๋ฉ๋๋ค. ๋ฐ๋ผ์ ThreadSafeReference
๋ ์๋ช
์ด ์งง์์ผ ํฉ๋๋ค.
let person = Person(name: "Jane") let realm = try! Realm() try! realm.write { realm.add(person) } // Create thread-safe reference to person let personRef = ThreadSafeReference(to: person) // Pass the reference to a background thread DispatchQueue(label: "background", autoreleaseFrequency: .workItem).async { let realm = try! Realm() try! realm.write { // Resolve within the transaction to ensure you get the latest changes from other threads guard let person = realm.resolve(personRef) else { return // person was deleted } person.name = "Jane Doe" } }
๋ค๋ฅธ ์ค๋ ๋์์ ๊ฐ์ฒด๋ก ์์
ํ๋ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ํด๋น ์ค๋ ๋์์ ๊ฐ์ฒด๋ฅผ ๋ค์ ์ฟผ๋ฆฌํ๋ ๊ฒ์
๋๋ค. ๊ทธ๋ฌ๋ ๊ฐ์ฒด์ ํ๋ผ์ด๋จธ๋ฆฌ ํค๊ฐ ์๋ ๊ฒฝ์ฐ ์ด๋ฅผ ์ฟผ๋ฆฌํ๋ ๊ฒ์ ๊ฐ๋จํ์ง ์์ต๋๋ค. ๊ธฐ๋ณธ ํค๊ฐ ์๋์ง ์ฌ๋ถ์ ๊ด๊ณ์์ด ๋ชจ๋ ๊ฐ์ฒด์์ ThreadSafeReference
๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋ชฉ๋ก ๋ฐ ๊ฒฐ๊ณผ์ ํจ๊ป ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
๋จ์ ์ ThreadSafeReference
์ ๋ช ๊ฐ์ง ์์ฉ๊ตฌ๊ฐ ํ์ํ๋ค๋ ๊ฒ์
๋๋ค. ๊ฐ์ฒด๊ฐ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์ ๋จ์ ์์ง ์๋๋ก ์ ์ ํ ๋ฒ์์ autoreleaseFrequency
๋ฅผ ์ฌ์ฉํ์ฌ DispatchQueue
์ ๋ชจ๋ ํญ๋ชฉ์ ๋ํํด์ผ ํฉ๋๋ค. ๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ด ์์ฉ๊ตฌ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ํธ์ ํ์ฅ์ ๋ง๋๋ ๊ฒ์ด ๋์์ด ๋ ์ ์์ต๋๋ค.
extension Realm { func writeAsync<T: ThreadConfined>(_ passedObject: T, errorHandler: @escaping ((_ error: Swift.Error) -> Void) = { _ in return }, block: @escaping ((Realm, T?) -> Void)) { let objectReference = ThreadSafeReference(to: passedObject) let configuration = self.configuration DispatchQueue(label: "background", autoreleaseFrequency: .workItem).async { do { let realm = try Realm(configuration: configuration) try realm.write { // Resolve within the transaction to ensure you get the latest changes from other threads let object = realm.resolve(objectReference) block(realm, object) } } catch { errorHandler(error) } } } }
์ด ํ์ฅ์ Realm ํด๋์ค์ writeAsync()
๋ฉ์๋๋ฅผ ์ถ๊ฐํฉ๋๋ค. ์ด ๋ฉ์๋๋ ์ธ์คํด์ค๋ฅผ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋๋ก ์ ๋ฌํฉ๋๋ค.
์์
์ด๋ฉ์ผ ์ฑ์ ๋ง๋ค์๊ณ ๋ฐฑ๊ทธ๋ผ์ด๋์์ ์ฝ์ ๋ชจ๋ ์ด๋ฉ์ผ์ ์ญ์ ํ๊ณ ์ถ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค. ์ด์ ๋ ์ค์ ์ฝ๋๋ก ์ด ์์ ์ ์ํํ ์ ์์ต๋๋ค. ํด๋ก์ ๋ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ ์คํ๋๋ฉฐ ์์ญ๊ณผ ์ ๋ฌ๋ ๊ฐ์ฒด ๋ชจ๋์ ์์ฒด ๋ฒ์ ์ ์์ ํ๋ค๋ ์ ์ ์ ์ํฉ๋๋ค.
let realm = try! Realm() let readEmails = realm.objects(Email.self).where { $0.read == true } realm.writeAsync(readEmails) { (realm, readEmails) in guard let readEmails = readEmails else { // Already deleted return } realm.delete(readEmails) }
์ฌ๋ฌ ์ค๋ ๋์์ ๋์ผํ Realm ์ฌ์ฉ
์ค๋ ๋ ๊ฐ์ ์์ญ ์ธ์คํด์ค๋ฅผ ๊ณต์ ํ ์ ์์ต๋๋ค.
์ฌ๋ฌ ์ค๋ ๋์์ ๋์ผํ Realm ํ์ผ์ ์ฌ์ฉํ๋ ค๋ฉด ๊ฐ ์ค๋ ๋์์ ๋ค๋ฅธ Realm ์ธ์คํด์ค๋ฅผ ์ฝ๋๋ค. ๋์ผํ ๊ตฌ์ฑ ์ ์ฌ์ฉํ๋ ํ ๋ชจ๋ Realm ์ธ์คํด์ค๋ ๋์คํฌ์ ๋์ผํ ํ์ผ์ ๋งคํ๋ฉ๋๋ค.
Realm ์๋ก๊ณ ์นจ
์์ญ์ ์ด๋ฉด ๊ฐ์ฅ ์ต๊ทผ์ ์ฑ๊ณตํ ์ฐ๊ธฐ ์ปค๋ฐ์ด ๋ฐ์๋๋ฉฐ ์๋ก ๊ณ ์นจํ ๋๊น์ง ํด๋น ๋ฒ์ ์ผ๋ก ์ ์ง๋ฉ๋๋ค. ์ด๋ ์์ญ์ด ๋ค์ ์๋ก ๊ณ ์นจ๊น์ง ๋ค๋ฅธ ์ค๋ ๋์์ ๋ฐ์ํ ๋ณ๊ฒฝ ์ฌํญ์ ๋ณผ ์ ์์์ ์๋ฏธํฉ๋๋ค. UI ์ค๋ ๋์ ์์ญ, ๋ ์ ํํ๊ฒ๋ ์ด๋ฒคํธ ๋ฃจํ ์ค๋ ๋์ ์์ญ์ ํด๋น ์ค๋ ๋์ ๋ฃจํ๊ฐ ์์๋ ๋ ์๋์ผ๋ก ์๋ก ๊ณ ์ณ์ง๋๋ค. ๊ทธ๋ฌ๋ ๋ฃจํ ์ค๋ ๋์ ์กด์ฌํ์ง ์๊ฑฐ๋ ์๋ ์๋ก ๊ณ ์นจ์ด ๋นํ์ฑํ๋ ์์ญ ์ธ์คํด์ค๋ ์๋์ผ๋ก ์๋ก ๊ณ ์นจํด์ผ ํฉ๋๋ค.
if (![realm autorefresh]) { [realm refresh] }
if (!realm.autorefresh) { // Manually refresh realm.refresh() }
๋๊ฒฐ๋ ๊ฐ์ฒด
์ค๋ ๋์ ์ ํ๋ ๋ผ์ด๋ธ ๊ฐ์ฒด๋ ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ ์๋ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ผ๋ถ ์ฑ(์์: ๋ฐ์ํ ์ด๋ฒคํธ ์คํธ๋ฆผ ๊ธฐ๋ฐ ์ํคํ ์ฒ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ์ฑ)์ ์ต์ข ์ ์ผ๋ก UI ์ค๋ ๋์ ๋๋ฌํ๊ธฐ ์ ์ ์ฒ๋ฆฌ๋ฅผ ์ํด ๋ถ๋ณ์ ๋ณต์ฌ๋ณธ์ ์ฌ๋ฌ ์ค๋ ๋๋ก ์ ์กํด์ผ ํฉ๋๋ค. ๋งค๋ฒ ๋ฅ ์นดํผ๋ฅผ ๋ง๋๋ ๊ฒ์ ๋น์ฉ์ด ๋ง์ด ๋ค๊ณ ์์ญ์ ๋ผ์ด๋ธ ์ธ์คํด์ค๋ฅผ ์ค๋ ๋ ๊ฐ์ ๊ณต์ ํ๋ ๊ฒ์ ํ์ฉํ์ง ์์ต๋๋ค. ์ด ๊ฒฝ์ฐ ๊ฐ์ฒด, ์ปฌ๋ ์ ๋ฐ ์์ญ์ ๋๊ฒฐ ๋ฐ ๋๊ฒฐ ํด์ ํ ์ ์์ต๋๋ค.
๋๊ฒฐํ๋ฉด ํน์ ๊ฐ์ฒด, ์ปฌ๋ ์ ๋๋ ์์ญ์ ๋ํ ๋ณ๊ฒฝํ ์ ์๋ ๋ณด๊ธฐ๊ฐ ์์ฑ๋ฉ๋๋ค. ๋๊ฒฐ๋ ๊ฐ์ฒด, ์ปฌ๋ ์ ๋๋ ์์ญ์ ์ฌ์ ํ ๋์คํฌ์ ์กด์ฌํ๋ฉฐ ๋ค๋ฅธ ์ค๋ ๋๋ก ์ ๋ฌ๋ ๋ ๋ฅ ์นดํผ๊ฐ ํ์ ์์ต๋๋ค. ์ค๋ ๋ ๋ฌธ์ ์ ๋ํ ๊ฑฑ์ ์์ด ์ค๋ ๋ ๊ฐ์ ๋๊ฒฐ๋ ๊ฐ์ฒด๋ฅผ ์์ ๋กญ๊ฒ ๊ณต์ ํ ์ ์์ต๋๋ค. ์์ญ์ ๋๊ฒฐํ๋ฉด ๊ทธ ํ์ ๊ฐ์ฒด๋ ๋๊ฒฐ๋ฉ๋๋ค.
ํ
Swift Actor์ ํจ๊ป ThreadSafeReference ์ฌ์ฉ
Realm์ ํ์ฌ ์ค์ํํธ ํ์์์ thaw()
์(๋ฅผ) ํจ๊ป ์ฌ์ฉํ๋ ๊ฒ์ ์ง์ํ์ง ์์ต๋๋ค. ํ์์ ๊ฒฝ๊ณ๋ฅผ ๋์ด Realm ๋ฐ์ดํฐ๋ก ์์
ํ๋ ค๋ฉด ๋๊ฒฐ๋ ๊ฐ์ฒด ๋์ ThreadSafeReference
๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์์ธํ ๋ด์ฉ์ ThreadSafeReference ๊ณต์ ๋ฅผ ์ฐธ์กฐํ์ธ์.
๋๊ฒฐ๋ ๊ฐ์ฒด๋ ๋ผ์ด๋ธ ์ํ๊ฐ ์๋๋ฉฐ ์๋์ผ๋ก ์ ๋ฐ์ดํธ๋์ง ์์ต๋๋ค. ์ด๋ ์ฌ์ค์ ์ ์ง ์์ ์ ๊ฐ์ฒด ์ํ์ ๋ํ ์ค๋ ์ท์ ๋๋ค. ๊ฐ์ฒด๋ฅผ ๋๊ฒฐ ํด์ ํ๋ฉด ๋๊ฒฐ๋ ๊ฐ์ฒด์ ๋ผ์ด๋ธ ๋ฒ์ ์ด ๋ฐํ๋ฉ๋๋ค.
// Get an immutable copy of the realm that can be passed across threads RLMRealm *frozenRealm = [realm freeze]; RLMResults *dogs = [Dog allObjectsInRealm:realm]; // You can freeze collections RLMResults *frozenDogs = [dogs freeze]; // You can still read from frozen realms RLMResults *frozenDogs2 = [Dog allObjectsInRealm:frozenRealm]; Dog *dog = [dogs firstObject]; // You can freeze objects Dog *frozenDog = [dog freeze]; // To modify frozen objects, you can thaw them // You can thaw collections RLMResults *thawedDogs = [dogs thaw]; // You can thaw objects Dog *thawedDog = [dog thaw]; // You can thaw frozen realms RLMRealm *thawedRealm = [realm thaw];
let realm = try! Realm() // Get an immutable copy of the realm that can be passed across threads let frozenRealm = realm.freeze() assert(frozenRealm.isFrozen) let people = realm.objects(Person.self) // You can freeze collections let frozenPeople = people.freeze() assert(frozenPeople.isFrozen) // You can still read from frozen realms let frozenPeople2 = frozenRealm.objects(Person.self) assert(frozenPeople2.isFrozen) let person = people.first! assert(!person.realm!.isFrozen) // You can freeze objects let frozenPerson = person.freeze() assert(frozenPerson.isFrozen) // Frozen objects have a reference to a frozen realm assert(frozenPerson.realm!.isFrozen)
๋๊ฒฐ๋ ๊ฐ์ฒด๋ก ์์ ํ ๋ ๋ค์ ์ค ํ๋๋ฅผ ์๋ํ๋ฉด ์์ธ๊ฐ ๋ฐ์ํฉ๋๋ค.
๋๊ฒฐ๋ ์์ญ์์ ์ฐ๊ธฐ ํธ๋์ญ์ (write transaction) ์ด๊ธฐ
๋๊ฒฐ๋ ๊ฐ์ฒด ์์
๋๊ฒฐ๋ ์์ญ, ์ปฌ๋ ์ ๋๋ ๊ฐ์ฒด์ ๋ณ๊ฒฝ ๋ฆฌ์ค๋ ์ถ๊ฐ
isFrozen
์(๋ฅผ) ์ฌ์ฉํ์ฌ ๊ฐ์ฒด๊ฐ ๋๊ฒฐ๋์๋์ง ํ์ธํ ์ ์์ต๋๋ค ์ด๋ ํญ์ ์ค๋ ๋๋ก๋ถํฐ ์์ ํฉ๋๋ค.
if ([realm isFrozen]) { // ... }
if (realm.isFrozen) { // ... }
๋๊ฒฐ๋ ๊ฐ์ฒด๋ ํด๋น ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ผ์ด๋ธ ์์ญ์ด ์ด๋ ค ์๋ ํ ์ ํจํฉ๋๋ค. ๋ฐ๋ผ์ ๋ชจ๋ ์ค๋ ๋๊ฐ ๋๊ฒฐ๋ ๊ฐ์ฒด๋ก ์๋ฃ๋ ๋๊น์ง ๋ผ์ด๋ธ ์์ญ์ ๋ซ์ง ์๋๋ก ํฉ๋๋ค. ๋ผ์ด๋ธ ์์ญ์ด ๋ซํ๊ธฐ ์ ์ ๋๊ฒฐ๋ ์์ญ์ ๋ซ์ ์ ์์ต๋๋ค.
์ค์
๋๊ฒฐ๋ ๊ฐ์ฒด๋ฅผ ์บ์ฑํ๋ ๊ฒฝ์ฐ
๋๊ฒฐ๋ ๊ฐ์ฒด๋ฅผ ๋๋ฌด ๋ง์ด ์บ์ฑํ๋ฉด ์์ญ ํ์ผ ํฌ๊ธฐ์ ๋ถ์ ์ ์ธ ์ํฅ์ ๋ฏธ์น ์ ์์ต๋๋ค. '๋๋ฌด ๋ง์'์ ํน์ ๋์ ์ฅ์น์ Realm ๊ฐ์ฒด์ ํฌ๊ธฐ์ ๋ฐ๋ผ ๋ค๋ฆ ๋๋ค. ๋ง์ ์์ ๋ฒ์ ์ ์บ์ํด์ผ ํ๋ ๊ฒฝ์ฐ์๋ ํ์ํ ๋ฒ์ ์ ์์ญ ์ธ๋ถ๋ก ๋ณต์ฌํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๋๊ฒฐ๋ ๊ฐ์ฒด ์์
๋๊ฒฐ๋ ๊ฐ์ฒด๋ฅผ ์์ ํ๋ ค๋ฉด ํด๋น ๊ฐ์ฒด๋ฅผ ๋๊ฒฐ ํด์ ํด์ผ ํฉ๋๋ค. ๋๊ฒฐ๋์ง ์์ ์์ญ์์ ์ฟผ๋ฆฌํ ๋ค์ ์์ ํ ์๋ ์์ต๋๋ค. ๋ผ์ด๋ธ ๊ฐ์ฒด, ์ปฌ๋ ์
๋๋ ์์ญ์์ thaw
์(๋ฅผ) ํธ์ถํ๋ฉด ์๋์ผ๋ก ๋ฐํ๋ฉ๋๋ค.
๊ฐ์ฒด ๋๋ ์ปฌ๋ ์ ์ ๋๊ฒฐ ํด์ ํ๋ฉด ๊ฐ์ฒด ๋๋ ์ปฌ๋ ์ ์ด ์ฐธ์กฐํ๋ ์์ญ๋ ๋๊ฒฐ ํด์ ๋ฉ๋๋ค.
// Read from a frozen realm let frozenPeople = frozenRealm.objects(Person.self) // The collection that we pull from the frozen realm is also frozen assert(frozenPeople.isFrozen) // Get an individual person from the collection let frozenPerson = frozenPeople.first! // To modify the person, you must first thaw it // You can also thaw collections and realms let thawedPerson = frozenPerson.thaw() // Check to make sure this person is valid. An object is // invalidated when it is deleted from its managing realm, // or when its managing realm has invalidate() called on it. assert(thawedPerson?.isInvalidated == false) // Thawing the person also thaws the frozen realm it references assert(thawedPerson!.realm!.isFrozen == false) // Let's make the code easier to follow by naming the thawed realm let thawedRealm = thawedPerson!.realm! // Now, you can modify the todo try! thawedRealm.write { thawedPerson!.name = "John Michael Kane" }
๋๊ฒฐ๋ ์ปฌ๋ ์ ์ ์ถ๊ฐ
๋๊ฒฐ๋ ์ปฌ๋ ์ ์ ์ถ๊ฐํ ๋๋ ์ปฌ๋ ์ ๊ณผ ์ถ๊ฐํ๋ ค๋ ๊ฐ์ฒด๋ฅผ ๋ชจ๋ ๋๊ฒฐ ํด์ ํด์ผ ํฉ๋๋ค. ์ด ์์์์๋ ๋๊ฒฐ๋ Realm์ ์๋ ๋ ๊ฐ์ฒด๋ฅผ ์ฟผ๋ฆฌํฉ๋๋ค.
๊ฐ ๊ฐ์ฒด์ ๋ชฉ๋ก ์์ฑ์ด ์๋ ์ฌ๋ ๊ฐ์ฒด์ ๋๋ค.
๊ฐ ๊ฐ์ฒด
์ฌ๋์ ๊ฐ ๋ชฉ๋ก ์ปฌ๋ ์ ์ ๊ฐ๋ฅผ ์ถ๊ฐํ๊ธฐ ์ ์ ๋ ๊ฐ์ฒด๋ฅผ ๋ชจ๋ ๋๊ฒฐ ํด์ ํด์ผ ํฉ๋๋ค. ์ฌ๋ ๊ฐ์ฒด๋ง ๋๊ฒฐ ํด์ ํ๊ณ ๊ฐ๋ ๋๊ฒฐ ํด์ ํ์ง ์์ผ๋ฉด Realm์์ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
์ค๋ ๋ ๊ฐ์ ๊ณ ์ ๋ ๊ฐ์ฒด๋ฅผ ์ ๋ฌํ ๋๋ ๋์ผํ ๊ท์น์ด ์ ์ฉ๋ฉ๋๋ค. ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ๋ UI๋ฅผ ์ฐจ๋จํ๋ ๋์ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์์ ํจ์๋ฅผ ํธ์ถํ์ฌ ์ผ๋ถ ์์ ์ ์ํํ๋ ๊ฒฝ์ฐ์ผ ์ ์์ต๋๋ค.
// Get a copy of frozen objects. // Here, we're getting them from a frozen realm, // but you might also be passing them across threads. let frozenTimmy = frozenRealm.objects(Person.self).where { $0.name == "Timmy" }.first! let frozenLassie = frozenRealm.objects(Dog.self).where { $0.name == "Lassie" }.first! // Confirm the objects are frozen. assert(frozenTimmy.isFrozen == true) assert(frozenLassie.isFrozen == true) // Thaw the frozen objects. You must thaw both the object // you want to append and the collection you want to append it to. let thawedTimmy = frozenTimmy.thaw() let thawedLassie = frozenLassie.thaw() let realm = try! Realm() try! realm.write { thawedTimmy?.dogs.append(thawedLassie!) } XCTAssertEqual(thawedTimmy?.dogs.first?.name, "Lassie")
Realm์ ์ค๋ ๋ฉ ๋ชจ๋ธ ์ฌ์ธต ๋ถ์
Realm์ MVCC(Multiversion Concurrency Control) ๋ฅผ ํตํด ์ค๋ ๋ ์ ๋ฐ์ ๊ฑธ์ณ ์์ ํ๊ณ ๋น ๋ฅด๋ฉฐ ์ ๊ธ ์๋ ๋์ ์ก์ธ์ค๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ํคํ ์ฒ.
Git๊ณผ ๋น๊ต ๋ฐ ๋์กฐ
Git ๊ณผ ๊ฐ์ ๋ถ์ฐ๋ ๋ฒ์ ๊ด๋ฆฌ ์์คํ ์ ์ต์ํ ๊ฒฝ์ฐ ๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฏธ MVCC๋ฅผ ์ง๊ด์ ์ผ๋ก ์ดํดํ๊ณ ์์ ์ ์์ต๋๋ค. Git์ ๋ ๊ฐ์ง ๊ธฐ๋ณธ ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ปค๋ฐ, ์ฆ ์์์ฑ ์ฐ๊ธฐ์ ๋๋ค.
๋ธ๋์น, ์ฆ ์ปค๋ฐ ๊ธฐ๋ก์ ๋ค๋ฅธ ๋ฒ์ ์ ๋๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก Realm์ ํธ๋์ญ์ ํํ์ ์์ ๋จ์๋ก ์ปค๋ฐ๋ ์ฐ๊ธฐ๊ฐ ์์ต๋๋ค. ๋ํ Realm์ ๋ธ๋์น์ฒ๋ผ ์ฃผ์ด์ง ์๊ฐ์ ๋ค์ํ ๋ฒ์ ์ ํ์คํ ๋ฆฌ๋ฅผ ๊ฐ๊ณ ์์ต๋๋ค.
ํฌํฌ๋ฅผ ํตํ ๋ฐฐํฌ์ ๋ถ์ฐ์ ์ ๊ทน์ ์ผ๋ก ์ง์ํ๋ Git๊ณผ ๋ฌ๋ฆฌ ์์ญ์๋ ํญ์ ํ๋์ ์ต์ ๋ฒ์ ๋ง ์๊ณ ํญ์ ์ต์ ๋ฒ์ ์ ํค๋์ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋กํฉ๋๋ค. ์์ญ์ ์ด์ ๋ฒ์ ์ ์ธ ์ ์์ต๋๋ค. ์ฆ, ๋ฐ์ดํฐ๊ฐ ํ๋์ ์ต์ ๋ฒ์ ์ผ๋ก ์๋ ด๋๋ค๋ ์๋ฏธ์ ๋๋ค.
๋ด๋ถ ๊ตฌ์กฐ
์์ญ์ B-ํธ๋ฆฌ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํ๋ฉ๋๋ค. ์ต์์ ๋ ธ๋๋ ์์ญ์ ๋ฒ์ ์ ๋ํ๋ ๋๋ค. ํ์ ๋ ธ๋๋ ํด๋น ๋ฒ์ ์ ์์ญ์ ์๋ ๊ฐ์ฒด์ ๋๋ค. ์์ญ์ Git์ด HEAD ์ปค๋ฐ์ ๋ํ ํฌ์ธํฐ๋ฅผ ๊ฐ๋ ๊ฒ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ต์ ๋ฒ์ ์ ๋ํ ํฌ์ธํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค.
Realm์ ์ฐ๊ธฐ ์ค ๋ณต์ฌ(copy-on-write) ๊ธฐ์ ์ ์ฌ์ฉํ์ฌ ๊ฒฉ๋ฆฌ ๋ฅผ ๋ณด์ฅํฉ๋๋ค. ๋ฐ ๋ด๊ตฌ์ฑ . ๋ณ๊ฒฝ์ ์ํํ๋ฉด Realm์ ํธ๋ฆฌ์ ๊ด๋ จ ๋ถ๋ถ์ ๋ณต์ฌํ์ฌ ๊ธฐ๋กํฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ Realm์ ๋ ๋จ๊ณ๋ก ๋ณ๊ฒฝ ์ฌํญ์ ์ปค๋ฐํฉ๋๋ค.
Realm์ ๋ณ๊ฒฝ ์ฌํญ์ ๋์คํฌ์ ๊ธฐ๋กํ๊ณ ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ํ์ธํฉ๋๋ค.
๊ทธ๋ฐ ๋ค์ Realm์ ์ต์ ๋ฒ์ ํฌ์ธํฐ๊ฐ ์๋ก ์์ฑ๋ ๋ฒ์ ์ ๊ฐ๋ฆฌํค๋๋ก ์ค์ ํฉ๋๋ค.
2๋จ๊ณ ์ปค๋ฐ ํ๋ก์ธ์ค๋ ์ฐ๊ธฐ๊ฐ ๋์ค์ ์คํจํ๋๋ผ๋ ํธ๋ฆฌ์ ๊ด๋ จ ๋ถ๋ถ ๋ณต์ฌ๋ณธ์ด ๋ณ๊ฒฝ๋์๊ธฐ ๋๋ฌธ์ ์๋ ๋ฒ์ ์ด ์ด๋ค ์์ผ๋ก๋ ์์๋์ง ์๋๋ก ๋ณด์ฅํฉ๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ์์ญ์ ๋ฃจํธ ํฌ์ธํฐ๋ ์ ๋ฒ์ ์ด ์ ํจํ๋ค๋ ๊ฒ์ด ๋ณด์ฅ๋ ๋๊น์ง ์๋ณธ ๋ฒ์ ์ ๊ฐ๋ฆฌํต๋๋ค.
์์
๋ค์ ๋ค์ด์ด๊ทธ๋จ์ ์ปค๋ฐ ํ๋ก์ธ์ค๋ฅผ ๋ณด์ฌ์ค๋๋ค.
์์ญ์ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก ๋์ด ์์ต๋๋ค. ์์ญ์๋ ์ต์ ๋ฒ์ ์ธ V1์ ๋ํ ํฌ์ธํฐ๊ฐ ์์ต๋๋ค.
๊ธฐ๋ก ์ Realm์ V1์ ๊ธฐ๋ฐ์ผ๋ก V2 ๋ฒ์ ์ ์๋ก ๋ง๋ญ๋๋ค. Realm์ ์์ ์ ์ํด ๊ฐ์ฒด์ ๋ณต์ฌ๋ณธ์ ๋ง๋ค๊ณ (A 1, C 1) ์์ ๋์ง ์์ ๊ฐ์ฒด์ ๋ํ ๋งํฌ๋ ๊ณ์ํด์ ์๋ณธ ๋ฒ์ (B, D)์ ๊ฐ๋ฆฌํต๋๋ค.
์ปค๋ฐ์ ํ์ธํ ํ Realm์ ํฌ์ธํฐ๋ฅผ ์๋ก์ด ์ต์ ๋ฒ์ ์ธ V2๋ก ์ ๋ฐ์ดํธํฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ Realm์ ๋ ์ด์ ํธ๋ฆฌ์ ์ฐ๊ฒฐ๋์ง ์์ ์ค๋๋ ๋ ธ๋๋ฅผ ๋ฒ๋ฆฝ๋๋ค.
Realm์ ๋ฉ๋ชจ๋ฆฌ ๋งคํ๊ณผ ๊ฐ์ ์ ๋ก ์นดํผ ๊ธฐ์ ์ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค. ์์ญ์์ ๊ฐ์ ์ฝ์ผ๋ฉด ๋ณต์ฌ๋ณธ์ด ์๋ ์ฌ์ค์ ์ค์ ๋์คํฌ ๊ฐ์ ๋ณด๋ ๊ฒ์ ๋๋ค. ์ด๋ ๋ผ์ด๋ธ ๊ฐ์ฒด์ ๊ธฐ๋ณธ์ด๋ฉฐ ๋์คํฌ ์ฐ๊ธฐ๊ฐ ๊ฒ์ฆ๋ ํ ์์ญ ํค๋ ํฌ์ธํฐ๊ฐ ์ ๋ฒ์ ์ ๊ฐ๋ฆฌํค๋๋ก ์ค์ ํ ์ ์๋ ์ด์ ์ด๊ธฐ๋ ํฉ๋๋ค.
์์ฝ
Realm์ ๋ค์ ์ธ ๊ฐ์ง ๊ท์น์ ๋ฐ๋ฅด๋ฉด ๊ฐ๋จํ๊ณ ์์ ํ ๋ฉํฐ์ค๋ ๋ ์ฝ๋๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
์ฝ๊ธฐ ์ํด ๋ฝ์ ํ์ง ๋ง์ธ์.
๋ฐฑ๊ทธ๋ผ์ด๋ ์ค๋ ๋์ ์ฐ๊ฑฐ๋ Device Sync๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ UI ์ค๋ ๋์ ์ฐ๊ธฐ ๋ฐฉ์ง
๋ค๋ฅธ ์ค๋ ๋์ ๋ผ์ด๋ธ ๊ฐ์ฒด๋ฅผ ์ ๋ฌํ์ง ๋ง์ธ์.
๊ฐ ์ฌ์ฉ ์ฌ๋ก์ ๋ฐ๋ผ ์ค๋ ๋ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ณต์ ํ๋ ์ ์ ํ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
์์ญ ์ธ์คํด์ค์ ๋ค๋ฅธ ์ค๋ ๋์ ๋ํ ๋ณ๊ฒฝ ์ฌํญ์ ๋ณด๋ ค๋ฉด '๋ฃจํ' ์ค๋ ๋์ ์กด์ฌํ์ง ์๊ฑฐ๋ ์๋ ์๋ก ๊ณ ์นจ์ด ๋นํ์ฑํ๋ ์ธ์คํด์ค๋ฅผ ์๋์ผ๋ก ์๋ก ๊ณ ์นจํฉ๋๋ค.
๋ฐ์ํ ์ด๋ฒคํธ ์คํธ๋ฆผ ๊ธฐ๋ฐ ์ํคํ ์ฒ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ์ฑ์ ๊ฒฝ์ฐ ๊ฐ์ฒด, ์ปฌ๋ ์ ๋ฐ ์์ญ์ ๋๊ฒฐํ์ฌ ์์ ๋ณต์ฌ๋ณธ์ ๋ค๋ฅธ ์ค๋ ๋์ ํจ์จ์ ์ผ๋ก ์ ๋ฌํ์ฌ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
Realm์ ๋ฉํฐ๋ฒ์ ผ ๋์์ฑ ์ ์ด(MVCC) ์ํคํ ์ฒ๋ Git๊ณผ ์ ์ฌํฉ๋๋ค. ๊ทธ๋ฌ๋ Git๊ณผ๋ ๋ฌ๋ฆฌ Realm์ ๊ฐ ์์ญ์ ๋ํด ํ๋์ ์ค์ ์ต์ ๋ฒ์ ๋ง ์์ต๋๋ค.
Realm์ ๊ฒฉ๋ฆฌ ๋ฐ ๋ด๊ตฌ์ฑ์ ๋ณด์ฅํ๊ธฐ ์ํด ๋ ๋จ๊ณ๋ก ์ปค๋ฐํฉ๋๋ค.
์ ์ก ๊ฐ๋ฅ, ์ ์ก ๋ถ๊ฐ๋ฅ ๋ฐ ์ค๋ ๋ ์ ํ ์ ํ
Realm Swift SDK ํผ๋ธ๋ฆญ API์๋ ํฌ๊ฒ ์ธ ๊ฐ์ง ๋ฒ์ฃผ๋ก ๋ถ๋ฅ๋๋ ์ ํ์ด ํฌํจ๋์ด ์์ต๋๋ค.
์ ์ก ๊ฐ๋ฅ
์ ์ก ๋ถ๊ฐ๋ฅ ๋ฐ ์ค๋ ๋ ์ ํ ์์
์ค๋ ๋ ์ ํ
์ ์ก์ด ๋ถ๊ฐ๋ฅํ ์ ํ๊ณผ ์ค๋ ๋ ๊ฐ์ ์ค๋ ๋๋ก ์ ํ๋์ง ์์ ์ ํ์ ๊ณต์ ํ ์ ์์ง๋ง ์ด๋ฅผ ๋๊ธฐํํด์ผ ํฉ๋๋ค.
์ค๋ ๋์ ํ์ ๋ ์ ํ์ ๋๊ฒฐ๋์ง ์๋ ํ ๊ฒฉ๋ฆฌ ์ปจํ ์คํธ์ ํ์ ๋ฉ๋๋ค. ๋๊ธฐํ๋ฅผ ์ฌ์ฉํด๋ ์ด๋ฌํ ์ปจํ ์คํธ ๊ฐ์ ์ ๋ฌํ ์ ์์ต๋๋ค.
์ ์ก ๊ฐ๋ฅ | Non-Sendable | ์ค๋ ๋ ์ ํ |
---|---|---|
AnyBSON | RLMAppConfiguration | AnyRealmCollection |
AsyncOpen | RLMFindOneAndModifyOptions | AnyRealmValue |
AsyncOpenSubscription | RLMFindOptions | ๋ชฉ๋ก |
RLM API ํค ์ธ์ฆ | RLM ๋คํธ์ํฌ ์ ์ก | Map |
RLMApp | RLMRequest | MutableSet |
RLMAsyncOpenTask | RLMResponse | ํ๋ก์ ์ |
RLMChangeStream | RLMSyncConfiguration | RLMArray |
RLMCompensatingWriteInfo | RLMSyncTimeoutOptions | RLMChangeStream |
RLMCredentials | RLMDictionary | |
RLMDecimal128 | RLMDictionaryChange | |
RLMEmailPasswordAuth | RLMEmbeddedObject | |
RLM Max ํค | RLM ๋งํฌ ์ค๋ธ์ ํธ | |
RLM Min ํค | RLMObject | |
RLM Mongo ํด๋ผ์ด์ธํธ | RLM ์์ฑ ๋ณ๊ฒฝ | |
RLM Mongo ์ปฌ๋ ์ | RLMRealm | |
RLM Mongo ๋ฐ์ดํฐ๋ฒ ์ด์ค | RLMResults | |
RLM ๊ฐ์ฒด ID | RLM ์น์ | |
RLM ๊ฐ์ฒด ์คํค๋ง | RLM ์น์ ๊ฒฐ๊ณผ | |
RLM ์งํ ์๋ฆผ | RLM ์น์ ๊ฒฐ๊ณผ ๋ณ๊ฒฝ ์ธํธ | |
RLM ์งํ ์๋ฆผ ํ ํฐ | RLMSet | |
RLM ์์ฑ | RLM Sync ๊ตฌ๋ | |
RLMPropertyDescriptor | RLM Sync ์๋ธ์คํฌ๋ฆฝ์ ์ธํธ | |
RLM ์ ๊ณต์ ํด๋ผ์ด์ธํธ | RealmOptional | |
RLM ํธ์ ํด๋ผ์ด์ธํธ | RealmProperty | |
RLM ์คํค๋ง | ||
RLMSortDescriptor | ||
RLM Sync ์ค๋ฅ ์ก์ ํ ํฐ | ||
RLM Sync ๊ด๋ฆฌ์ | ||
RLM Sync ์ธ์ | ||
RLMThreadSafeReference | ||
RLMUpdateResult | ||
RLM ์ฌ์ฉ์ | ||
RLM ์ฌ์ฉ์ API ํค | ||
RL ์ฌ์ฉ์ ID | ||
RLM ์ฌ์ฉ์ ํ๋กํ | ||
ThreadSafe |