🌟 Core Data: Apple의 강력한 데이터 관리 프레임워크

Core Data는 단순한 데이터베이스가 아니야. Apple이 만든 객체 그래프 관리 프레임워크라고 할 수 있어.
쉽게 말하면, Swift 객체를 그대로 저장하고 불러올 수 있게 해주는 마법 같은 도구지! ✨

많은 개발자들이 Core Data를 어려워하는데, 사실 개념만 제대로 이해하면 정말 편리한 친구야.

📚 Core Data의 핵심 개념들

🛠️ Core Data 시작하기

먼저 Data Model 파일을 만들어보자. File → New → File → Data Model을 선택하면 .xcdatamodeld 파일이 생성돼.
보통 프로젝트 이름과 같은 이름으로 만들어. 예를 들어 'MyApp.xcdatamodeld' 이런 식으로!

import CoreData

class CoreDataManager {
    static let shared = CoreDataManager()
    
    private init() {}
    
    // Persistent Container 생성
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "MyApp")
        container.loadPersistentStores { description, error in
            if let error = error {
                fatalError("Core Data 로드 실패: \(error)")
            }
        }
        return container
    }()
    
    // Context 접근
    var context: NSManagedObjectContext {
        return persistentContainer.viewContext
    }
    
    // 저장 메서드
    func saveContext() {
        let context = persistentContainer.viewContext
        if context.hasChanges {
            do {
                try context.save()
                print("✅ 데이터 저장 성공!")
            } catch {
                print("❌ 저장 실패: \(error)")
            }
        }
    }
}

위 코드는 Core Data를 사용하기 위한 기본 매니저 클래스야. 싱글톤 패턴으로 만들어서 앱 전체에서 하나의 인스턴스만 사용하도록 했어. 🎯

예를 들어 간단한 메모 앱을 만든다고 가정해볼게. 'Memo'라는 Entity를 만들고 다음 속성들을 추가해보자:

func createMemo(title: String, content: String) {
    let context = CoreDataManager.shared.context
    
    // 새로운 Memo 객체 생성
    let memo = Memo(context: context)
    memo.id = UUID()
    memo.title = title
    memo.content = content
    memo.createdAt = Date()
    memo.isImportant = false
    
    // 저장
    CoreDataManager.shared.saveContext()
    print("📝 메모 생성 완료: \(title)")
}

// 사용 예시
createMemo(title: "장보기", content: "우유, 계란, 빵 사기")

보다시피 일반 Swift 객체를 다루는 것처럼 자연스럽게 사용할 수 있어! 이게 Core Data의 큰 장점이야. 🌟

func fetchAllMemos() -> [Memo] {
    let context = CoreDataManager.shared.context
    let fetchRequest: NSFetchRequest<Memo> = Memo.fetchRequest()
    
    // 정렬 기준 추가 (최신순)
    let sortDescriptor = NSSortDescriptor(key: "createdAt", ascending: false)
    fetchRequest.sortDescriptors = [sortDescriptor]
    
    do {
        let memos = try context.fetch(fetchRequest)
        print("📚 총 \(memos.count)개의 메모를 불러왔어요")
        return memos
    } catch {
        print("❌ 불러오기 실패: \(error)")
        return []
    }
}

// 특정 조건으로 검색
func fetchImportantMemos() -> [Memo] {
    let context = CoreDataManager.shared.context
    let fetchRequest: NSFetchRequest<Memo> = Memo.fetchRequest()
    
    // 조건 추가 (중요 표시된 메모만)
    fetchRequest.predicate = NSPredicate(format: "isImportant == %@", NSNumber(value: true))
    
    do {
        return try context.fetch(fetchRequest)
    } catch {
        print("❌ 검색 실패: \(error)")
        return []
    }
}

func updateMemo(memo: Memo, newTitle: String, newContent: String) {
    memo.title = newTitle
    memo.content = newContent
    
    // 저장만 하면 끝!
    CoreDataManager.shared.saveContext()
    print("✏️ 메모 수정 완료")
}

// 중요 표시 토글
func toggleImportant(memo: Memo) {
    memo.isImportant.toggle()
    CoreDataManager.shared.saveContext()
}

객체의 속성을 바꾸고 save()만 호출하면 돼. 정말 직관적이지? 😄

func deleteMemo(memo: Memo) {
    let context = CoreDataManager.shared.context
    context.delete(memo)
    CoreDataManager.shared.saveContext()
    print("🗑️ 메모 삭제 완료")
}

// 모든 메모 삭제
func deleteAllMemos() {
    let context = CoreDataManager.shared.context
    let fetchRequest: NSFetchRequest<NSFetchRequestResult> = Memo.fetchRequest()
    let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
    
    do {
        try context.execute(deleteRequest)
        CoreDataManager.shared.saveContext()
        print("🗑️ 모든 메모 삭제 완료")
    } catch {
        print("❌ 삭제 실패: \(error)")
    }
}

🔗 관계(Relationship) 설정하기

Core Data의 진짜 강력함은 Entity 간의 관계를 설정할 수 있다는 거야!
예를 들어 'Category'와 'Memo'의 관계를 만들어볼까? 📂

.xcdatamodeld에서 'Category' Entity를 만들고:
• name (String)
• color (String)
• memos (Relationship → Memo, Type: To Many)

