[SwiftData] Query and Filtering Data

predicates는 한국어로 번역하면 술어라고 번역할 수 있는데 이는 논리적인 조건식을 의미함. SwiftData는 predicates를 사용해서 데이터를 필터링하고 조건에 맞는 데이터를 찾을 수 있다. 

논리적 조건을 정의할 수 있고 구체적인 데이터를 획득할 수 있다. 

 

SwiftData의 Schema를 정의하기 위해 Model을 구성할 때 enum 이나 image 타입을 사용할 수도 있음.

 

Relationship

객체지향 프로그래밍에서 혼자 존재하는 객체는 없고, 관계형 데이터베이스에서 그 관계를 기술하는 것은 중요하다.

다:다 관계

A라는 모델이 B모델을 여러개 가지고 있을 수 있고, B라는 모델이 A라는 모델을 여러개 가질 수 있을때 다:다 관계라고 한다.

/// 유저 정보
@Model class User {
    /// 유저의 고유값
    @Attribute(.unique) var id: UUID = UUID()
    /// 유저 이름
    var name: String
    /// 유저 나이
    var age: Int
    /// 유저 생일
    var birth: Date
    /// 유저의 관심사. 여러개 선택 가능
    var interests: [Interest] = []
    
    init(name: String, age: Int, birth: Date, closeUser: [User]) {
        self.name = name
        self.age = age
        self.birth = birth
    }
}

/// 유저 관심사
@Model class Interest {
    /// 관심사 고유값
    @Attribute(.unique) var id: UUID = UUID()
    /// 관심사 명
    var title: String
    /// 해당 관심사에 관심있는 유저 목록
    var user: [User] = []
    
    init(title: String) {
        self.title = title
    }
}

위 코드에서 사용자는 관심사를 여러개 선택할 수 있고, 관심사는 해당 관심사에 관심있는 사용자 목록을 가질 수 있다. 

 

1:다 관계

하나의 모델은 다른 타입의 모델을 여러개 가질 수 있을 때 1:다 관계라고 한다. 

/// 유저 정보
@Model class User {
    /// 유저의 고유값
    @Attribute(.unique) var id: UUID = UUID()
    /// 유저 이름
    var name: String
    /// 유저 나이
    var age: Int
    /// 유저 생일
    var birth: Date
    /// 유저의 관심사. 여러개 선택 가능
    var interests: [Interest] = []
    /// 소속된 회사
    var company: Company? = nil
    
    init(name: String, age: Int, birth: Date, closeUser: [User]) {
        self.name = name
        self.age = age
        self.birth = birth
    }
}

/// 회사 정보
@Model class Company {
    /// 회사 고유값
    @Attribute(.unique) var id: UUID = UUID()
    /// 회사명
    var name: String
    /// 해당 회사에 소속된 유저 목록
    var user: [User] = []

    init(name: String) {
        self.name = name
    }
}

사용자는 하나의 회사에 소속되거나 소속되지 않을 수 있으며 회사는 소속된 사용자의 목록을 가지고 있다. 

 

모델 클래스 간의 Relationship

    /// 해당 회사에 소속된 유저 목록
    /// 해당 회사가 삭제되면 회사에 소속된 사용자 목록이 함께 삭제된다.
    @Relationship(deleteRule: .cascade, inverse: \User.company)
    var user: [User] = []

deleteRule을 통해 cascade로 지정하면 company가 삭제될 때 해당 company에 소속된 User는 함께 삭제된다. 

inverse 프로퍼티는 해당 모델과 이와 관련된 모델간의 관계를 제공한다. User의 Company와 해당 모델간의 관계를 inverse 키패스로 전달 할 수 있다.

만약에 삭제 옵션을 원하지 않으면 inverse만 제공하면 된다.

    /// 해당 회사에 소속된 유저 목록
    @Relationship(inverse: \User.company)
    var user: [User] = []

SwiftData는 자동적으로 그 관계를 추론한다. 때문에 inverse를 제공하지 않더라도 SwiftData가 자동으로 모델간의 관계를 유추할 수 있다. 따라서 model container를 구축할 때 모든 스키마를 전달하는 것이 아닌 하위 스키마를 모두 포함하고 있는 상위 스키마 하나를 전달하면 모든 관계를 추론할 수 있게 된다.

user의 company를 지정하면 company의 user list에도 user가 자동으로 추가된다. 이는 swiftdata가 자동으로 그 관계를 추론할 수 있기 때문. 마찬가지로 user.company를 nil로 하면 그 관계 역시 자동으로 끊어진다. 

 

deleteRule

// User Model
var company: Company? = nil

// Company Model
    @Relationship(deleteRule: .nullify, inverse: \User.company) // 여기서 지정하는 deleteRule은 회사를 지웠을 때 User를 어떻게 하겠냐는 뜻
    var users: [User] = []

동작을 확인해 봤을 때 deleteRule을 명시하지 않았고, 둘 관계가 필수요소가 아닐 때 nullify 옵션으로 지정되는 것 같다.

만약 여기서 cascade로 지정하면 에러가 발생한다. 

