Sample CoreData Playground with relationships

CoreDataPlayground-v2.swift

// Playground is where kids play biatch

import CoreData

@objc(City)
class City: NSManagedObject {
    @NSManaged var name: String
    @NSManaged var streets: NSSet
}

@objc(Street)
class Street: NSManagedObject {
    @NSManaged var name: String
    @NSManaged var city: City
}

var streetEntity = NSEntityDescription()
streetEntity.name = "Street"
streetEntity.managedObjectClassName = "Street"

var streetNameAttribute = NSAttributeDescription()
streetNameAttribute.name = "name"
streetNameAttribute.attributeType = NSAttributeType.StringAttributeType
streetNameAttribute.optional = false
streetNameAttribute.indexed = true

var cityEntity = NSEntityDescription()
cityEntity.name = "City"
cityEntity.managedObjectClassName = "City"

var nameAttribute = NSAttributeDescription()
nameAttribute.name = "name"
nameAttribute.attributeType = NSAttributeType.StringAttributeType
nameAttribute.optional = false
nameAttribute.indexed = true

var streetsRelation = NSRelationshipDescription()
var inverseStreetRelation = NSRelationshipDescription()

streetsRelation.destinationEntity = streetEntity
streetsRelation.name = "streets"
streetsRelation.minCount = 0
streetsRelation.maxCount = 0
streetsRelation.optional = true
streetsRelation.deleteRule = .CascadeDeleteRule
streetsRelation.inverseRelationship = inverseStreetRelation

inverseStreetRelation.destinationEntity = cityEntity
inverseStreetRelation.name = "city"
inverseStreetRelation.minCount = 0
inverseStreetRelation.maxCount = 1
inverseStreetRelation.optional = true
inverseStreetRelation.deleteRule = .NullifyDeleteRule
inverseStreetRelation.inverseRelationship = streetsRelation

cityEntity.properties = [nameAttribute, streetsRelation]
streetEntity.properties = [ streetNameAttribute, inverseStreetRelation ]

var model = NSManagedObjectModel()
model.entities = [cityEntity, streetEntity]

var persistentStoreCoordinator = NSPersistentStoreCoordinator(managedObjectModel: model)
let url = NSURL(fileURLWithPath: "database.sqlite")

// destroy store on each run
try persistentStoreCoordinator.destroyPersistentStoreAtURL(url, withType: NSSQLiteStoreType, options: nil)

do {
    try persistentStoreCoordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil)
}
catch {
    print("error creating psc: \(error)")
}

var managedObjectContext = NSManagedObjectContext(concurrencyType: NSManagedObjectContextConcurrencyType.MainQueueConcurrencyType)
managedObjectContext.persistentStoreCoordinator = persistentStoreCoordinator

for i in 0 ..< 5 {
    for j in 0 ..< 5 {
        if i == 4 && j > 1 {
            continue
        }
        
        let city = City(entity: cityEntity, insertIntoManagedObjectContext: managedObjectContext)
        let street = Street(entity: streetEntity, insertIntoManagedObjectContext: managedObjectContext)
        
        street.name = "Street in City \(i)"
        
        city.name = "City \(i)"
        city.streets = NSSet(object: street)

    }
}

try! managedObjectContext.obtainPermanentIDsForObjects(Array(managedObjectContext.insertedObjects))

do {
    _ = try managedObjectContext.save()
}
catch let error as NSError {
    print("Error: \(error)")
}

let fetchRequest = NSFetchRequest(entityName: "City")

let nameExpr = NSExpression(forKeyPath: "name")
let countExpr = NSExpressionDescription()
let countVariableExpr = NSExpression(forVariable: "count")

countExpr.name = "count"
countExpr.expression = NSExpression(forFunction: "count:", arguments: [ nameExpr ])
countExpr.expressionResultType = .Integer64AttributeType

fetchRequest.resultType = .DictionaryResultType
fetchRequest.sortDescriptors = [ NSSortDescriptor(key: "name", ascending: true) ]
fetchRequest.propertiesToGroupBy = [ "name" ]
fetchRequest.propertiesToFetch = [ "name", countExpr ]
fetchRequest.havingPredicate = NSPredicate(format: "%@ > 1", countVariableExpr)

let results = try! managedObjectContext.executeFetchRequest(fetchRequest)

print("\(results)")

for dict in results {
    let cityName = dict["name"] as! String
    let count = dict["count"] as! Int
    
    print("\(cityName) has \(count) duplicates")
    
    let fetchRequest = NSFetchRequest(entityName: "City")
    let result = try? managedObjectContext.executeFetchRequest(fetchRequest)
}