그리고 'Memo' Entity에:
• category (Relationship → Category, Type: To One)

func createCategory(name: String, color: String) -> Category {
    let context = CoreDataManager.shared.context
    let category = Category(context: context)
    category.name = name
    category.color = color
    CoreDataManager.shared.saveContext()
    return category
}

func createMemoWithCategory(title: String, content: String, category: Category) {
    let context = CoreDataManager.shared.context
    let memo = Memo(context: context)
    memo.id = UUID()
    memo.title = title
    memo.content = content
    memo.createdAt = Date()
    memo.category = category  // 관계 설정!
    
    CoreDataManager.shared.saveContext()
}

// 특정 카테고리의 모든 메모 가져오기
func fetchMemos(in category: Category) -> [Memo] {
    // Category 객체의 memos 속성으로 바로 접근 가능!
    return category.memos?.allObjects as? [Memo] ?? []
}

관계를 설정하면 양방향으로 쉽게 접근할 수 있어. Category에서 Memo로, Memo에서 Category로! 🔄

⚡ Core Data 성능 최적화 팁

func batchInsertMemos(count: Int) {
    let context = CoreDataManager.shared.context
    
    context.performAndWait {
        for i in 0..<count {
            let memo = Memo(context: context)
            memo.id = UUID()
            memo.title = "메모 \(i)"
            memo.content = "내용 \(i)"
            memo.createdAt = Date()
            
            // 100개마다 저장
            if i % 100 == 0 {
                try? context.save()
                context.reset() // 메모리 정리
            }
        }
        try? context.save()
    }
}

func fetchOptimized() -> [Memo] {
    let fetchRequest: NSFetchRequest<Memo> = Memo.fetchRequest()
    
    // 배치 크기 설정 (한 번에 20개씩)
    fetchRequest.fetchBatchSize = 20
    
    // 필요한 속성만 가져오기
    fetchRequest.propertiesToFetch = ["title", "createdAt"]
    
    // 결과 개수 제한
    fetchRequest.fetchLimit = 100
    
    return try! CoreDataManager.shared.context.fetch(fetchRequest)
}

func performBackgroundTask() {
    let container = CoreDataManager.shared.persistentContainer
    
    container.performBackgroundTask { context in
        // 백그라운드에서 실행되는 작업
        for i in 0..<1000 {
            let memo = Memo(context: context)
            memo.title = "Background Memo \(i)"
            memo.createdAt = Date()
        }
        
        try? context.save()
        
        DispatchQueue.main.async {
            print("✅ 백그라운드 작업 완료!")
        }
    }
}

🗄️ SQLite: 직접 제어하는 관계형 데이터베이스

이제 SQLite에 대해 알아볼 차례야! SQLite는 세계에서 가장 많이 사용되는 데이터베이스 엔진이야.
스마트폰, 브라우저, 임베디드 시스템 등 정말 많은 곳에서 사용되고 있어. 📱💻

Core Data와 달리 SQLite는 직접 SQL 쿼리를 작성해서 데이터를 다뤄.
더 복잡하지만, 그만큼 세밀한 제어가 가능하고 성능 최적화도 자유롭게 할 수 있지!

🎯 SQLite의 특징

🚀 iOS에서 SQLite 사용하기

iOS에는 SQLite가 기본으로 내장되어 있어! 별도 설치 없이 바로 사용할 수 있어. 😊
하지만 C API를 직접 사용하는 건 좀 복잡하니까, 보통 래퍼 라이브러리를 사용해.

대표적인 라이브러리들:

오늘은 가장 Swift답고 사용하기 쉬운 SQLite.swift로 예제를 만들어볼게! 🎯

Xcode에서 File → Add Packages... → 검색창에 입력:
https://github.com/stephencelis/SQLite.swift

또는 CocoaPods를 사용한다면:

pod 'SQLite.swift', '~> 0.14.1'

import SQLite

class SQLiteManager {
    static let shared = SQLiteManager()
    private var db: Connection?
    
    // 테이블 정의
    let memos = Table("memos")
    let id = Expression<Int64>("id")
    let title = Expression<String>("title")
    let content = Expression<String>("content")
    let createdAt = Expression<Date>("created_at")
    let isImportant = Expression<Bool>("is_important")
    
    private init() {
        do {
            let path = NSSearchPathForDirectoriesInDomains(
                .documentDirectory, .userDomainMask, true
            ).first!
            
            let dbPath = "\(path)/myapp.sqlite3"
            db = try Connection(dbPath)
            print("✅ SQLite 연결 성공: \(dbPath)")
            
            createTable()
        } catch {
            print("❌ SQLite 연결 실패: \(error)")
        }
    }
    
    // 테이블 생성
    private func createTable() {
        do {
            try db?.run(memos.create(ifNotExists: true) { table in
                table.column(id, primaryKey: .autoincrement)
                table.column(title)
                table.column(content)
                table.column(createdAt)
                table.column(isImportant, defaultValue: false)
            })
            print("✅ 테이블 생성 완료")
        } catch {
            print("❌ 테이블 생성 실패: \(error)")
        }
    }
}

위 코드에서 주목할 점은 Expression을 사용해서 타입 안정성을 확보했다는 거야!
일반 SQL 문자열보다 훨씬 안전하고 Swift스러운 방식이지. 🛡️