nil이 기본으로 설정되는 관계에서는  nullify를 설정해서 에러가 발생하지 않도록 주의해야 함

 

Cascade를 사용할 때는 모델 구성에 신경 써야 한다. 

@Model
class Book {
    /// 고유값
//    @Attribute(.unique) var id: UUID = UUID()
    /// 책 이름
    var name: String
    /// 소속 도서관
    @Relationship(inverse: \Library.books)
    var library: Library?
    
    init(name: String) {
//        self.id = UUID()
        self.name = name
    }
}

고유값을 생성하지 않도록 한다.  cascade옵션으로 지웠을 때 에러가 발생함

@Model
class Library {
    /// 고유값
    @Attribute(.unique) var id: UUID = UUID()
    /// 도서관 이름
    var name: String
    /// 도서관에 배치된 책
    @Relationship(deleteRule: .cascade)
    var books: [Book] = []
    
    init(name: String) {
        self.id = UUID()
        self.name = name
    }
}

relationship을 cascade로 걸어둔다. 이렇게 하면 Library가 사라질 때 책이 함께 사라진다.

 

참조 무결성

Company의 정보를 변경하면 user의 company 정보도 변경될까?

 

Transient

    /// 회사 목록에서 선택된 회사를 표시하기 위해 사용
    @Transient
    var isChecked = false

Transient를 사용하면 SwiftData는 해당 값을 관리하지 않는다. 데이터베이스에 저장되는 값이 아닌 해당 객체와 비즈니스 로직에서 사용될 값을 정의한다.

 

Predicates

술어는 논리적인 조건식이며 이 조건이 true인지 false인지를 판별한다. predicates를 사용해서 filtering을 수행하거나 Sorting 하여 구체적인 데이터를 데이터베이스로부터 가져올 수 있다. 

저장된 데이터로부터 데이터를 가져오고 조작하기 위한 조건을 정의 할 수 있다. SwiftData 쿼리에서 predicate를 사용할 수 있으며 SwiftData는 이를 위해 @Query 프로퍼티 래퍼를 제공한다. @Query 프로퍼티래퍼를 사용해서 필터와 정렬를 지정할 수 있다. 

    @Query(filter: #Predicate<User> { $0.age > 20 },
           sort: [SortDescriptor(\User.birth)])
    var sortedUser: [User]

Predicate를 사용해서 사용자의 나이가 20살을 넘었는지 확인해서 해당 값이 true인 user를 가지고 온다. 그 유저를 생일로 정렬하도록 하려면 위와 같이 코드를 작성하면 된다.

#Predicate를 predicate macro라고 한며 필터링 조건을 정의하기 위해 사용한다. 

sort는 SortDescriptor 구조체를 사용할 수 있다. 

 

Predicates는 강력하고 유연한 조건을 기술할 수 있는데 조건식과 다양한 표현을 predicate 클로저 내부에서 필터링 조건식을 정의 할 수 있다. 

    @Query private var queriedUser: [User]
    var queriedUserComputedProperty: [User] {
        let startDate = Date(timeIntervalSinceReferenceDate: -123456789.0)
        let endDate = Date()

        return queriedUser.filter({ $0.birth > startDate && $0.birth < endDate })
    }

 

Predicate의 조건식에 넣기 위해서는 Query property wrapper 자체가 lazy var 로 선언이 안되서 static 값을 사용했는데 내부에 global함수도 쓸 수 없음

Date 함수 사용이 불가능해서 Computed Property를 사용하는 방법도 있음

 

복잡한 Predicate를 위한 표현식

    @Query(filter: #Predicate<User> { user in
        user.name.contains("kim") &&
        user.interests.contains { $0.title == "등산" } == true
    }) var query4: [User]

 

검색기능 이용하기

    @State private var userToEdit: User?
    @State private var searchString: String = ""
    
// 생략
                UserListView(searchString: searchString, userToEdit: $userToEdit)
                    .searchable(text: $searchString)
                    .sheet(item: $userToEdit) { user in
                        UpdateUserSheetView(user: user)
                    }

struct UserListView: View {
    @Environment(\.modelContext) var context
    @Query(sort: \User.age, order: .forward) private var users: [User]
    @Binding var userToEdit: User?
    
    init(searchString: String, userToEdit: Binding<User?>) {
        if searchString.count > 0 {
            self._users = Query(filter: #Predicate<User> {
                $0.name.contains(searchString)
            }, sort: \User.age, animation: .easeInOut)
        } else {
            self._users = Query(sort: \User.age, animation: .easeInOut)
        }
        
        self._userToEdit = userToEdit
    }
    
    var body: some View {
        List {
            ForEach(users) { user in
                HStack {
                    Text(user.name)
                    Text("\(user.age)")
                    Text("\(user.birth.formatted())")
                }
                .onTapGesture {
                    userToEdit = user
                }
            }
            .onDelete{ indexSet in
                print("인덱스 : ", indexSet)
                for index in indexSet {
                    context.delete(users[index])
                }
            }
        } //: List
        .overlay {
            if users.isEmpty {
                Text("사용자를 추가해 주세요")
            }
        }
    }
}