【Swift UI】Core Dataの使い方！SQLiteにデータを永続的に保存する

import CoreData

struct PersistenceController {
    // シングルトン
    static let shared = PersistenceController(inMemory: true)

    // プレビュー用のデモデータ用(なくてもOK)
    static var preview: PersistenceController = {
        let result = PersistenceController(inMemory: true)
        let viewContext = result.container.viewContext
        
        for _ in 0..<10 {
            let newItem = Item(context: viewContext)
            newItem.timestamp = Date()
        }
        do {
            // データの追加
            try viewContext.save()
        } catch {
            let nsError = error as NSError
            fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
        }
        return result
    }()

    let container: NSPersistentContainer

    // 初期化&セットアップ処理」
    init(inMemory: Bool = false) {
        // .xcdatamodelファイル(モデルファイル名を渡す)
        // 永続的なコンテナー インスタンスを作成
        container = NSPersistentContainer(name: "CoreDataTest")
        
        if inMemory {
            // オンメモリで使用したい場合
            // /dev/nullはLinuxにおいてゴミ箱的な役割の特別なファイル
            print("InMemory")
            container.persistentStoreDescriptions.first!.url = URL(fileURLWithPath: "/dev/null")
        } else {
            // falseの場合は通常通りSQLiteファイルの保存する
            print("InFile")
        }
        // 永続ストアをロード ストアが存在しない場合は自動作成
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
        // 親コンテキストからの変更を自動的にマージする
        container.viewContext.automaticallyMergesChangesFromParent = true
    }
}

import SwiftUI
import CoreData

struct ContentView: View {
    // コンテキストの取得
    @Environment(\.managedObjectContext) private var viewContext
    
    // データ取得
    // データの変化とともにプロパティの値も自動で変化する
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Item.timestamp, ascending: true)],
        animation: .default)
    private var items: FetchedResults<Item>
    
    var body: some View {
        NavigationView {
            List {
                ForEach(items) { item in
                    NavigationLink {
                        Text("Item at \(item.timestamp!, formatter: itemFormatter)")
                    } label: {
                        Text(item.timestamp!, formatter: itemFormatter)
                    }
                }
                .onDelete(perform: deleteItems)
            }
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    EditButton()
                }
                ToolbarItem {
                    Button(action: addItem) {
                        Label("Add Item", systemImage: "plus")
                    }
                }
            }
            Text("Select an item")
        }
    }
    
    // データの追加処理
    /// エンティティをインスタンス化してデータを格納
    /// viewContext.save() で反映
    private func addItem() {
        withAnimation {
            let newItem = Item(context: viewContext)
            newItem.timestamp = Date()
            
            do {
                try viewContext.save()
            } catch {
                let nsError = error as NSError
                fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
            }
        }
    }
    
    // データの削除処理
    /// データを削除する
    /// viewContext.save() で反映
    private func deleteItems(offsets: IndexSet) {
        withAnimation {
            offsets.map { items[$0] }.forEach(viewContext.delete)
            
            do {
                try viewContext.save()
            } catch {
                let nsError = error as NSError
                fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
            }
        }
    }
}

private let itemFormatter: DateFormatter = {
    let formatter = DateFormatter()
    formatter.dateStyle = .short
    formatter.timeStyle = .medium
    return formatter
}()

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView().environment(\.managedObjectContext, PersistenceController.preview.container.viewContext)
    }
}

/// 保存処理
private func saveContext(_ context: NSManagedObjectContext) {
        guard context.hasChanges else { return }
        do {
            try context.save()
        } catch let error as NSError {
            fatalError("Unresolved error \(error), \(error.userInfo)")
        }
    }

/// 新規作成
let newItem = Item(context: viewContext)
newItem.timestamp = Date()

/// 追加処理
context.insert(object)

@FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Item.timestamp, ascending: true)],
        animation: .default)
private var items: FetchedResults

public func fetch() -> [Person] {
    // String(describing: Person.self) → "Person" と同じ
    let fetchRequest = NSFetchRequest<Person>(entityName: String(describing: Person.self))
    do {
    return try context.fetch(fetchRequest)
    } catch let error as NSError {
      print("Could not fetch. \(error), \(error.userInfo)")
      return []
    }
}

context.delete(object)

// 新しいデータベースのURLを指定
let newStoreURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent("データベース名.sqlite")

// NSPersistentStoreDescriptionを作成し、URLを設定
let storeDescription = NSPersistentStoreDescription(url: newStoreURL)

// NSPersistentContainerを作成し、NSPersistentStoreDescriptionをセット
let container = NSPersistentContainer(name: "LinkMark")
container.persistentStoreDescriptions = [storeDescription]

// コンテナをロードします
container.loadPersistentStores { (storeDescription, error) in
    if let error = error as NSError? {
        fatalError("Unresolved error \(error), \(error.userInfo)")
    }
}