📝 Create - 데이터 삽입

extension SQLiteManager {
    func insertMemo(title: String, content: String, isImportant: Bool = false) -> Int64? {
        do {
            let insert = memos.insert(
                self.title <- title,
                self.content <- content,
                self.createdAt <- Date(),
                self.isImportant <- isImportant
            )
            
            let rowId = try db?.run(insert)
            print("✅ 메모 추가 성공! ID: \(rowId ?? 0)")
            return rowId
        } catch {
            print("❌ 메모 추가 실패: \(error)")
            return nil
        }
    }
}

// 사용 예시
let memoId = SQLiteManager.shared.insertMemo(
    title: "SQLite 공부하기",
    content: "오늘은 SQLite를 배워보자!",
    isImportant: true
)

📖 Read - 데이터 조회

// 메모 구조체 정의
struct MemoModel {
    let id: Int64
    let title: String
    let content: String
    let createdAt: Date
    let isImportant: Bool
}

extension SQLiteManager {
    // 모든 메모 조회
    func fetchAllMemos() -> [MemoModel] {
        var result: [MemoModel] = []
        
        do {
            let query = memos.order(createdAt.desc)
            
            for memo in try db!.prepare(query) {
                let model = MemoModel(
                    id: memo[id],
                    title: memo[title],
                    content: memo[content],
                    createdAt: memo[createdAt],
                    isImportant: memo[isImportant]
                )
                result.append(model)
            }
            
            print("📚 총 \(result.count)개의 메모를 불러왔어요")
        } catch {
            print("❌ 조회 실패: \(error)")
        }
        
        return result
    }
    
    // 특정 메모 조회
    func fetchMemo(byId memoId: Int64) -> MemoModel? {
        do {
            let query = memos.filter(id == memoId)
            
            if let memo = try db?.pluck(query) {
                return MemoModel(
                    id: memo[id],
                    title: memo[title],
                    content: memo[content],
                    createdAt: memo[createdAt],
                    isImportant: memo[isImportant]
                )
            }
        } catch {
            print("❌ 조회 실패: \(error)")
        }
        
        return nil
    }
    
    // 중요 메모만 조회
    func fetchImportantMemos() -> [MemoModel] {
        var result: [MemoModel] = []
        
        do {
            let query = memos
                .filter(isImportant == true)
                .order(createdAt.desc)
            
            for memo in try db!.prepare(query) {
                let model = MemoModel(
                    id: memo[id],
                    title: memo[title],
                    content: memo[content],
                    createdAt: memo[createdAt],
                    isImportant: memo[isImportant]
                )
                result.append(model)
            }
        } catch {
            print("❌ 조회 실패: \(error)")
        }
        
        return result
    }
    
    // 검색 기능
    func searchMemos(keyword: String) -> [MemoModel] {
        var result: [MemoModel] = []
        
        do {
            let query = memos.filter(
                title.like("%\(keyword)%") || content.like("%\(keyword)%")
            )
            
            for memo in try db!.prepare(query) {
                let model = MemoModel(
                    id: memo[id],
                    title: memo[title],
                    content: memo[content],
                    createdAt: memo[createdAt],
                    isImportant: memo[isImportant]
                )
                result.append(model)
            }
            
            print("🔍 '\(keyword)' 검색 결과: \(result.count)개")
        } catch {
            print("❌ 검색 실패: \(error)")
        }
        
        return result
    }
}

SQLite.swift의 쿼리 빌더는 정말 직관적이야! filter, order, limit 같은 메서드를 체이닝해서 사용할 수 있어. 🔗

✏️ Update - 데이터 수정

extension SQLiteManager {
    func updateMemo(id memoId: Int64, title: String?, content: String?, isImportant: Bool?) -> Bool {
        do {
            let memo = memos.filter(id == memoId)
            var setters: [Setter] = []
            
            if let title = title {
                setters.append(self.title <- title)
            }
            if let content = content {
                setters.append(self.content <- content)
            }
            if let isImportant = isImportant {
                setters.append(self.isImportant <- isImportant)
            }
            
            let updated = try db?.run(memo.update(setters))
            
            if updated ?? 0 > 0 {
                print("✅ 메모 수정 성공!")
                return true
            } else {
                print("⚠️ 수정할 메모를 찾을 수 없어요")
                return false
            }
        } catch {
            print("❌ 수정 실패: \(error)")
            return false
        }
    }
    
    // 중요 표시 토글
    func toggleImportant(id memoId: Int64) -> Bool {
        do {
            let memo = memos.filter(id == memoId)
            
            // 현재 값을 가져와서 반대로 설정
            if let current = try db?.pluck(memo) {
                let newValue = !current[isImportant]
                try db?.run(memo.update(isImportant <- newValue))
                print("✅ 중요 표시 토글 완료: \(newValue)")
                return true
            }
        } catch {
            print("❌ 토글 실패: \(error)")
        }
        
        return false
    }
}

🗑️ Delete - 데이터 삭제

extension SQLiteManager {
    func deleteMemo(id memoId: Int64) -> Bool {
        do {
            let memo = memos.filter(id == memoId)
            let deleted = try db?.run(memo.delete())
            
            if deleted ?? 0 > 0 {
                print("✅ 메모 삭제 성공!")
                return true
            } else {
                print("⚠️ 삭제할 메모를 찾을 수 없어요")
                return false
            }
        } catch {
            print("❌ 삭제 실패: \(error)")
            return false
        }
    }
    
