CloudKit - 具有依赖性的 CKQueryOperation
CloudKit - CKQueryOperation with dependency
我刚开始使用 CloudKit，请耐心等待。
背景资料
在 WWDC 2015 上，苹果发表了关于 CloudKit https://developer.apple.com/videos/wwdc/2015/?id=715
的演讲
在这次演讲中，他们警告不要创建链接查询，而是推荐这种策略：
let firstFetch = CKFetchRecordsOperation(...)
let secondFetch = CKFetchRecordsOperation(...)
...
secondFetch.addDependency(firstFetch)
letQueue = NSOperationQueue()
queue.addOperations([firstFetch, secondFetch], waitUntilFinished: false)
示例结构
测试项目数据库包含宠物及其主人，如下所示：
|Pets | |Owners |
|-name | |-firstName |
|-birthdate | |-lastName |
|-owner (Reference) | | |
我的问题
我正在尝试查找属于某个主人的所有宠物，但我担心我正在创建链苹果警告。请参阅下面的两种方法，它们做同样的事情，但有两种方式。哪个更正确或者都错了？我觉得我在做同样的事情，但只是使用完成块。
我很困惑如何更改 otherSearchBtnClick: 以使用依赖项。 我需要在哪里添加
ownerQueryOp.addDependency(queryOp)
在 otherSearchBtnClick:?
@IBAction func searchBtnClick(sender: AnyObject) {
var petString = ""
let container = CKContainer.defaultContainer()
let publicDatabase = container.publicCloudDatabase
let privateDatabase = container.privateCloudDatabase
let predicate = NSPredicate(format: "lastName == '\(ownerLastNameTxt.text)'")
let ckQuery = CKQuery(recordType: "Owner", predicate: predicate)
publicDatabase.performQuery(ckQuery, inZoneWithID: nil) {
record, error in
if error != nil {
println(error.localizedDescription)
} else {
if record != nil {
for owner in record {
let myRecord = owner as! CKRecord
let myReference = CKReference(record: myRecord, action: CKReferenceAction.None)
let myPredicate = NSPredicate(format: "owner == %@", myReference)
let petQuery = CKQuery(recordType: "Pet", predicate: myPredicate)
publicDatabase.performQuery(petQuery, inZoneWithID: nil) {
record, error in
if error != nil {
println(error.localizedDescription)
} else {
if record != nil {
for pet in record {
println(pet.objectForKey("name") as! String)
}
}
}
}
}
}
}
}
}
@IBAction func otherSearchBtnClick (sender: AnyObject) {
let container = CKContainer.defaultContainer()
let publicDatabase = container.publicCloudDatabase
let privateDatabase = container.privateCloudDatabase
let queue = NSOperationQueue()
let petPredicate = NSPredicate(format: "lastName == '\(ownerLastNameTxt.text)'")
let petQuery = CKQuery(recordType: "Owner", predicate: petPredicate)
let queryOp = CKQueryOperation(query: petQuery)
queryOp.recordFetchedBlock = { (record: CKRecord!) in
println("recordFetchedBlock: \(record)")
self.matchingOwners.append(record)
}
queryOp.queryCompletionBlock = { (cursor: CKQueryCursor!, error: NSError!) in
if error != nil {
println(error.localizedDescription)
} else {
println("queryCompletionBlock: \(cursor)")
println("ALL RECORDS ARE: \(self.matchingOwners)")
for owner in self.matchingOwners {
let ownerReference = CKReference(record: owner, action: CKReferenceAction.None)
let ownerPredicate = NSPredicate(format: "owner == %@", ownerReference)
let ownerQuery = CKQuery(recordType: "Pet", predicate: ownerPredicate)
let ownerQueryOp = CKQueryOperation(query: ownerQuery)
ownerQueryOp.recordFetchedBlock = { (record: CKRecord!) in
println("recordFetchedBlock (pet values): \(record)")
self.matchingPets.append(record)
}
ownerQueryOp.queryCompletionBlock = { (cursor: CKQueryCursor!, error: NSError!) in
if error != nil {
println(error.localizedDescription)
} else {
println("queryCompletionBlock (pet values)")
for pet in self.matchingPets {
println(pet.objectForKey("name") as! String)
}
}
}
publicDatabase.addOperation(ownerQueryOp)
}
}
}
publicDatabase.addOperation(queryOp)
}
理论上你可以有多个所有者，因此有多个依赖项。此外，内部查询将在外部查询执行后创建。你将来不及创建依赖关系。在您的情况下，将内部查询强制执行到一个单独的队列可能更容易：
if record != nil {
for owner in record {
NSOperationQueue.mainQueue().addOperationWithBlock {
这样您将确保每个内部查询都将在新队列上执行，同时父查询可以完成。
其他：为了使您的代码更简洁，最好将 for 循环内的所有代码放在一个单独的函数中，并以 CKReference 作为参数。
我最近遇到了同样的问题，最终使用 NSBlockOperation 准备第二个查询并添加了一个依赖项以使其全部正常工作：
let container = CKContainer.defaultContainer()
let publicDB = container.publicCloudDatabase
let operationqueue = NSOperationQueue.mainQueue()
let familyPredicate = NSPredicate(format: "name == %@", argumentArray: [familyName])
let familyQuery = CKQuery(recordType: "Familias", predicate: familyPredicate)
let fetchFamilyRecordOp = CKQueryOperation(query: familyQuery)
fetchFamilyRecordOp.recordFetchedBlock = { record in
familyRecord = record
}
let fetchMembersOP = CKQueryOperation()
// Once we have the familyRecord, we prepare the PersonsFetch
let prepareFamilyRef = NSBlockOperation() {
let familyRef = CKReference(record: familyRecord!, action: CKReferenceAction.None)
let familyRecordID = familyRef?.recordID
let membersPredicate = NSPredicate(format: "familia == %@", argumentArray: [familyRecordID!])
let membersQuery = CKQuery(recordType: "Personas", predicate: membersPredicate)
fetchMembersOP.query = membersQuery
}
prepareFamilyRef.addDependency(fetchFamilyRecordOp)
fetchMembersOP.recordFetchedBlock = { record in
members.append(record)
}
fetchMembersOP.addDependency(prepareFamilyRef)
fetchMembersOP.database = publicDB
fetchFamilyRecordOp.database = publicDB
operationqueue.addOperations([fetchFamilyRecordOp, fetchMembersOP, prepareFamilyRef], waitUntilFinished: false)
现在它按照我的预期工作，因为您可以以非常精细的方式设置您的操作，并且它们以正确的顺序执行 ^.^
在你的情况下，我会这样构造它：
let predicate = NSPredicate(format: "lastName == '\(ownerLastNameTxt.text)'")
let ckQuery = CKQuery(recordType: "Owner", predicate: predicate)
let getOwnerOperation = CKQueryOperation(query: ckQuery)
getOwnerOperation.recordFetchedBlock = { record in
let name = record.valueForKey("name") as! String
if name == myOwnerName {
ownerRecord = record
}
}
//now we have and operation that will save in our var OwnerRecord the record that is exactly our owner
//now we create another that will fetch our pets
let queryPetsForOurOwner = CKQueryOperation()
queryPetsForOurOwner.recordFetchedBlock = { record in
results.append(record)
}
//That's all this op has to do, BUT it needs the owner operation to be completed first, but not inmediately, we need to prepare it's query first so:
var fetchPetsQuery : CKQuery?
let preparePetsForOwnerQuery = NSBlockOperation() {
let myOwnerRecord = ownerRecord!
let ownerRef = CKReference(record: myOwnerRecord, action: CKReferenceAction.None)
let myPredicate = NSPredicate(format: "owner == %@", myReference)
fetchPetsQuery = CKQuery(recordType: "Pet", predicate: myPredicate)
}
queryPetsForOurOwner.query = fetchPetsQuery
preparePetsForOwnerQuery.addDependency(getOwnerOperation)
queryPetsForOurOwner.addDependency(preparePetsForOwnerQuery)
现在需要做的就是在将它们定向到我们的数据库后将它们添加到新创建的操作队列中
getOwnerOperation.database = publicDB
queryPetsForOurOwner.database = publicDB
let operationqueue = NSOperationQueue.mainQueue()
operationqueue.addOperations([getOwnerOperation, queryPetsForOurOwner, preparePetsForOwnerQuery], waitUntilFinished: false)
P.S：我知道我说的是 Family 和 Person，名字不是那样的，但我是西班牙人并正在测试一些 cloudkit 操作，所以我还没有标准化为英语记录尚未输入名称 ;)
如果您不需要取消并且不介意在出现网络错误时重试，那么我认为您可以很好地链接查询。
我知道我知道，在 WWDC 2015 中，Nihar Sharma 推荐了添加依赖项的方法，但看起来他只是在最后没有多想就把它扔进去了。您会看到不可能重试 NSOperation，因为它们无论如何都是一次性的，并且他没有提供取消队列中已有操作的示例，或者如何从一个操作传递数据到下一个操作。鉴于这 3 个复杂问题可能需要您数周才能解决，请坚持您的工作并等待下一次 WWDC 的解决方案。另外，块的全部意义在于让您调用内联方法并能够访问上述方法中的参数，因此如果您转向操作，您可能无法充分利用该优势。
他不使用链接的主要原因是荒谬的，他无法分辨哪个错误是针对哪个请求的，他将他的错误命名为 someError 然后是 otherError 等等。没有人在他们正确的头脑中命名错误参数不同块，所以只需对所有块使用相同的名称，然后您就会知道在块内您始终使用正确的错误。因此，他是创建他的混乱场景并为其提供解决方案的人，但是最好的解决方案只是不要首先创建多个错误参数名称的混乱场景！
尽管如此，如果您仍想尝试使用操作依赖项，这里有一个如何完成的示例：
__block CKRecord* venueRecord;
CKRecordID* venueRecordID = [[CKRecordID alloc] initWithRecordName:@"4c31ee5416adc9282343c19c"];
CKFetchRecordsOperation* fetchVenue = [[CKFetchRecordsOperation alloc] initWithRecordIDs:@[venueRecordID]];
fetchVenue.database = [CKContainer defaultContainer].publicCloudDatabase;
// init a fetch for the category, it's just a placeholder just now to go in the operation queue and will be configured once we have the venue.
CKFetchRecordsOperation* fetchCategory = [[CKFetchRecordsOperation alloc] init];
[fetchVenue setFetchRecordsCompletionBlock:^(NSDictionary<CKRecordID *,CKRecord *> * _Nullable recordsByRecordID, NSError * _Nullable error) {
venueRecord = recordsByRecordID.allValues.firstObject;
CKReference* ref = [venueRecord valueForKey:@"category"];
// configure the category fetch
fetchCategory.recordIDs = @[ref.recordID];
fetchCategory.database = [CKContainer defaultContainer].publicCloudDatabase;
}];
[fetchCategory setFetchRecordsCompletionBlock:^(NSDictionary<CKRecordID *,CKRecord *> * _Nullable recordsByRecordID, NSError * _Nullable error) {
CKRecord* categoryRecord = recordsByRecordID.allValues.firstObject;
// here we have a venue and a category so we could call a completion handler with both.
}];
NSOperationQueue* queue = [[NSOperationQueue alloc] init];
[fetchCategory addDependency:fetchVenue];
[queue addOperations:@[fetchVenue, fetchCategory] waitUntilFinished:NO];
它的工作原理是首先获取 Venue 记录，然后获取其类别。
抱歉，没有错误处理，但如您所见，已经有大量代码可以通过链接在几行代码中完成。我个人觉得这个结果比简单地将便利方法链接在一起更令人费解和困惑。
我刚开始使用 CloudKit，请耐心等待。
背景资料
在 WWDC 2015 上，苹果发表了关于 CloudKit https://developer.apple.com/videos/wwdc/2015/?id=715
的演讲在这次演讲中，他们警告不要创建链接查询，而是推荐这种策略：
let firstFetch = CKFetchRecordsOperation(...)
let secondFetch = CKFetchRecordsOperation(...)
...
secondFetch.addDependency(firstFetch)
letQueue = NSOperationQueue()
queue.addOperations([firstFetch, secondFetch], waitUntilFinished: false)
示例结构
测试项目数据库包含宠物及其主人，如下所示：
|Pets | |Owners |
|-name | |-firstName |
|-birthdate | |-lastName |
|-owner (Reference) | | |
我的问题
我正在尝试查找属于某个主人的所有宠物，但我担心我正在创建链苹果警告。请参阅下面的两种方法，它们做同样的事情，但有两种方式。哪个更正确或者都错了？我觉得我在做同样的事情，但只是使用完成块。
我很困惑如何更改 otherSearchBtnClick: 以使用依赖项。 我需要在哪里添加
ownerQueryOp.addDependency(queryOp)
在 otherSearchBtnClick:?
@IBAction func searchBtnClick(sender: AnyObject) {
var petString = ""
let container = CKContainer.defaultContainer()
let publicDatabase = container.publicCloudDatabase
let privateDatabase = container.privateCloudDatabase
let predicate = NSPredicate(format: "lastName == '\(ownerLastNameTxt.text)'")
let ckQuery = CKQuery(recordType: "Owner", predicate: predicate)
publicDatabase.performQuery(ckQuery, inZoneWithID: nil) {
record, error in
if error != nil {
println(error.localizedDescription)
} else {
if record != nil {
for owner in record {
let myRecord = owner as! CKRecord
let myReference = CKReference(record: myRecord, action: CKReferenceAction.None)
let myPredicate = NSPredicate(format: "owner == %@", myReference)
let petQuery = CKQuery(recordType: "Pet", predicate: myPredicate)
publicDatabase.performQuery(petQuery, inZoneWithID: nil) {
record, error in
if error != nil {
println(error.localizedDescription)
} else {
if record != nil {
for pet in record {
println(pet.objectForKey("name") as! String)
}
}
}
}
}
}
}
}
}
@IBAction func otherSearchBtnClick (sender: AnyObject) {
let container = CKContainer.defaultContainer()
let publicDatabase = container.publicCloudDatabase
let privateDatabase = container.privateCloudDatabase
let queue = NSOperationQueue()
let petPredicate = NSPredicate(format: "lastName == '\(ownerLastNameTxt.text)'")
let petQuery = CKQuery(recordType: "Owner", predicate: petPredicate)
let queryOp = CKQueryOperation(query: petQuery)
queryOp.recordFetchedBlock = { (record: CKRecord!) in
println("recordFetchedBlock: \(record)")
self.matchingOwners.append(record)
}
queryOp.queryCompletionBlock = { (cursor: CKQueryCursor!, error: NSError!) in
if error != nil {
println(error.localizedDescription)
} else {
println("queryCompletionBlock: \(cursor)")
println("ALL RECORDS ARE: \(self.matchingOwners)")
for owner in self.matchingOwners {
let ownerReference = CKReference(record: owner, action: CKReferenceAction.None)
let ownerPredicate = NSPredicate(format: "owner == %@", ownerReference)
let ownerQuery = CKQuery(recordType: "Pet", predicate: ownerPredicate)
let ownerQueryOp = CKQueryOperation(query: ownerQuery)
ownerQueryOp.recordFetchedBlock = { (record: CKRecord!) in
println("recordFetchedBlock (pet values): \(record)")
self.matchingPets.append(record)
}
ownerQueryOp.queryCompletionBlock = { (cursor: CKQueryCursor!, error: NSError!) in
if error != nil {
println(error.localizedDescription)
} else {
println("queryCompletionBlock (pet values)")
for pet in self.matchingPets {
println(pet.objectForKey("name") as! String)
}
}
}
publicDatabase.addOperation(ownerQueryOp)
}
}
}
publicDatabase.addOperation(queryOp)
}
理论上你可以有多个所有者，因此有多个依赖项。此外，内部查询将在外部查询执行后创建。你将来不及创建依赖关系。在您的情况下，将内部查询强制执行到一个单独的队列可能更容易：
if record != nil {
for owner in record {
NSOperationQueue.mainQueue().addOperationWithBlock {
这样您将确保每个内部查询都将在新队列上执行，同时父查询可以完成。
其他：为了使您的代码更简洁，最好将 for 循环内的所有代码放在一个单独的函数中，并以 CKReference 作为参数。
我最近遇到了同样的问题，最终使用 NSBlockOperation 准备第二个查询并添加了一个依赖项以使其全部正常工作：
let container = CKContainer.defaultContainer()
let publicDB = container.publicCloudDatabase
let operationqueue = NSOperationQueue.mainQueue()
let familyPredicate = NSPredicate(format: "name == %@", argumentArray: [familyName])
let familyQuery = CKQuery(recordType: "Familias", predicate: familyPredicate)
let fetchFamilyRecordOp = CKQueryOperation(query: familyQuery)
fetchFamilyRecordOp.recordFetchedBlock = { record in
familyRecord = record
}
let fetchMembersOP = CKQueryOperation()
// Once we have the familyRecord, we prepare the PersonsFetch
let prepareFamilyRef = NSBlockOperation() {
let familyRef = CKReference(record: familyRecord!, action: CKReferenceAction.None)
let familyRecordID = familyRef?.recordID
let membersPredicate = NSPredicate(format: "familia == %@", argumentArray: [familyRecordID!])
let membersQuery = CKQuery(recordType: "Personas", predicate: membersPredicate)
fetchMembersOP.query = membersQuery
}
prepareFamilyRef.addDependency(fetchFamilyRecordOp)
fetchMembersOP.recordFetchedBlock = { record in
members.append(record)
}
fetchMembersOP.addDependency(prepareFamilyRef)
fetchMembersOP.database = publicDB
fetchFamilyRecordOp.database = publicDB
operationqueue.addOperations([fetchFamilyRecordOp, fetchMembersOP, prepareFamilyRef], waitUntilFinished: false)
现在它按照我的预期工作，因为您可以以非常精细的方式设置您的操作，并且它们以正确的顺序执行 ^.^
在你的情况下，我会这样构造它：
let predicate = NSPredicate(format: "lastName == '\(ownerLastNameTxt.text)'")
let ckQuery = CKQuery(recordType: "Owner", predicate: predicate)
let getOwnerOperation = CKQueryOperation(query: ckQuery)
getOwnerOperation.recordFetchedBlock = { record in
let name = record.valueForKey("name") as! String
if name == myOwnerName {
ownerRecord = record
}
}
//now we have and operation that will save in our var OwnerRecord the record that is exactly our owner
//now we create another that will fetch our pets
let queryPetsForOurOwner = CKQueryOperation()
queryPetsForOurOwner.recordFetchedBlock = { record in
results.append(record)
}
//That's all this op has to do, BUT it needs the owner operation to be completed first, but not inmediately, we need to prepare it's query first so:
var fetchPetsQuery : CKQuery?
let preparePetsForOwnerQuery = NSBlockOperation() {
let myOwnerRecord = ownerRecord!
let ownerRef = CKReference(record: myOwnerRecord, action: CKReferenceAction.None)
let myPredicate = NSPredicate(format: "owner == %@", myReference)
fetchPetsQuery = CKQuery(recordType: "Pet", predicate: myPredicate)
}
queryPetsForOurOwner.query = fetchPetsQuery
preparePetsForOwnerQuery.addDependency(getOwnerOperation)
queryPetsForOurOwner.addDependency(preparePetsForOwnerQuery)
现在需要做的就是在将它们定向到我们的数据库后将它们添加到新创建的操作队列中
getOwnerOperation.database = publicDB
queryPetsForOurOwner.database = publicDB
let operationqueue = NSOperationQueue.mainQueue()
operationqueue.addOperations([getOwnerOperation, queryPetsForOurOwner, preparePetsForOwnerQuery], waitUntilFinished: false)
P.S：我知道我说的是 Family 和 Person，名字不是那样的，但我是西班牙人并正在测试一些 cloudkit 操作，所以我还没有标准化为英语记录尚未输入名称 ;)
如果您不需要取消并且不介意在出现网络错误时重试，那么我认为您可以很好地链接查询。
我知道我知道，在 WWDC 2015 中，Nihar Sharma 推荐了添加依赖项的方法，但看起来他只是在最后没有多想就把它扔进去了。您会看到不可能重试 NSOperation，因为它们无论如何都是一次性的，并且他没有提供取消队列中已有操作的示例，或者如何从一个操作传递数据到下一个操作。鉴于这 3 个复杂问题可能需要您数周才能解决，请坚持您的工作并等待下一次 WWDC 的解决方案。另外，块的全部意义在于让您调用内联方法并能够访问上述方法中的参数，因此如果您转向操作，您可能无法充分利用该优势。
他不使用链接的主要原因是荒谬的，他无法分辨哪个错误是针对哪个请求的，他将他的错误命名为 someError 然后是 otherError 等等。没有人在他们正确的头脑中命名错误参数不同块，所以只需对所有块使用相同的名称，然后您就会知道在块内您始终使用正确的错误。因此，他是创建他的混乱场景并为其提供解决方案的人，但是最好的解决方案只是不要首先创建多个错误参数名称的混乱场景！
尽管如此，如果您仍想尝试使用操作依赖项，这里有一个如何完成的示例：
__block CKRecord* venueRecord;
CKRecordID* venueRecordID = [[CKRecordID alloc] initWithRecordName:@"4c31ee5416adc9282343c19c"];
CKFetchRecordsOperation* fetchVenue = [[CKFetchRecordsOperation alloc] initWithRecordIDs:@[venueRecordID]];
fetchVenue.database = [CKContainer defaultContainer].publicCloudDatabase;
// init a fetch for the category, it's just a placeholder just now to go in the operation queue and will be configured once we have the venue.
CKFetchRecordsOperation* fetchCategory = [[CKFetchRecordsOperation alloc] init];
[fetchVenue setFetchRecordsCompletionBlock:^(NSDictionary<CKRecordID *,CKRecord *> * _Nullable recordsByRecordID, NSError * _Nullable error) {
venueRecord = recordsByRecordID.allValues.firstObject;
CKReference* ref = [venueRecord valueForKey:@"category"];
// configure the category fetch
fetchCategory.recordIDs = @[ref.recordID];
fetchCategory.database = [CKContainer defaultContainer].publicCloudDatabase;
}];
[fetchCategory setFetchRecordsCompletionBlock:^(NSDictionary<CKRecordID *,CKRecord *> * _Nullable recordsByRecordID, NSError * _Nullable error) {
CKRecord* categoryRecord = recordsByRecordID.allValues.firstObject;
// here we have a venue and a category so we could call a completion handler with both.
}];
NSOperationQueue* queue = [[NSOperationQueue alloc] init];
[fetchCategory addDependency:fetchVenue];
[queue addOperations:@[fetchVenue, fetchCategory] waitUntilFinished:NO];
它的工作原理是首先获取 Venue 记录，然后获取其类别。
抱歉，没有错误处理，但如您所见，已经有大量代码可以通过链接在几行代码中完成。我个人觉得这个结果比简单地将便利方法链接在一起更令人费解和困惑。