-
Notifications
You must be signed in to change notification settings - Fork 87
Expand file tree
/
Copy pathQuerySet.swift
More file actions
257 lines (202 loc) · 9.42 KB
/
QuerySet.swift
File metadata and controls
257 lines (202 loc) · 9.42 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
import Foundation
import CoreData
/// Represents a lazy database lookup for a set of objects.
open class QuerySet<ModelType : NSManagedObject> : Equatable {
/// Returns the managed object context that will be used to execute any requests.
public let context: NSManagedObjectContext
/// Returns the name of the entity the request is configured to fetch.
public let entityName: String
/// Returns the sort descriptors of the receiver.
public let sortDescriptors: [NSSortDescriptor]
/// Returns the predicate of the receiver.
public let predicate: NSPredicate?
/// The range of the query, allows you to offset and limit a query
public let range: Range<Int>?
// MARK: Initialization
public init(_ context:NSManagedObjectContext, _ entityName:String) {
self.context = context
self.entityName = entityName
self.sortDescriptors = []
self.predicate = nil
self.range = nil
}
/// Create a queryset from another queryset with a different sortdescriptor predicate and range
public init(queryset:QuerySet<ModelType>, sortDescriptors:[NSSortDescriptor]?, predicate:NSPredicate?, range: Range<Int>?) {
self.context = queryset.context
self.entityName = queryset.entityName
self.sortDescriptors = sortDescriptors ?? []
self.predicate = predicate
self.range = range
}
}
/// Methods which return a new queryset
extension QuerySet {
// MARK: Sorting
/// Returns a new QuerySet containing objects ordered by the given sort descriptor.
public func orderBy(_ sortDescriptor:NSSortDescriptor) -> QuerySet<ModelType> {
return orderBy([sortDescriptor])
}
/// Returns a new QuerySet containing objects ordered by the given sort descriptors.
public func orderBy(_ sortDescriptors:[NSSortDescriptor]) -> QuerySet<ModelType> {
return QuerySet(queryset:self, sortDescriptors:sortDescriptors, predicate:predicate, range:range)
}
/// Reverses the ordering of the QuerySet
public func reverse() -> QuerySet<ModelType> {
func reverseSortDescriptor(_ sortDescriptor:NSSortDescriptor) -> NSSortDescriptor {
return NSSortDescriptor(key: sortDescriptor.key!, ascending: !sortDescriptor.ascending)
}
return QuerySet(queryset:self, sortDescriptors:sortDescriptors.map(reverseSortDescriptor), predicate:predicate, range:range)
}
// MARK: Type-safe Sorting
/// Returns a new QuerySet containing objects ordered by the given key path.
public func orderBy<T>(_ keyPath: KeyPath<ModelType, T>, ascending: Bool) -> QuerySet<ModelType> {
return orderBy(NSSortDescriptor(key: (keyPath as AnyKeyPath)._kvcKeyPathString!, ascending: ascending))
}
/// Returns a new QuerySet containing objects ordered by the given sort descriptor.
public func orderBy(_ closure:((ModelType.Type) -> (SortDescriptor<ModelType>))) -> QuerySet<ModelType> {
return orderBy(closure(ModelType.self).sortDescriptor)
}
/// Returns a new QuerySet containing objects ordered by the given sort descriptors.
public func orderBy(_ closure:((ModelType.Type) -> ([SortDescriptor<ModelType>]))) -> QuerySet<ModelType> {
return orderBy(closure(ModelType.self).map { $0.sortDescriptor })
}
// MARK: Filtering
/// Returns a new QuerySet containing objects that match the given predicate.
public func filter(_ predicate: Predicate<ModelType>) -> QuerySet<ModelType> {
return filter(predicate.predicate)
}
/// Returns a new QuerySet containing objects that match the given predicate.
public func filter(_ predicate:NSPredicate) -> QuerySet<ModelType> {
var futurePredicate = predicate
if let existingPredicate = self.predicate {
futurePredicate = NSCompoundPredicate(type: NSCompoundPredicate.LogicalType.and, subpredicates: [existingPredicate, predicate])
}
return QuerySet(queryset:self, sortDescriptors:sortDescriptors, predicate:futurePredicate, range:range)
}
/// Returns a new QuerySet containing objects that match the given predicates.
public func filter(_ predicates:[NSPredicate]) -> QuerySet<ModelType> {
let newPredicate = NSCompoundPredicate(type: NSCompoundPredicate.LogicalType.and, subpredicates: predicates)
return filter(newPredicate)
}
/// Returns a new QuerySet containing objects that exclude the given predicate.
public func exclude(_ predicate: Predicate<ModelType>) -> QuerySet<ModelType> {
return exclude(predicate.predicate)
}
/// Returns a new QuerySet containing objects that exclude the given predicate.
public func exclude(_ predicate:NSPredicate) -> QuerySet<ModelType> {
let excludePredicate = NSCompoundPredicate(type: NSCompoundPredicate.LogicalType.not, subpredicates: [predicate])
return filter(excludePredicate)
}
/// Returns a new QuerySet containing objects that exclude the given predicates.
public func exclude(_ predicates:[NSPredicate]) -> QuerySet<ModelType> {
let excludePredicate = NSCompoundPredicate(type: NSCompoundPredicate.LogicalType.and, subpredicates: predicates)
return exclude(excludePredicate)
}
// MARK: Type-safe filtering
/// Returns a new QuerySet containing objects that match the given predicate.
@available(*, deprecated, renamed: "filter(_:)", message: "Replaced by KeyPath filtering https://git.io/Jv2v3")
public func filter(_ closure:((ModelType.Type) -> (Predicate<ModelType>))) -> QuerySet<ModelType> {
return filter(closure(ModelType.self).predicate)
}
/// Returns a new QuerySet containing objects that exclude the given predicate.
@available(*, deprecated, renamed: "exclude(_:)", message: "Replaced by KeyPath filtering https://git.io/Jv2v3")
public func exclude(_ closure:((ModelType.Type) -> (Predicate<ModelType>))) -> QuerySet<ModelType> {
return exclude(closure(ModelType.self).predicate)
}
/// Returns a new QuerySet containing objects that match the given predicatess.
@available(*, deprecated, renamed: "filter(_:)", message: "Replaced by KeyPath filtering https://git.io/Jv2v3")
public func filter(_ closures:[((ModelType.Type) -> (Predicate<ModelType>))]) -> QuerySet<ModelType> {
return filter(closures.map { $0(ModelType.self).predicate })
}
/// Returns a new QuerySet containing objects that exclude the given predicates.
@available(*, deprecated, renamed: "exclude(_:)", message: "Replaced by KeyPath filtering https://git.io/Jv2v3")
public func exclude(_ closures:[((ModelType.Type) -> (Predicate<ModelType>))]) -> QuerySet<ModelType> {
return exclude(closures.map { $0(ModelType.self).predicate })
}
}
/// Functions for evauluating a QuerySet
extension QuerySet {
// MARK: Subscripting
/// Returns the object at the specified index.
public func object(_ index: Int) throws -> ModelType? {
let request = fetchRequest
request.fetchOffset = index
request.fetchLimit = 1
let items = try context.fetch(request)
return items.first
}
public subscript(range: ClosedRange<Int>) -> QuerySet<ModelType> {
get {
return self[Range(range)]
}
}
public subscript(range: Range<Int>) -> QuerySet<ModelType> {
get {
var fullRange = range
if let currentRange = self.range {
fullRange = ((currentRange.lowerBound + range.lowerBound) ..< range.upperBound)
}
return QuerySet(queryset:self, sortDescriptors:sortDescriptors, predicate:predicate, range:fullRange)
}
}
// Mark: Getters
/// Returns the first object in the QuerySet
public func first() throws -> ModelType? {
return try self.object(0)
}
/// Returns the last object in the QuerySet
public func last() throws -> ModelType? {
return try reverse().first()
}
// MARK: Conversion
/// Returns a fetch request equivilent to the QuerySet
public var fetchRequest: NSFetchRequest<ModelType> {
let request = NSFetchRequest<ModelType>(entityName: entityName)
request.predicate = predicate
request.sortDescriptors = sortDescriptors
if let range = range {
request.fetchOffset = range.lowerBound
request.fetchLimit = range.upperBound - range.lowerBound
}
return request
}
/// Returns an array of all objects matching the QuerySet
public func array() throws -> [ModelType] {
return try context.fetch(fetchRequest)
}
// MARK: Count
/// Returns the count of objects matching the QuerySet.
public func count() throws -> Int {
return try context.count(for: fetchRequest)
}
// MARK: Exists
/** Returns true if the QuerySet contains any results, and false if not.
:note: Returns nil if the operation could not be completed.
*/
public func exists() throws -> Bool {
let fetchRequest = self.fetchRequest
fetchRequest.fetchLimit = 1
let result = try context.count(for: fetchRequest)
return result != 0
}
// MARK: Deletion
/// Deletes all the objects matching the QuerySet.
public func delete() throws -> Int {
let objects = try array()
let deletedCount = objects.count
for object in objects {
context.delete(object)
}
return deletedCount
}
}
/// Returns true if the two given querysets are equivilent
public func == <ModelType : NSManagedObject>(lhs: QuerySet<ModelType>, rhs: QuerySet<ModelType>) -> Bool {
let context = lhs.context == rhs.context
let entityName = lhs.entityName == rhs.entityName
let sortDescriptors = lhs.sortDescriptors == rhs.sortDescriptors
let predicate = lhs.predicate == rhs.predicate
let startIndex = lhs.range?.lowerBound == rhs.range?.lowerBound
let endIndex = lhs.range?.upperBound == rhs.range?.upperBound
return context && entityName && sortDescriptors && predicate && startIndex && endIndex
}