    // 모든 메모 삭제
    func deleteAllMemos() -> Bool {
        do {
            try db?.run(memos.delete())
            print("✅ 모든 메모 삭제 완료!")
            return true
        } catch {
            print("❌ 전체 삭제 실패: \(error)")
            return false
        }
    }
    
    // 오래된 메모 삭제 (30일 이상)
    func deleteOldMemos(days: Int = 30) -> Bool {
        do {
            let cutoffDate = Calendar.current.date(
                byAdding: .day,
                value: -days,
                to: Date()
            )!
            
            let oldMemos = memos.filter(createdAt < cutoffDate)
            let deleted = try db?.run(oldMemos.delete())
            
            print("✅ \(deleted ?? 0)개의 오래된 메모 삭제 완료!")
            return true
        } catch {
            print("❌ 삭제 실패: \(error)")
            return false
        }
    }
}

🔧 고급 SQLite 기능들

📊 집계 함수 사용하기

extension SQLiteManager {
    // 전체 메모 개수
    func getMemoCount() -> Int {
        do {
            let count = try db?.scalar(memos.count) ?? 0
            return count
        } catch {
            print("❌ 개수 조회 실패: \(error)")
            return 0
        }
    }
    
    // 중요 메모 개수
    func getImportantMemoCount() -> Int {
        do {
            let count = try db?.scalar(memos.filter(isImportant == true).count) ?? 0
            return count
        } catch {
            return 0
        }
    }
    
    // 통계 정보
    func getStatistics() -> (total: Int, important: Int, today: Int) {
        let total = getMemoCount()
        let important = getImportantMemoCount()
        
        let today = Calendar.current.startOfDay(for: Date())
        let todayMemos = memos.filter(createdAt >= today)
        let todayCount = (try? db?.scalar(todayMemos.count)) ?? 0
        
        return (total, important, todayCount)
    }
}

🔄 트랜잭션 처리

여러 작업을 하나의 단위로 묶어서 처리할 때 트랜잭션을 사용해. 중간에 오류가 발생하면 전체를 롤백할 수 있어! 🔒

extension SQLiteManager {
    func transferMemos(fromCategory: String, toCategory: String) -> Bool {
        do {
            try db?.transaction {
                // 여러 작업을 하나의 트랜잭션으로
                let memosToUpdate = memos.filter(title.like("%\(fromCategory)%"))
                
                for memo in try db!.prepare(memosToUpdate) {
                    let newTitle = memo[title].replacingOccurrences(
                        of: fromCategory,
                        with: toCategory
                    )
                    
                    let update = memos
                        .filter(id == memo[id])
                        .update(title <- newTitle)
                    
                    try db?.run(update)
                }
            }
            
            print("✅ 카테고리 이동 완료!")
            return true
        } catch {
            print("❌ 트랜잭션 실패 (롤백됨): \(error)")
            return false
        }
    }
}

🔍 인덱스 생성으로 성능 향상

extension SQLiteManager {
    func createIndexes() {
        do {
            // title 컬럼에 인덱스 생성
            try db?.run(memos.createIndex(title, ifNotExists: true))
            
            // 복합 인덱스 (여러 컬럼)
            try db?.run(memos.createIndex(isImportant, createdAt, ifNotExists: true))
            
            print("✅ 인덱스 생성 완료!")
        } catch {
            print("❌ 인덱스 생성 실패: \(error)")
        }
    }
}

🔐 데이터베이스 암호화

민감한 데이터를 저장한다면 암호화는 필수야! SQLCipher를 사용하면 데이터베이스 전체를 암호화할 수 있어.

// SQLCipher 사용 예시
import SQLite

class SecureSQLiteManager {
    private var db: Connection?
    
    init(password: String) {
        do {
            let path = // ... 경로 설정
            db = try Connection(path)
            
            // 암호화 키 설정
            try db?.execute("PRAGMA key = '\(password)'")
            
            print("✅ 암호화된 데이터베이스 연결 성공!")
        } catch {
            print("❌ 연결 실패: \(error)")
        }
    }
}

🔄 데이터 마이그레이션: 버전 관리의 핵심

앱을 업데이트하다 보면 데이터 구조를 바꿔야 할 때가 있어.
새로운 기능을 추가하거나, 기존 구조를 개선하거나... 이럴 때 마이그레이션이 필요해! 🔧

마이그레이션을 잘못하면 사용자 데이터가 날아갈 수 있으니 정말 조심해야 해. 😰

📦 Core Data 마이그레이션

새 버전이 만들어지면 .xcdatamodeld 파일 안에 여러 버전이 생겨.
예: MyApp.xcdatamodeld → MyApp.xcdatamodel, MyApp 2.xcdatamodel

현재 버전을 설정하려면 .xcdatamodeld 파일을 선택하고 File Inspector에서 "Current"를 변경해.

예를 들어 Memo Entity에 'category' 속성을 추가한다고 해보자:

// 변경 전 (버전 1)
Entity: Memo
- id: UUID
- title: String
- content: String
- createdAt: Date

// 변경 후 (버전 2)
Entity: Memo
- id: UUID
- title: String
- content: String
- createdAt: Date
- category: String  // 새로 추가!

lazy var persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "MyApp")
    
    // 마이그레이션 옵션 설정
    let description = container.persistentStoreDescriptions.first
    description?.shouldMigrateStoreAutomatically = true
    description?.shouldInferMappingModelAutomatically = true
    
    container.loadPersistentStores { description, error in
        if let error = error {
            fatalError("마이그레이션 실패: \(error)")
        }
        print("✅ 마이그레이션 성공!")
    }
    
    return container
}()

🔧 복잡한 마이그레이션: Mapping Model

데이터 변환이 필요한 복잡한 경우에는 Mapping Model을 만들어야 해.

import CoreData

class MemoMigrationPolicy: NSEntityMigrationPolicy {
    // 마이그레이션 중 호출되는 메서드
    override func createDestinationInstances(
        forSource sInstance: NSManagedObject,
        in mapping: NSEntityMapping,
        manager: NSMigrationManager
    ) throws {
        try super.createDestinationInstances(
            forSource: sInstance,
            in: mapping,
            manager: manager
        )
        
        // 커스텀 로직
        guard let destinationMemo = manager.destinationInstances(
            forEntityMappingName: mapping.name,
            sourceInstances: [sInstance]
        ).first else { return }
        
        // 예: 기존 데이터를 변환해서 새 속성에 설정
        if let oldTitle = sInstance.value(forKey: "title") as? String {
            // 제목에서 카테고리 추출
            let category = extractCategory(from: oldTitle)
            destinationMemo.setValue(category, forKey: "category")
        }
    }
    
    private func extractCategory(from title: String) -> String {
        // 제목 앞부분에서 카테고리 추출하는 로직
        if title.hasPrefix("[업무]") {
            return "업무"
        } else if title.hasPrefix("[개인]") {
            return "개인"
        }
        return "기타"
    }
}

🔄 SQLite 마이그레이션

SQLite는 마이그레이션을 직접 관리해야 해. 하지만 더 세밀한 제어가 가능하지! 💪

버전 관리 시스템 구축

class SQLiteMigrationManager {
    private let db: Connection
    private let currentVersion = 3  // 현재 앱의 DB 버전
    
    init(db: Connection) {
        self.db = db
    }
    
    func migrate() throws {
        let userVersion = try db.scalar("PRAGMA user_version") as! Int64
        
        print("📦 현재 DB 버전: \(userVersion)")
        print("🎯 목표 버전: \(currentVersion)")
        
        if userVersion < currentVersion {
            try performMigration(from: Int(userVersion), to: currentVersion)
        }
    }
    
    private func performMigration(from: Int, to: Int) throws {
        // 트랜잭션으로 안전하게 마이그레이션
        try db.transaction {
            for version in (from + 1)...to {
                print("🔄 버전 \(version)으로 마이그레이션 중...")
                try migrateToVersion(version)
            }
            
            // 버전 업데이트
            try db.run("PRAGMA user_version = \(to)")
            print("✅ 마이그레이션 완료!")
        }
    }
    
    private func migrateToVersion(_ version: Int) throws {
        switch version {
        case 1:
            try migrateToV1()
        case 2:
            try migrateToV2()
        case 3:
            try migrateToV3()
        default:
            break
        }
    }
    
    // 버전 1: 초기 테이블 생성
    private func migrateToV1() throws {
        try db.run("""
            CREATE TABLE IF NOT EXISTS memos (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                title TEXT NOT NULL,
                content TEXT NOT NULL,
                created_at DATETIME NOT NULL
            )
        """)
    }
    
    // 버전 2: is_important 컬럼 추가
    private func migrateToV2() throws {
        try db.run("""
            ALTER TABLE memos 
            ADD COLUMN is_important INTEGER DEFAULT 0
        """)
    }
    
    // 버전 3: category 컬럼 추가 및 기존 데이터 변환
    private func migrateToV3() throws {
        // 1. 새 컬럼 추가
        try db.run("""
            ALTER TABLE memos 
            ADD COLUMN category TEXT DEFAULT '기타'
        """)
        
        // 2. 기존 데이터 변환
        try db.run("""
            UPDATE memos 
            SET category = CASE 
                WHEN title LIKE '[업무]%' THEN '업무'
                WHEN title LIKE '[개인]%' THEN '개인'
                ELSE '기타'
            END
        """)
        
        // 3. 인덱스 생성
        try db.run("""
            CREATE INDEX IF NOT EXISTS idx_category 
            ON memos(category)
        """)
    }
}

안전한 마이그레이션 전략

class SafeMigrationManager {
    func migrateWithBackup() throws {
        let fileManager = FileManager.default
        let documentsPath = NSSearchPathForDirectoriesInDomains(
            .documentDirectory, .userDomainMask, true
        ).first!
        
        let dbPath = "\(documentsPath)/myapp.sqlite3"
        let backupPath = "\(documentsPath)/myapp_backup.sqlite3"
        
        // 1. 백업 생성
        print("💾 백업 생성 중...")
        if fileManager.fileExists(atPath: backupPath) {
            try fileManager.removeItem(atPath: backupPath)
        }
        try fileManager.copyItem(atPath: dbPath, toPath: backupPath)
        
        do {
            // 2. 마이그레이션 시도
            let db = try Connection(dbPath)
            let migrationManager = SQLiteMigrationManager(db: db)
            try migrationManager.migrate()
            
            // 3. 성공 시 백업 삭제
            print("✅ 마이그레이션 성공! 백업 삭제")
            try fileManager.removeItem(atPath: backupPath)
            
        } catch {
            // 4. 실패 시 백업 복구
            print("❌ 마이그레이션 실패! 백업 복구 중...")
            try fileManager.removeItem(atPath: dbPath)
            try fileManager.copyItem(atPath: backupPath, toPath: dbPath)
            
            throw error
        }
    }
}

🎨 SwiftUI와 데이터 영속화 통합

요즘 iOS 개발은 SwiftUI가 대세지! SwiftUI와 데이터 영속화를 어떻게 통합하는지 알아보자. 🚀

🌟 Core Data + SwiftUI

SwiftUI는 Core Data와 정말 잘 어울려! @FetchRequest를 사용하면 자동으로 UI가 업데이트돼.

import SwiftUI
import CoreData

struct MemoListView: View {
    // Core Data 환경 변수
    @Environment(\.managedObjectContext) private var viewContext
    
    // 자동으로 데이터를 가져오고 변경사항 감지
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Memo.createdAt, ascending: false)],
        animation: .default
    )
    private var memos: FetchedResults<Memo>
    
    @State private var showingAddSheet = false
    
    var body: some View {
        NavigationView {
            List {
                ForEach(memos) { memo in
                    MemoRow(memo: memo)
                }
                .onDelete(perform: deleteMemos)
            }
            .navigationTitle("메모 📝")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { showingAddSheet = true }) {
                        Label("추가", systemImage: "plus")
                    }
                }
            }
            .sheet(isPresented: $showingAddSheet) {
                AddMemoView()
                    .environment(\.managedObjectContext, viewContext)
            }
        }
    }
    
    private func deleteMemos(offsets: IndexSet) {
        withAnimation {
            offsets.map { memos[$0] }.forEach(viewContext.delete)
            
            do {
                try viewContext.save()
            } catch {
                print("❌ 삭제 실패: \(error)")
            }
        }
    }
}

struct MemoRow: View {
    @ObservedObject var memo: Memo
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            HStack {
                Text(memo.title ?? "제목 없음")
                    .font(.headline)
                
                Spacer()
                
                if memo.isImportant {
                    Image(systemName: "star.fill")
                        .foregroundColor(.yellow)
                }
            }
            
            Text(memo.content ?? "")
                .font(.subheadline)
                .foregroundColor(.secondary)
                .lineLimit(2)
            
            Text(memo.createdAt ?? Date(), style: .date)
                .font(.caption)
                .foregroundColor(.gray)
        }
        .padding(.vertical, 4)
    }
}

메모 추가 뷰

struct AddMemoView: View {
    @Environment(\.managedObjectContext) private var viewContext
    @Environment(\.dismiss) private var dismiss
    
    @State private var title = ""
    @State private var content = ""
    @State private var isImportant = false
    
    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("메모 정보")) {
                    TextField("제목", text: $title)
                    
                    TextEditor(text: $content)
                        .frame(height: 200)
                    
                    Toggle("중요 표시", isOn: $isImportant)
                }
            }
            .navigationTitle("새 메모")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("취소") {
                        dismiss()
                    }
                }
                
                ToolbarItem(placement: .confirmationAction) {
                    Button("저장") {
                        saveMemo()
                    }
                    .disabled(title.isEmpty)
                }
            }
        }
    }
    
    private func saveMemo() {
        let newMemo = Memo(context: viewContext)
        newMemo.id = UUID()
        newMemo.title = title
        newMemo.content = content
        newMemo.createdAt = Date()
        newMemo.isImportant = isImportant
        
        do {
            try viewContext.save()
            dismiss()
        } catch {
            print("❌ 저장 실패: \(error)")
        }
    }
}

필터링과 검색

struct FilteredMemoListView: View {
    @Environment(\.managedObjectContext) private var viewContext
    
    @State private var searchText = ""
    @State private var showImportantOnly = false
    
    var body: some View {
        VStack {
            // 검색 바
            HStack {
                Image(systemName: "magnifyingglass")
                    .foregroundColor(.gray)
                
                TextField("검색...", text: $searchText)
                
                if !searchText.isEmpty {
                    Button(action: { searchText = "" }) {
                        Image(systemName: "xmark.circle.fill")
                            .foregroundColor(.gray)
                    }
                }
            }
            .padding(8)
            .background(Color(.systemGray6))
            .cornerRadius(10)
            .padding(.horizontal)
            
            // 필터 토글
            Toggle("중요 메모만", isOn: $showImportantOnly)
                .padding(.horizontal)
            
            // 동적 FetchRequest
            MemoList(
                searchText: searchText,
                showImportantOnly: showImportantOnly
            )
        }
        .navigationTitle("메모 검색")
    }
}

struct MemoList: View {
    let searchText: String
    let showImportantOnly: Bool
    
    @FetchRequest private var memos: FetchedResults<Memo>
    
    init(searchText: String, showImportantOnly: Bool) {
        self.searchText = searchText
        self.showImportantOnly = showImportantOnly
        
        // 동적으로 predicate 생성
        var predicates: [NSPredicate] = []
        
        if !searchText.isEmpty {
            let searchPredicate = NSPredicate(
                format: "title CONTAINS[cd] %@ OR content CONTAINS[cd] %@",
                searchText, searchText
            )
            predicates.append(searchPredicate)
        }
        
        if showImportantOnly {
            let importantPredicate = NSPredicate(format: "isImportant == %@", NSNumber(value: true))
            predicates.append(importantPredicate)
        }
        
        let compoundPredicate = predicates.isEmpty ? nil : NSCompoundPredicate(andPredicateWithSubpredicates: predicates)
        
        _memos = FetchRequest<Memo>(
            sortDescriptors: [NSSortDescriptor(keyPath: \Memo.createdAt, ascending: false)],
            predicate: compoundPredicate,
            animation: .default
        )
    }
    
    var body: some View {
        List(memos) { memo in
            MemoRow(memo: memo)
        }
    }
}

📱 SQLite + SwiftUI

SQLite를 SwiftUI와 함께 사용하려면 ObservableObject를 활용해야 해.

import SwiftUI
import Combine

class MemoViewModel: ObservableObject {
    @Published var memos: [MemoModel] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private let sqliteManager = SQLiteManager.shared
    
    func loadMemos() {
        isLoading = true
        
        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
            let fetchedMemos = self?.sqliteManager.fetchAllMemos() ?? []
            
            DispatchQueue.main.async {
                self?.memos = fetchedMemos
                self?.isLoading = false
            }
        }
    }
    
    func addMemo(title: String, content: String, isImportant: Bool = false) {
        guard let id = sqliteManager.insertMemo(
            title: title,
            content: content,
            isImportant: isImportant
        ) else {
            errorMessage = "메모 추가 실패"
            return
        }
        
        loadMemos()  // 새로고침
    }
    
    func deleteMemo(id: Int64) {
        if sqliteManager.deleteMemo(id: id) {
            memos.removeAll { $0.id == id }
        } else {
            errorMessage = "메모 삭제 실패"
        }
    }
    
    func searchMemos(keyword: String) {
        isLoading = true
        
        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
            let results = self?.sqliteManager.searchMemos(keyword: keyword) ?? []
            
            DispatchQueue.main.async {
                self?.memos = results
                self?.isLoading = false
            }
        }
    }
}

struct SQLiteMemoListView: View {
    @StateObject private var viewModel = MemoViewModel()
    @State private var showingAddSheet = false
    @State private var searchText = ""
    
    var body: some View {
        NavigationView {
            VStack {
                // 검색 바
                SearchBar(text: $searchText, onSearch: {
                    if searchText.isEmpty {
                        viewModel.loadMemos()
                    } else {
                        viewModel.searchMemos(keyword: searchText)
                    }
                })
                
                if viewModel.isLoading {
                    ProgressView("로딩 중...")
                } else {
                    List {
                        ForEach(viewModel.memos, id: \.id) { memo in
                            SQLiteMemoRow(memo: memo)
                        }
                        .onDelete { indexSet in
                            indexSet.forEach { index in
                                let memo = viewModel.memos[index]
                                viewModel.deleteMemo(id: memo.id)
                            }
                        }
                    }
                }
            }
            .navigationTitle("메모 📝")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button(action: { showingAddSheet = true }) {
                        Label("추가", systemImage: "plus")
                    }
                }
            }
            .sheet(isPresented: $showingAddSheet) {
                AddSQLiteMemoView(viewModel: viewModel)
            }
            .onAppear {
                viewModel.loadMemos()
            }
            .alert("오류", isPresented: .constant(viewModel.errorMessage != nil)) {
                Button("확인") {
                    viewModel.errorMessage = nil
                }
            } message: {
                Text(viewModel.errorMessage ?? "")
            }
        }
    }
}

struct SQLiteMemoRow: View {
    let memo: MemoModel
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            HStack {
                Text(memo.title)
                    .font(.headline)
                
                Spacer()
                
                if memo.isImportant {
                    Image(systemName: "star.fill")
                        .foregroundColor(.yellow)
                }
            }
            
            Text(memo.content)
                .font(.subheadline)
                .foregroundColor(.secondary)
                .lineLimit(2)
            
            Text(memo.createdAt, style: .date)
                .font(.caption)
                .foregroundColor(.gray)
        }
        .padding(.vertical, 4)
    }
}

struct SearchBar: View {
    @Binding var text: String
    let onSearch: () -> Void
    
    var body: some View {
        HStack {
            Image(systemName: "magnifyingglass")
                .foregroundColor(.gray)
            
            TextField("검색...", text: $text)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .onSubmit {
                    onSearch()
                }
            
            if !text.isEmpty {
                Button(action: {
                    text = ""
                    onSearch()
                }) {
                    Image(systemName: "xmark.circle.fill")
                        .foregroundColor(.gray)
                }
            }
        }
        .padding(.horizontal)
    }
}

🔒 데이터 보안과 프라이버시

사용자 데이터를 다룰 때는 보안이 정말 중요해! 특히 민감한 정보를 저장한다면 더더욱. 🔐
iOS에서 데이터를 안전하게 보호하는 방법들을 알아보자.

🛡️ Data Protection API

iOS는 기본적으로 파일 시스템을 암호화해. 하지만 Data Protection API를 사용하면 더 강력한 보호를 할 수 있어!

// Core Data에 Data Protection 적용
lazy var persistentContainer: NSPersistentContainer = {
    let container = NSPersistentContainer(name: "MyApp")
    
    let description = container.persistentStoreDescriptions.first
    
    // 파일 보호 레벨 설정
    description?.setOption(
        FileProtectionType.complete as NSObject,
        forKey: NSPersistentStoreFileProtectionKey
    )
    
    container.loadPersistentStores { description, error in
        if let error = error {
            fatalError("로드 실패: \(error)")
        }
    }
    
    return container
}()

🔑 Keychain으로 민감 정보 저장

비밀번호, 토큰, 암호화 키 같은 민감한 정보는 절대 UserDefaults나 일반 파일에 저장하면 안 돼!
Keychain을 사용해야 해. 🔐

import Security

class KeychainManager {
    static let shared = KeychainManager()
    
    private init() {}
    
    // 저장
    func save(key: String, value: String) -> Bool {
        guard let data = value.data(using: .utf8) else { return false }
        
        // 기존 항목 삭제
        delete(key: key)
        
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecValueData as String: data,
            kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly
        ]
        
        let status = SecItemAdd(query as CFDictionary, nil)
        return status == errSecSuccess
    }
    
    // 불러오기
    func load(key: String) -> String? {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]
        
        var result: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &result)
        
        guard status == errSecSuccess,
              let data = result as? Data,
              let string = String(data: data, encoding: .utf8) else {
            return nil
        }
        
        return string
    }
    
    // 삭제
    func delete(key: String) -> Bool {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key
        ]
        
        let status = SecItemDelete(query as CFDictionary)
        return status == errSecSuccess || status == errSecItemNotFound
    }
}

// 사용 예시
KeychainManager.shared.save(key: "apiToken", value: "secret_token_12345")
if let token = KeychainManager.shared.load(key: "apiToken") {
    print("토큰: \(token)")
}

🔐 데이터베이스 암호화

SQLCipher로 SQLite 암호화

// Podfile에 추가
// pod 'SQLCipher', '~> 4.5'

import SQLite

class EncryptedSQLiteManager {
    private var db: Connection?
    
    init(password: String) throws {
        let path = // ... 경로 설정
        db = try Connection(path)
        
        // 암호화 키 설정
        try db?.execute("PRAGMA key = '\(password)'")
        
        // 암호화 알고리즘 설정 (선택사항)
        try db?.execute("PRAGMA cipher_page_size = 4096")
        try db?.execute("PRAGMA kdf_iter = 256000")
        
        // 연결 테스트
        try db?.execute("SELECT count(*) FROM sqlite_master")
        
        print("✅ 암호화된 데이터베이스 연결 성공!")
    }
    
    // 비밀번호 변경
    func changePassword(newPassword: String) throws {
        try db?.execute("PRAGMA rekey = '\(newPassword)'")
        print("✅ 비밀번호 변경 완료!")
    }
}

🔍 데이터 유출 방지

// 앱 스위처에서 스크린샷 숨기기
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    private var blurView: UIVisualEffectView?
    
    func sceneWillResignActive(_ scene: UIScene) {
        // 앱이 백그라운드로 갈 때 블러 효과
        addBlurEffect()
    }
    
    func sceneDidBecomeActive(_ scene: UIScene) {
        // 앱이 포그라운드로 올 때 블러 제거
        removeBlurEffect()
    }
    
    private func addBlurEffect() {
        guard blurView == nil else { return }
        
        let blurEffect = UIBlurEffect(style: .light)
        let blurView = UIVisualEffectView(effect: blurEffect)
        blurView.frame = window?.bounds ?? .zero
        blurView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        
        window?.addSubview(blurView)
        self.blurView = blurView
    }
    
    private func removeBlurEffect() {
        blurView?.removeFromSuperview()
        blurView = nil
    }
}

// 스크린샷 감지
NotificationCenter.default.addObserver(
    forName: UIApplication.userDidTakeScreenshotNotification,
    object: nil,
    queue: .main
) { _ in
    print("⚠️ 스크린샷이 촬영되었습니다!")
    // 필요한 경우 경고 표시 또는 로깅
}

🎯 마무리하며

와! 정말 긴 여정이었어. 😅 Core Data와 SQLite를 활용한 iOS 데이터 영속화에 대해 깊이 있게 알아봤어.

핵심 내용을 다시 한번 정리해볼까? 📝

데이터 영속화는 앱 개발의 핵심이야. 사용자의 소중한 데이터를 안전하게 보관하고,
빠르게 접근할 수 있도록 하는 것이 우리의 책임이지! 💾

처음에는 어렵게 느껴질 수 있지만, 하나씩 차근차근 익히다 보면
어느새 능숙하게 다루고 있는 자신을 발견하게 될 거야. 🚀

Core Data든 SQLite든, 중요한 건 사용자 경험이야.
빠르고 안정적이며 안전한 데이터 관리를 통해 최고의 앱을 만들어보자! ✨

궁금한 점이 있거나 더 깊이 배우고 싶다면, 실무 경험이 풍부한 개발자들과
교류하는 것도 큰 도움이 돼. 함께 성장하는 개발자가 되자! 🌱

행복한 코딩 되세요! 🎉
Happy Coding! 💻✨