version bump

Merge branch 'prototype/customMigrationTest' of github.com:JohnEstropia/CoreStore into prototype/customMigrationTest
fix migration for CoreStoreObject relationships
2026-01-12 12:20:30 +01:00 · 2017-06-08 01:17:39 +09:00 · 2017-06-08 01:07:00 +09:00 · 2017-06-08 01:06:51 +09:00 · 2017-06-07 12:31:42 +09:00 · 2017-06-06 17:40:29 +09:00
29 changed files with 1215 additions and 427 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,7 +9,7 @@ env:
  global:
  - LC_CTYPE=en_US.UTF-8
  - LANG=en_US.UTF-8
-matrix:
+  matrix:
    - DESTINATION="OS=10.3,name=iPhone 7"          SCHEME="CoreStore iOS"     SDK=iphonesimulator10.3  RUN_TESTS="YES" POD_LINT="NO"
    - DESTINATION="OS=10.1,name=iPhone 7"          SCHEME="CoreStore iOS"     SDK=iphonesimulator10.3  RUN_TESTS="YES" POD_LINT="NO"
    - DESTINATION="OS=9.0,name=iPhone 6 Plus"      SCHEME="CoreStore iOS"     SDK=iphonesimulator10.3  RUN_TESTS="YES" POD_LINT="NO"
@@ -25,7 +25,7 @@ matrix:
 before_install:
  - gem install cocoapods --no-rdoc --no-ri --no-document --quiet
  - gem install xcpretty --no-rdoc --no-ri --no-document --quiet
-  - curl -OlL "https://github.com/Carthage/Carthage/releases/download/0.20.1/Carthage.pkg"
+  - curl -OlL "https://github.com/Carthage/Carthage/releases/download/0.23.0/Carthage.pkg"
  - sudo installer -pkg "Carthage.pkg" -target /
  - rm "Carthage.pkg"
 before_script:
--- a/CoreStore.podspec
+++ b/CoreStore.podspec
@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
    s.name = "CoreStore"
-    s.version = "4.0.0"
+    s.version = "4.0.3"
    s.license = "MIT"
    s.summary = "Unleashing the real power of Core Data with the elegance and safety of Swift"
    s.homepage = "https://github.com/JohnEstropia/CoreStore"
--- a/CoreStore.xcodeproj/project.pbxproj
+++ b/CoreStore.xcodeproj/project.pbxproj
@@ -238,6 +238,10 @@
 		B538BA781D15B3E30003A766 /* CoreStoreBridge.m in Sources */ = {isa = PBXBuildFile; fileRef = B538BA701D15B3E30003A766 /* CoreStoreBridge.m */; };
 		B538BA791D15B3E30003A766 /* CoreStoreBridge.m in Sources */ = {isa = PBXBuildFile; fileRef = B538BA701D15B3E30003A766 /* CoreStoreBridge.m */; };
 		B538BA7A1D15B3E30003A766 /* CoreStoreBridge.m in Sources */ = {isa = PBXBuildFile; fileRef = B538BA701D15B3E30003A766 /* CoreStoreBridge.m */; };
+		B53B275F1EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */ = {isa = PBXBuildFile; fileRef = B53B275E1EE3B92E00E9B352 /* CoreStoreManagedObject.swift */; };
+		B53B27601EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */ = {isa = PBXBuildFile; fileRef = B53B275E1EE3B92E00E9B352 /* CoreStoreManagedObject.swift */; };
+		B53B27611EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */ = {isa = PBXBuildFile; fileRef = B53B275E1EE3B92E00E9B352 /* CoreStoreManagedObject.swift */; };
+		B53B27621EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */ = {isa = PBXBuildFile; fileRef = B53B275E1EE3B92E00E9B352 /* CoreStoreManagedObject.swift */; };
 		B53FB9FE1CAB2D2F00F0D40A /* CSMigrationResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = B53FB9FD1CAB2D2F00F0D40A /* CSMigrationResult.swift */; };
 		B53FBA001CAB2D2F00F0D40A /* CSMigrationResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = B53FB9FD1CAB2D2F00F0D40A /* CSMigrationResult.swift */; };
 		B53FBA011CAB2D2F00F0D40A /* CSMigrationResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = B53FB9FD1CAB2D2F00F0D40A /* CSMigrationResult.swift */; };
@@ -752,6 +756,7 @@
 		B52FD3A91E3B3EF10001D919 /* NSManagedObject+Logging.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "NSManagedObject+Logging.swift"; sourceTree = "<group>"; };
 		B533C4DA1D7D4BFA001383CB /* DispatchQueue+CoreStore.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "DispatchQueue+CoreStore.swift"; sourceTree = "<group>"; };
 		B538BA701D15B3E30003A766 /* CoreStoreBridge.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CoreStoreBridge.m; sourceTree = "<group>"; };
+		B53B275E1EE3B92E00E9B352 /* CoreStoreManagedObject.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CoreStoreManagedObject.swift; sourceTree = "<group>"; };
 		B53FB9FD1CAB2D2F00F0D40A /* CSMigrationResult.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CSMigrationResult.swift; sourceTree = "<group>"; };
 		B53FBA031CAB300C00F0D40A /* CSMigrationType.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CSMigrationType.swift; sourceTree = "<group>"; };
 		B53FBA0A1CAB5E6500F0D40A /* CSCoreStore+Migrating.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "CSCoreStore+Migrating.swift"; sourceTree = "<group>"; };
@@ -1425,16 +1430,17 @@
 			children = (
 				B5C976E61C6E3A5900B1AF90 /* CoreStoreFetchedResultsController.swift */,
 				B526613F1CADD585007B85D9 /* CoreStoreFetchRequest+CoreStore.swift */,
-				B51260881E9B252B00402229 /* NSEntityDescription+DynamicModel.swift */,
-				B56923C31EB823B4007C4DC9 /* NSEntityDescription+Migration.swift */,
+				B53B275E1EE3B92E00E9B352 /* CoreStoreManagedObject.swift */,
+				B533C4DA1D7D4BFA001383CB /* DispatchQueue+CoreStore.swift */,
 				B51260921E9B28F100402229 /* EntityIdentifier.swift */,
 				B54A6A541BA15F2A007870FD /* FetchedResultsControllerDelegate.swift */,
 				B5E834BA1B7691F3001D3D50 /* Functions.swift */,
 				B5FAD6AB1B51285300714891 /* MigrationManager.swift */,
 				B5E84F2B1AFF849C0064E85B /* NotificationObserver.swift */,
-				B533C4DA1D7D4BFA001383CB /* DispatchQueue+CoreStore.swift */,
-				B52FD3A91E3B3EF10001D919 /* NSManagedObject+Logging.swift */,
+				B51260881E9B252B00402229 /* NSEntityDescription+DynamicModel.swift */,
+				B56923C31EB823B4007C4DC9 /* NSEntityDescription+Migration.swift */,
 				B58D0C621EAA0C7E003EDD87 /* NSManagedObject+DynamicModel.swift */,
+				B52FD3A91E3B3EF10001D919 /* NSManagedObject+Logging.swift */,
 				B5E84F2C1AFF849C0064E85B /* NSManagedObjectContext+CoreStore.swift */,
 				B5E84F351AFF85470064E85B /* NSManagedObjectContext+Querying.swift */,
 				B5E84F321AFF85470064E85B /* NSManagedObjectContext+Setup.swift */,
@@ -1875,6 +1881,7 @@
 				B5E2222A1CA51B6E00BA2E95 /* CSUnsafeDataTransaction.swift in Sources */,
 				B5E84F391AFF85470064E85B /* NSManagedObjectContext+Querying.swift in Sources */,
 				B56923E81EB827F5007C4DC9 /* InferredSchemaMappingProvider.swift in Sources */,
+				B53B275F1EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */,
 				B5D33A011E96012400C880DE /* Relationship.swift in Sources */,
 				B5E84EE81AFF84610064E85B /* CoreStoreLogger.swift in Sources */,
 				B56923C91EB82410007C4DC9 /* NSManagedObjectModel+Migration.swift in Sources */,
@@ -2059,6 +2066,7 @@
 				82BA18A71C4BBD2900A0916E /* CoreStore+Logging.swift in Sources */,
 				82BA18D81C4BBD7100A0916E /* WeakObject.swift in Sources */,
 				B56923E91EB827F5007C4DC9 /* InferredSchemaMappingProvider.swift in Sources */,
+				B53B27601EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */,
 				B5D33A021E96012400C880DE /* Relationship.swift in Sources */,
 				B559CD4B1CAA8C6D00E4D58B /* CSStorageInterface.swift in Sources */,
 				B56923CA1EB82410007C4DC9 /* NSManagedObjectModel+Migration.swift in Sources */,
@@ -2243,6 +2251,7 @@
 				B52DD1A71BE1F93200949AFE /* BaseDataTransaction+Querying.swift in Sources */,
 				B546F96C1C9AF26D00D5AC55 /* CSInMemoryStore.swift in Sources */,
 				B56923EB1EB827F5007C4DC9 /* InferredSchemaMappingProvider.swift in Sources */,
+				B53B27621EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */,
 				B5D33A041E96012400C880DE /* Relationship.swift in Sources */,
 				B52DD1C61BE1F94600949AFE /* NSManagedObjectContext+CoreStore.swift in Sources */,
 				B56923CC1EB82410007C4DC9 /* NSManagedObjectModel+Migration.swift in Sources */,
@@ -2427,6 +2436,7 @@
 				B563219F1BD65216006C9394 /* ObjectMonitor.swift in Sources */,
 				B56321B61BD6521C006C9394 /* WeakObject.swift in Sources */,
 				B56923EA1EB827F5007C4DC9 /* InferredSchemaMappingProvider.swift in Sources */,
+				B53B27611EE3B92E00E9B352 /* CoreStoreManagedObject.swift in Sources */,
 				B5D33A031E96012400C880DE /* Relationship.swift in Sources */,
 				B559CD4C1CAA8C6D00E4D58B /* CSStorageInterface.swift in Sources */,
 				B56923CB1EB82410007C4DC9 /* NSManagedObjectModel+Migration.swift in Sources */,
--- a/CoreStoreDemo/CoreStoreDemo/AppDelegate.swift
+++ b/CoreStoreDemo/CoreStoreDemo/AppDelegate.swift
@@ -8,7 +8,6 @@

 import UIKit

-import CoreStore

 // MARK: - AppDelegate

--- a/CoreStoreDemo/CoreStoreDemo/Info.plist
+++ b/CoreStoreDemo/CoreStoreDemo/Info.plist
@@ -17,11 +17,11 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.0.1</string>
+	<string>4.0.3</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
-	<string>1</string>
+	<string>4</string>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
 	<key>UILaunchStoryboardName</key>
--- a/Demo/MigrationsDemoViewController.swift
+++ b/Demo/MigrationsDemoViewController.swift
@@ -46,7 +46,7 @@ class MigrationsDemoViewController: UIViewController, ListObserver, UITableViewD
        self.present(alert, animated: true, completion: nil)
        
        
-        let modelMetadata = withExtendedLifetime(DataStack(modelName: "MigrationDemo")) {
+        let modelMetadata = withExtendedLifetime(DataStack(xcodeModelName: "MigrationDemo")) {
            (dataStack: DataStack) -> ModelMetadata in
            
            let models = self.models
@@ -91,6 +91,11 @@ class MigrationsDemoViewController: UIViewController, ListObserver, UITableViewD
        }
    }
    
+    func listMonitorDidRefetch(_ monitor: ListMonitor<NSManagedObject>) {
+        
+        self.listMonitorDidChange(monitor)
+    }
+    
    // MARK: UITableViewDataSource
    
    @objc dynamic func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
@@ -148,7 +153,10 @@ class MigrationsDemoViewController: UIViewController, ListObserver, UITableViewD
            label: "Model V1",
            entityType: OrganismV1.self,
            schemaHistory: SchemaHistory(
-                modelName: "MigrationDemo",
+                XcodeDataModelSchema.from(
+                    modelName: "MigrationDemo",
+                    migrationChain: ["MigrationDemoV3", "MigrationDemoV2", "MigrationDemo"]
+                ),
                migrationChain: ["MigrationDemoV3", "MigrationDemoV2", "MigrationDemo"]
            )
        ),
@@ -156,7 +164,13 @@ class MigrationsDemoViewController: UIViewController, ListObserver, UITableViewD
            label: "Model V2",
            entityType: OrganismV2.self,
            schemaHistory: SchemaHistory(
-                modelName: "MigrationDemo",
+                XcodeDataModelSchema.from(
+                    modelName: "MigrationDemo",
+                    migrationChain: [
+                        "MigrationDemo": "MigrationDemoV2",
+                        "MigrationDemoV3": "MigrationDemoV2"
+                    ]
+                ),
                migrationChain: [
                    "MigrationDemo": "MigrationDemoV2",
                    "MigrationDemoV3": "MigrationDemoV2"
@@ -167,7 +181,10 @@ class MigrationsDemoViewController: UIViewController, ListObserver, UITableViewD
            label: "Model V3",
            entityType: OrganismV3.self,
            schemaHistory: SchemaHistory(
-                modelName: "MigrationDemo",
+                XcodeDataModelSchema.from(
+                    modelName: "MigrationDemo",
+                    migrationChain: ["MigrationDemo", "MigrationDemoV2", "MigrationDemoV3"]
+                ),
                migrationChain: ["MigrationDemo", "MigrationDemoV2", "MigrationDemoV3"]
            )
        )
--- a/Demo/StackSetupDemoViewController.swift
+++ b/Demo/StackSetupDemoViewController.swift
@@ -17,7 +17,7 @@ private struct Static {
    
    static let facebookStack: DataStack = {
        
-        let dataStack = DataStack(modelName: "StackSetupDemo")
+        let dataStack = DataStack(xcodeModelName: "StackSetupDemo")
        try! dataStack.addStorageAndWait(
            SQLiteStore(
                fileName: "AccountsDemo_FB_Male.sqlite",
@@ -55,7 +55,7 @@ private struct Static {
    
    static let twitterStack: DataStack = {
        
-        let dataStack = DataStack(modelName: "StackSetupDemo")
+        let dataStack = DataStack(xcodeModelName: "StackSetupDemo")
        try! dataStack.addStorageAndWait(
            SQLiteStore(
                fileName: "AccountsDemo_TW_Male.sqlite",
--- a/README.md
+++ b/README.md
@@ -22,6 +22,8 @@ Unleashing the real power of Core Data with the elegance and safety of Swift

 Upgrading from CoreStore 3.x to 4.x? Check out the [new features](#features) and make sure to read the [Migration guide](#upgrading-from-3xx-to-4xx).

+CoreStore is now part of the [Swift Source Compatibility projects](https://swift.org/source-compatibility/#current-list-of-projects).
+

 ## Why use CoreStore?
 CoreStore is the answer to the [challenges](http://inessential.com/2010/02/26/on_switching_away_from_core_data) [of](http://bsktapp.com/blog/why-is-realm-great-and-why-are-we-not-using-it/) [using](https://www.quora.com/Why-would-you-use-Realm-over-Core-Data) [Core](http://sebastiandobrincu.com/blog/5-reasons-why-you-should-choose-realm-over-coredata) [Data](https://medium.com/the-way-north/ditching-core-data-865c1bb5564c#.a5h8ou6ri). 
@@ -88,6 +90,7 @@ CoreStore was (and is) heavily shaped by real-world needs of developing data-dep
        - [Observe a list of objects](#observe-a-list-of-objects)
    - [Objective-C support](#objective-c-support)
    - [Type-safe `CoreStoreObject`s](#type-safe-corestoreobjects)
+        - [`VersionLock`s](#versionlocks)
 - [Roadmap](#roadmap)
 - [Installation](#installation)
 - [Changesets](#changesets)
@@ -457,6 +460,55 @@ CoreStore.defaultStack = DataStack(
 )   
 ```

+**`CoreStoreSchema`-based model versions with progressive migration**
+```swift
+typealias Animal = V2.Animal
+typealias Dog = V2.Dog
+typealias Person = V2.Person
+enum V2 {
+    class Animal: CoreStoreObject {
+        // ...
+    }
+    class Dog: Animal {
+        // ...
+    }
+    class Person: CoreStoreObject {
+        // ...
+    }
+}
+enum V1 {
+    class Animal: CoreStoreObject {
+        // ...
+    }
+    class Dog: Animal {
+        // ...
+    }
+    class Person: CoreStoreObject {
+        // ...
+    }
+}
+
+CoreStore.defaultStack = DataStack(
+    CoreStoreSchema(
+        modelVersion: "V1",
+        entities: [
+            Entity<V1.Animal>("Animal", isAbstract: true),
+            Entity<V1.Dog>("Dog"),
+            Entity<V1.Person>("Person")
+        ]
+    ),
+    CoreStoreSchema(
+        modelVersion: "V2",
+        entities: [
+            Entity<V2.Animal>("Animal", isAbstract: true),
+            Entity<V2.Dog>("Dog"),
+            Entity<V2.Person>("Person")
+        ]
+    ),
+    migrationChain: ["V1", "V2"]
+)
+```
+

 ### Starting migrations
 We have seen `addStorageAndWait(...)` used to initialize our persistent store. As the method name's *~AndWait* suffix suggests though, this method blocks so it should not do long tasks such as store migrations. In fact CoreStore will only attempt a synchronous **lightweight** migration if you explicitly provide the `.allowSynchronousLightweightMigration` option:
@@ -1696,6 +1748,39 @@ let puppies = CoreStore.fetchAll(

 All CoreStore APIs that are usable with `NSManagedObject`s are also available for `CoreStoreObject`s. These include `ListMonitor`s, `ImportableObject`s, fetching, etc.

+### `VersionLock`s
+
+While it is convenient to be able to declare entities only in code, it is worrying that we might accidentally change the `CoreStoreObject`'s properties and break our users' model version history. For this, the `CoreStoreSchema` allows us to "lock" our properties to a particular configuration. Any changes to that `VersionLock` will raise an assertion failure during the `CoreStoreSchema` initialization, so you can then look for the commit which changed the `VersionLock` hash.
+
+To use `VersionLock`s, create the `CoreStoreSchema`, run the app, and look for this particular log message that is automatically printed to the console:
+
+<img width="700" alt="VersionLock" src="https://cloud.githubusercontent.com/assets/3029684/26525632/757f1bd0-4398-11e7-9795-4132a2df0538.png" />
+
+Copy this dictionary value and use it as the `versionLock:` argument of the `CoreStoreSchema` initializer:
+```swift
+CoreStoreSchema(
+    modelVersion: "V1",
+    entities: [
+        Entity<Animal>("Animal", isAbstract: true),
+        Entity<Dog>("Dog"),
+        Entity<Person>("Person"),
+    ],
+    versionLock: [
+        "Animal": [0x1b59d511019695cf, 0xdeb97e86c5eff179, 0x1cfd80745646cb3, 0x4ff99416175b5b9a],
+        "Dog": [0xe3f0afeb109b283a, 0x29998d292938eb61, 0x6aab788333cfc2a3, 0x492ff1d295910ea7],
+        "Person": [0x66d8bbfd8b21561f, 0xcecec69ecae3570f, 0xc4b73d71256214ef, 0x89b99bfe3e013e8b]
+    ]
+)
+```
+You can also get this hash after the `DataStack` has been fully set up by printing to the console:
+```swift
+print(CoreStore.defaultStack.modelSchema.printCoreStoreSchema())
+```
+
+Once the version lock is set, any changes in the properties or to the model will trigger an assertion failure similar to this:
+
+<img width="700" alt="VersionLock failure" src="https://cloud.githubusercontent.com/assets/3029684/26525666/92f46f0c-4399-11e7-9395-4379f6f20876.png" />
+

 # Installation
 - Requires:
--- a/Sources/CSAsynchronousDataTransaction.swift
+++ b/Sources/CSAsynchronousDataTransaction.swift
@@ -35,7 +35,7 @@ import CoreData
 - SeeAlso: `AsynchronousDataTransaction`
 */
@objc
-public final class CSAsynchronousDataTransaction: CSBaseDataTransaction {
+public final class CSAsynchronousDataTransaction: CSBaseDataTransaction, CoreStoreObjectiveCType {
    
    /**
     Saves the transaction changes. This method should not be used after the `-commitWithCompletion:` method was already called once.
@@ -139,9 +139,9 @@ public final class CSAsynchronousDataTransaction: CSBaseDataTransaction {
    
    public typealias SwiftType = AsynchronousDataTransaction
    
-    public override var bridgeToSwift: AsynchronousDataTransaction {
+    public var bridgeToSwift: AsynchronousDataTransaction {
        
-        return super.bridgeToSwift as! AsynchronousDataTransaction
+        return super.swiftTransaction as! AsynchronousDataTransaction
    }
    
    public required init(_ swiftValue: AsynchronousDataTransaction) {
@@ -149,9 +149,9 @@ public final class CSAsynchronousDataTransaction: CSBaseDataTransaction {
        super.init(swiftValue as BaseDataTransaction)
    }
    
-    public required init(_ swiftValue: BaseDataTransaction) {
+    public required override init(_ swiftValue: BaseDataTransaction) {
        
-        super.init(swiftValue as! AsynchronousDataTransaction)
+        super.init(swiftValue)
    }
    
    
--- a/Sources/CSBaseDataTransaction+Querying.swift
+++ b/Sources/CSBaseDataTransaction+Querying.swift
@@ -40,7 +40,7 @@ public extension CSBaseDataTransaction {
    @objc
    public func fetchExistingObject(_ object: NSManagedObject) -> Any? {
        
-        return self.bridgeToSwift.context.fetchExisting(object) as NSManagedObject?
+        return self.swiftTransaction.context.fetchExisting(object) as NSManagedObject?
    }
    
    /**
@@ -52,7 +52,7 @@ public extension CSBaseDataTransaction {
    @objc
    public func fetchExistingObjectWithID(_ objectID: NSManagedObjectID) -> Any? {
        
-        return self.bridgeToSwift.context.fetchExisting(objectID) as NSManagedObject?
+        return self.swiftTransaction.context.fetchExisting(objectID) as NSManagedObject?
    }
    
    /**
@@ -64,7 +64,7 @@ public extension CSBaseDataTransaction {
    @objc
    public func fetchExistingObjects(_ objects: [NSManagedObject]) -> [Any] {
        
-        return self.bridgeToSwift.context.fetchExisting(objects) as [NSManagedObject]
+        return self.swiftTransaction.context.fetchExisting(objects) as [NSManagedObject]
    }
    
    /**
@@ -76,7 +76,7 @@ public extension CSBaseDataTransaction {
    @objc
    public func fetchExistingObjectsWithIDs(_ objectIDs: [NSManagedObjectID]) -> [Any] {
        
-        return self.bridgeToSwift.context.fetchExisting(objectIDs) as [NSManagedObject]
+        return self.swiftTransaction.context.fetchExisting(objectIDs) as [NSManagedObject]
    }
    
    /**
@@ -90,10 +90,10 @@ public extension CSBaseDataTransaction {
    public func fetchOneFrom(_ from: CSFrom, fetchClauses: [CSFetchClause]) -> Any? {
        
        CoreStore.assert(
-            self.bridgeToSwift.isRunningInAllowedQueue(),
+            self.swiftTransaction.isRunningInAllowedQueue(),
            "Attempted to fetch from a \(cs_typeName(self)) outside its designated queue."
        )
-        return self.bridgeToSwift.context.fetchOne(from, fetchClauses)
+        return self.swiftTransaction.context.fetchOne(from, fetchClauses)
    }
    
    /**
@@ -107,10 +107,10 @@ public extension CSBaseDataTransaction {
    public func fetchAllFrom(_ from: CSFrom, fetchClauses: [CSFetchClause]) -> [Any]? {
        
        CoreStore.assert(
-            self.bridgeToSwift.isRunningInAllowedQueue(),
+            self.swiftTransaction.isRunningInAllowedQueue(),
            "Attempted to fetch from a \(cs_typeName(self)) outside its designated queue."
        )
-        return self.bridgeToSwift.context.fetchAll(from, fetchClauses)
+        return self.swiftTransaction.context.fetchAll(from, fetchClauses)
    }
    
    /**
@@ -124,10 +124,10 @@ public extension CSBaseDataTransaction {
    public func fetchCountFrom(_ from: CSFrom, fetchClauses: [CSFetchClause]) -> NSNumber? {
        
        CoreStore.assert(
-            self.bridgeToSwift.isRunningInAllowedQueue(),
+            self.swiftTransaction.isRunningInAllowedQueue(),
            "Attempted to fetch from a \(cs_typeName(self)) outside its designated queue."
        )
-        return self.bridgeToSwift.context
+        return self.swiftTransaction.context
            .fetchCount(from, fetchClauses)
            .flatMap { NSNumber(value: $0) }
    }
@@ -143,10 +143,10 @@ public extension CSBaseDataTransaction {
    public func fetchObjectIDFrom(_ from: CSFrom, fetchClauses: [CSFetchClause]) -> NSManagedObjectID? {
        
        CoreStore.assert(
-            self.bridgeToSwift.isRunningInAllowedQueue(),
+            self.swiftTransaction.isRunningInAllowedQueue(),
            "Attempted to fetch from a \(cs_typeName(self)) outside its designated queue."
        )
-        return self.bridgeToSwift.context.fetchObjectID(from, fetchClauses)
+        return self.swiftTransaction.context.fetchObjectID(from, fetchClauses)
    }
    
    /**
@@ -163,10 +163,10 @@ public extension CSBaseDataTransaction {
    public func queryValueFrom(_ from: CSFrom, selectClause: CSSelect, queryClauses: [CSQueryClause]) -> Any? {
        
        CoreStore.assert(
-            self.bridgeToSwift.isRunningInAllowedQueue(),
+            self.swiftTransaction.isRunningInAllowedQueue(),
            "Attempted to query from a \(cs_typeName(self)) outside its designated queue."
        )
-        return self.bridgeToSwift.context.queryValue(from, selectClause, queryClauses)
+        return self.swiftTransaction.context.queryValue(from, selectClause, queryClauses)
    }
    
    /**
@@ -183,9 +183,9 @@ public extension CSBaseDataTransaction {
    public func queryAttributesFrom(_ from: CSFrom, selectClause: CSSelect, queryClauses: [CSQueryClause]) -> [[String: Any]]? {
        
        CoreStore.assert(
-            self.bridgeToSwift.isRunningInAllowedQueue(),
+            self.swiftTransaction.isRunningInAllowedQueue(),
            "Attempted to query from a \(cs_typeName(self)) outside its designated queue."
        )
-        return self.bridgeToSwift.context.queryAttributes(from, selectClause, queryClauses)
+        return self.swiftTransaction.context.queryAttributes(from, selectClause, queryClauses)
    }
 }
--- a/Sources/CSBaseDataTransaction.swift
+++ b/Sources/CSBaseDataTransaction.swift
@@ -35,7 +35,7 @@ import CoreData
 - SeeAlso: `BaseDataTransaction`
 */
@objc
-public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
+public class CSBaseDataTransaction: NSObject {
    
    // MARK: Object management
    
@@ -45,7 +45,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public var hasChanges: Bool {
        
-        return self.bridgeToSwift.hasChanges
+        return self.swiftTransaction.hasChanges
    }
    
    /**
@@ -57,7 +57,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func createInto(_ into: CSInto) -> Any {
        
-        return self.bridgeToSwift.create(into.bridgeToSwift)
+        return self.swiftTransaction.create(into.bridgeToSwift)
    }
    
    /**
@@ -69,7 +69,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func editObject(_ object: NSManagedObject?) -> Any? {
        
-        return self.bridgeToSwift.edit(object)
+        return self.swiftTransaction.edit(object)
    }
    
    /**
@@ -82,7 +82,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func editInto(_ into: CSInto, objectID: NSManagedObjectID) -> Any? {
        
-        return self.bridgeToSwift.edit(into.bridgeToSwift, objectID)
+        return self.swiftTransaction.edit(into.bridgeToSwift, objectID)
    }

    /**
@@ -93,7 +93,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func deleteObject(_ object: NSManagedObject?) {
        
-        self.bridgeToSwift.delete(object)
+        self.swiftTransaction.delete(object)
    }
    
    /**
@@ -104,7 +104,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func deleteObjects(_ objects: [NSManagedObject]) {
        
-        self.bridgeToSwift.delete(objects)
+        self.swiftTransaction.delete(objects)
    }
    
    /**
@@ -113,7 +113,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func refreshAndMergeAllObjects() {
        
-        self.bridgeToSwift.refreshAndMergeAllObjects()
+        self.swiftTransaction.refreshAndMergeAllObjects()
    }
    
    
@@ -128,7 +128,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func insertedObjectsOfType(_ entity: NSManagedObject.Type) -> Set<NSManagedObject> {
        
-        return self.bridgeToSwift.insertedObjects(entity)
+        return self.swiftTransaction.insertedObjects(entity)
    }
    
    /**
@@ -139,7 +139,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func insertedObjectIDs() -> Set<NSManagedObjectID> {
        
-        return self.bridgeToSwift.insertedObjectIDs()
+        return self.swiftTransaction.insertedObjectIDs()
    }
    
    /**
@@ -151,7 +151,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func insertedObjectIDsOfType(_ entity: NSManagedObject.Type) -> Set<NSManagedObjectID> {
        
-        return self.bridgeToSwift.insertedObjectIDs(entity)
+        return self.swiftTransaction.insertedObjectIDs(entity)
    }
    
    /**
@@ -163,7 +163,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func updatedObjectsOfType(_ entity: NSManagedObject.Type) -> Set<NSManagedObject> {
        
-        return self.bridgeToSwift.updatedObjects(entity)
+        return self.swiftTransaction.updatedObjects(entity)
    }
    
    /**
@@ -174,7 +174,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func updatedObjectIDs() -> Set<NSManagedObjectID> {
        
-        return self.bridgeToSwift.updatedObjectIDs()
+        return self.swiftTransaction.updatedObjectIDs()
    }
    
    /**
@@ -186,7 +186,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func updatedObjectIDsOfType(_ entity: NSManagedObject.Type) -> Set<NSManagedObjectID> {
        
-        return self.bridgeToSwift.updatedObjectIDs(entity)
+        return self.swiftTransaction.updatedObjectIDs(entity)
    }
    
    /**
@@ -198,7 +198,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func deletedObjectsOfType(_ entity: NSManagedObject.Type) -> Set<NSManagedObject> {
        
-        return self.bridgeToSwift.deletedObjects(entity)
+        return self.swiftTransaction.deletedObjects(entity)
    }
    
    /**
@@ -209,7 +209,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func deletedObjectIDs() -> Set<NSManagedObjectID> {
        
-        return self.bridgeToSwift.deletedObjectIDs()
+        return self.swiftTransaction.deletedObjectIDs()
    }

    /**
@@ -221,7 +221,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func deletedObjectIDsOfType(_ entity: NSManagedObject.Type) -> Set<NSManagedObjectID> {
        
-        return self.bridgeToSwift.deletedObjectIDs(entity)
+        return self.swiftTransaction.deletedObjectIDs(entity)
    }
    
    
@@ -229,7 +229,7 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    
    public override var hash: Int {
        
-        return ObjectIdentifier(self.bridgeToSwift).hashValue
+        return ObjectIdentifier(self.swiftTransaction).hashValue
    }
    
    public override func isEqual(_ object: Any?) -> Bool {
@@ -238,28 +238,20 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
            
            return false
        }
-        return self.bridgeToSwift === object.bridgeToSwift
+        return self.swiftTransaction === object.swiftTransaction
    }
    
    
-    // MARK: CoreStoreObjectiveCType
+    // MARK: Internal
    
-    public required init(_ swiftValue: BaseDataTransaction) {
+    internal let swiftTransaction: BaseDataTransaction
+    
+    internal init(_ swiftValue: BaseDataTransaction) {
        
        self.swiftTransaction = swiftValue
        super.init()
    }
    
-    public var bridgeToSwift: BaseDataTransaction {
-        
-        return self.swiftTransaction
-    }
-    
-    
-    // MARK: Private
-    
-    private let swiftTransaction: BaseDataTransaction
-    
    
    // MARK: Deprecated
    
@@ -267,20 +259,20 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
    @objc
    public func insertedObjects() -> Set<NSManagedObject> {
        
-        return self.bridgeToSwift.insertedObjects()
+        return self.swiftTransaction.insertedObjects()
    }
    
    @available(*, deprecated, message: "Use -[updatedObjectsOfType:] and pass the specific entity class")
    @objc
    public func updatedObjects() -> Set<NSManagedObject> {
        
-        return self.bridgeToSwift.updatedObjects()
+        return self.swiftTransaction.updatedObjects()
    }
    
    @available(*, deprecated, message: "Use -[deletedObjectsOfType:] and pass the specific entity class")
    @objc
    public func deletedObjects() -> Set<NSManagedObject> {
        
-        return self.bridgeToSwift.deletedObjects()
+        return self.swiftTransaction.deletedObjects()
    }
 }
--- a/Sources/CSSynchronousDataTransaction.swift
+++ b/Sources/CSSynchronousDataTransaction.swift
@@ -35,7 +35,7 @@ import CoreData
 - SeeAlso: `SynchronousDataTransaction`
 */
@objc
-public final class CSSynchronousDataTransaction: CSBaseDataTransaction {
+public final class CSSynchronousDataTransaction: CSBaseDataTransaction, CoreStoreObjectiveCType {
    
    /**
     Saves the transaction changes and waits for completion synchronously. This method should not be used after the `-commitAndWaitWithError:` method was already called once.
@@ -129,9 +129,9 @@ public final class CSSynchronousDataTransaction: CSBaseDataTransaction {
    
    public typealias SwiftType = SynchronousDataTransaction
    
-    public override var bridgeToSwift: SynchronousDataTransaction {
+    public var bridgeToSwift: SynchronousDataTransaction {
        
-        return super.bridgeToSwift as! SynchronousDataTransaction
+        return super.swiftTransaction as! SynchronousDataTransaction
    }
    
    public required init(_ swiftValue: SynchronousDataTransaction) {
@@ -139,9 +139,9 @@ public final class CSSynchronousDataTransaction: CSBaseDataTransaction {
        super.init(swiftValue as BaseDataTransaction)
    }
    
-    public required init(_ swiftValue: BaseDataTransaction) {
+    public required override init(_ swiftValue: BaseDataTransaction) {
        
-        super.init(swiftValue as! SynchronousDataTransaction)
+        super.init(swiftValue)
    }
    
    
--- a/Sources/CSUnsafeDataTransaction.swift
+++ b/Sources/CSUnsafeDataTransaction.swift
@@ -35,7 +35,7 @@ import CoreData
 - SeeAlso: `UnsafeDataTransaction`
 */
@objc
-public final class CSUnsafeDataTransaction: CSBaseDataTransaction {
+public final class CSUnsafeDataTransaction: CSBaseDataTransaction, CoreStoreObjectiveCType {
    /**
     Saves the transaction changes asynchronously. For a `CSUnsafeDataTransaction`, multiple commits are allowed, although it is the developer's responsibility to ensure a reasonable leeway to prevent blocking the main thread.
     
@@ -189,9 +189,9 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction {
    
    public typealias SwiftType = UnsafeDataTransaction
    
-    public override var bridgeToSwift: UnsafeDataTransaction {
+    public var bridgeToSwift: UnsafeDataTransaction {
        
-        return super.bridgeToSwift as! UnsafeDataTransaction
+        return super.swiftTransaction as! UnsafeDataTransaction
    }
    
    public required init(_ swiftValue: UnsafeDataTransaction) {
@@ -199,9 +199,9 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction {
        super.init(swiftValue as BaseDataTransaction)
    }
    
-    public required init(_ swiftValue: BaseDataTransaction) {
+    public required override init(_ swiftValue: BaseDataTransaction) {
        
-        super.init(swiftValue as! UnsafeDataTransaction)
+        super.init(swiftValue)
    }
    
    
--- a/Sources/CoreStoreFetchedResultsController.swift
+++ b/Sources/CoreStoreFetchedResultsController.swift
@@ -35,7 +35,7 @@ internal final class CoreStoreFetchedResultsController: NSFetchedResultsControll
    // MARK: Internal
    
    @nonobjc
-    internal convenience init<T: DynamicObject>(dataStack: DataStack, fetchRequest: NSFetchRequest<NSManagedObject>, from: From<T>?, sectionBy: SectionBy? = nil, applyFetchClauses: @escaping (_ fetchRequest: NSFetchRequest<NSManagedObject>) -> Void) {
+    internal convenience init<T: DynamicObject>(dataStack: DataStack, fetchRequest: NSFetchRequest<NSManagedObject>, from: From<T>, sectionBy: SectionBy? = nil, applyFetchClauses: @escaping (_ fetchRequest: NSFetchRequest<NSManagedObject>) -> Void) {
        
        self.init(
            context: dataStack.mainContext,
@@ -47,33 +47,18 @@ internal final class CoreStoreFetchedResultsController: NSFetchedResultsControll
    }
    
    @nonobjc
-    internal init<T: DynamicObject>(context: NSManagedObjectContext, fetchRequest: NSFetchRequest<NSManagedObject>, from: From<T>?, sectionBy: SectionBy? = nil, applyFetchClauses: @escaping (_ fetchRequest: NSFetchRequest<NSManagedObject>) -> Void) {
+    internal init<T: DynamicObject>(context: NSManagedObjectContext, fetchRequest: NSFetchRequest<NSManagedObject>, from: From<T>, sectionBy: SectionBy? = nil, applyFetchClauses: @escaping (_ fetchRequest: NSFetchRequest<NSManagedObject>) -> Void) {
        
-        _ = from?.applyToFetchRequest(
+        _ = from.applyToFetchRequest(
            fetchRequest,
            context: context,
            applyAffectedStores: false
        )
        applyFetchClauses(fetchRequest)
        
-        if let from = from {
+        self.reapplyAffectedStores = { fetchRequest, context in
            
-            self.reapplyAffectedStores = { fetchRequest, context in
-                
-                return from.applyAffectedStoresForFetchedRequest(fetchRequest, context: context)
-            }
-        }
-        else {
-            
-            guard let from = (fetchRequest.entity.flatMap { $0.managedObjectClassName }).flatMap(NSClassFromString).flatMap({ From<T>($0 as! T.Type) }) else {
-                
-                CoreStore.abort("Attempted to create a \(CoreStoreFetchedResultsController.self) without a \(cs_typeName(From<T>.self)) clause or an \(cs_typeName(NSEntityDescription.self)).")
-            }
-            
-            self.reapplyAffectedStores = { fetchRequest, context in
-                
-                return from.applyAffectedStoresForFetchedRequest(fetchRequest, context: context)
-            }
+            return from.applyAffectedStoresForFetchedRequest(fetchRequest, context: context)
        }
        
        super.init(
--- a/Sources/CoreStoreManagedObject.swift
+++ b/Sources/CoreStoreManagedObject.swift
@@ -0,0 +1,48 @@
+//
+//  CoreStoreManagedObject.swift
+//  CoreStore
+//
+//  Created by John Rommel Estropia on 2017/06/04.
+//  Copyright © 2017 John Rommel Estropia. All rights reserved.
+//
+
+import CoreData
+
+
+// MARK: - CoreStoreManagedObject
+
+@objc internal class CoreStoreManagedObject: NSManagedObject {
+    
+    @nonobjc
+    internal class func cs_setKeyPathsForValuesAffectingKeys(_ keyPathsForValuesAffectingKeys: [KeyPath: Set<KeyPath>], for managedObjectClass: CoreStoreManagedObject.Type) {
+        
+        Static.queue.sync(flags: .barrier) {
+            
+            Static.cache[ObjectIdentifier(managedObjectClass)] = keyPathsForValuesAffectingKeys
+        }
+    }
+    
+    // MARK: NSManagedObject
+    
+    override class func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String> {
+        
+        return Static.queue.sync(flags: .barrier) {
+            
+            let cacheKey = ObjectIdentifier(self)
+            if let keyPathsForValuesAffectingKeys = Static.cache[cacheKey] {
+                
+                return keyPathsForValuesAffectingKeys[key] ?? []
+            }
+            return super.keyPathsForValuesAffectingValue(forKey: key)
+        }
+    }
+}
+
+
+// MARK: - Private
+
+private enum Static {
+    
+    static let queue = DispatchQueue.concurrent("com.coreStore.coreStoreManagerObjectBarrierQueue")
+    static var cache: [ObjectIdentifier: [KeyPath: Set<KeyPath>]] = [:]
+}
--- a/Sources/CoreStoreObject+Querying.swift
+++ b/Sources/CoreStoreObject+Querying.swift
@@ -53,6 +53,39 @@ public extension DynamicObject where Self: CoreStoreObject {
        return attribute(self.meta).keyPath
    }
    
+    /**
+     Extracts the keyPath string from a `CoreStoreObject.Relationship` property.
+     ```
+     let keyPath: String = Person.keyPath { $0.pets }
+     ```
+     */
+    public static func keyPath<O: CoreStoreObject, D: CoreStoreObject>(_ relationship: (Self) -> RelationshipContainer<O>.ToOne<D>) -> String  {
+        
+        return relationship(self.meta).keyPath
+    }
+    
+    /**
+     Extracts the keyPath string from a `CoreStoreObject.Relationship` property.
+     ```
+     let keyPath: String = Person.keyPath { $0.pets }
+     ```
+     */
+    public static func keyPath<O: CoreStoreObject, D: CoreStoreObject>(_ relationship: (Self) -> RelationshipContainer<O>.ToManyOrdered<D>) -> String  {
+        
+        return relationship(self.meta).keyPath
+    }
+    
+    /**
+     Extracts the keyPath string from a `CoreStoreObject.Relationship` property.
+     ```
+     let keyPath: String = Person.keyPath { $0.pets }
+     ```
+     */
+    public static func keyPath<O: CoreStoreObject, D: CoreStoreObject>(_ relationship: (Self) -> RelationshipContainer<O>.ToManyUnordered<D>) -> String  {
+        
+        return relationship(self.meta).keyPath
+    }
+    
    /**
     Creates a `Where` clause from a `CoreStoreObject.Value` property.
     ```
@@ -67,10 +100,10 @@ public extension DynamicObject where Self: CoreStoreObject {
    /**
     Creates an `OrderBy` clause from a `CoreStoreObject.Value` property.
     ```
-     let person = CoreStore.fetchAll(From<Person>(), Person.ascending { $0.age })
+     let person = CoreStore.fetchAll(From<Person>(), Person.orderBy(ascending: { $0.age }))
     ```
     */
-    public static func ascending<O: CoreStoreObject, V: ImportableAttributeType>(_ attribute: (Self) -> ValueContainer<O>.Optional<V>) -> OrderBy  {
+    public static func orderBy<O: CoreStoreObject, V: ImportableAttributeType>(ascending attribute: (Self) -> ValueContainer<O>.Required<V>) -> OrderBy  {
        
        return OrderBy(.ascending(attribute(self.meta).keyPath))
    }
@@ -78,9 +111,46 @@ public extension DynamicObject where Self: CoreStoreObject {
    /**
     Creates an `OrderBy` clause from a `CoreStoreObject.Value` property.
     ```
-     let person = CoreStore.fetchAll(From<Person>(), Person.descending { $0.age })
+     let person = CoreStore.fetchAll(From<Person>(), Person.orderBy(ascending: { $0.age }))
     ```
     */
+    public static func orderBy<O: CoreStoreObject, V: ImportableAttributeType>(ascending attribute: (Self) -> ValueContainer<O>.Optional<V>) -> OrderBy  {
+        
+        return OrderBy(.ascending(attribute(self.meta).keyPath))
+    }
+    
+    /**
+     Creates an `OrderBy` clause from a `CoreStoreObject.Value` property.
+     ```
+     let person = CoreStore.fetchAll(From<Person>(), Person.orderBy(descending: { $0.age }))
+     ```
+     */
+    public static func orderBy<O: CoreStoreObject, V: ImportableAttributeType>(descending attribute: (Self) -> ValueContainer<O>.Required<V>) -> OrderBy  {
+        
+        return OrderBy(.descending(attribute(self.meta).keyPath))
+    }
+    
+    /**
+     Creates an `OrderBy` clause from a `CoreStoreObject.Value` property.
+     ```
+     let person = CoreStore.fetchAll(From<Person>(), Person.orderBy(descending: { $0.age }))
+     ```
+     */
+    public static func orderBy<O: CoreStoreObject, V: ImportableAttributeType>(descending attribute: (Self) -> ValueContainer<O>.Optional<V>) -> OrderBy  {
+        
+        return OrderBy(.descending(attribute(self.meta).keyPath))
+    }
+    
+    
+    // MARK: Deprecated
+    
+    @available(*, deprecated, renamed: "orderBy(ascending:)")
+    public static func ascending<O: CoreStoreObject, V: ImportableAttributeType>(_ attribute: (Self) -> ValueContainer<O>.Optional<V>) -> OrderBy  {
+        
+        return OrderBy(.ascending(attribute(self.meta).keyPath))
+    }
+    
+    @available(*, deprecated, renamed: "orderBy(descending:)")
    public static func descending<O: CoreStoreObject, V: ImportableAttributeType>(_ attribute: (Self) -> ValueContainer<O>.Optional<V>) -> OrderBy  {
        
        return OrderBy(.descending(attribute(self.meta).keyPath))
@@ -163,6 +233,18 @@ public extension ValueContainer.Required {
        
        return Where("%K >= %@", attribute.keyPath, value)
    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Value` property.
+     ```
+     let dog = CoreStore.fetchOne(From<Dog>(), Dog.where { ["Pluto", "Snoopy", "Scooby"] ~= $0.nickname })
+     ```
+     */
+    @inline(__always)
+    public static func ~= <S: Sequence>(_ sequence: S, _ attribute: ValueContainer<O>.Required<V>) -> Where where S.Iterator.Element == V {
+        
+        return Where(attribute.keyPath, isMemberOf: sequence)
+    }
 }


@@ -193,4 +275,146 @@ public extension ValueContainer.Optional {
        
        return !Where(attribute.keyPath, isEqualTo: value)
    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Value` property.
+     ```
+     let person = CoreStore.fetchOne(From<Person>(), Person.where { $0.age < 20 })
+     ```
+     */
+    @inline(__always)
+    public static func < (_ attribute: ValueContainer<O>.Optional<V>, _ value: V?) -> Where {
+        
+        if let value = value {
+            
+            return Where("%K < %@", attribute.keyPath, value)
+        }
+        else {
+            
+            return Where("%K < nil", attribute.keyPath)
+        }
+    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Value` property.
+     ```
+     let person = CoreStore.fetchOne(From<Person>(), Person.where { $0.age > 20 })
+     ```
+     */
+    @inline(__always)
+    public static func > (_ attribute: ValueContainer<O>.Optional<V>, _ value: V?) -> Where {
+        
+        if let value = value {
+            
+            return Where("%K > %@", attribute.keyPath, value)
+        }
+        else {
+            
+            return Where("%K > nil", attribute.keyPath)
+        }
+    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Value` property.
+     ```
+     let person = CoreStore.fetchOne(From<Person>(), Person.where { $0.age <= 20 })
+     ```
+     */
+    @inline(__always)
+    public static func <= (_ attribute: ValueContainer<O>.Optional<V>, _ value: V?) -> Where {
+        
+        if let value = value {
+            
+            return Where("%K <= %@", attribute.keyPath, value)
+        }
+        else {
+            
+            return Where("%K <= nil", attribute.keyPath)
+        }
+    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Value` property.
+     ```
+     let person = CoreStore.fetchOne(From<Person>(), Person.where { $0.age >= 20 })
+     ```
+     */
+    @inline(__always)
+    public static func >= (_ attribute: ValueContainer<O>.Optional<V>, _ value: V?) -> Where {
+        
+        if let value = value {
+            
+            return Where("%K >= %@", attribute.keyPath, value)
+        }
+        else {
+            
+            return Where("%K >= nil", attribute.keyPath)
+        }
+    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Value` property.
+     ```
+     let dog = CoreStore.fetchOne(From<Dog>(), Dog.where { ["Pluto", "Snoopy", "Scooby"] ~= $0.nickname })
+     ```
+     */
+    @inline(__always)
+    public static func ~= <S: Sequence>(_ sequence: S, _ attribute: ValueContainer<O>.Optional<V>) -> Where where S.Iterator.Element == V {
+        
+        return Where(attribute.keyPath, isMemberOf: sequence)
+    }
+}
+
+
+// MARK: - RelationshipContainer.ToOne
+
+public extension RelationshipContainer.ToOne {
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Relationship` property.
+     ```
+     let dog = CoreStore.fetchOne(From<Dog>(), Dog.where { $0.master == me })
+     ```
+     */
+    @inline(__always)
+    public static func == (_ relationship: RelationshipContainer<O>.ToOne<D>, _ object: D?) -> Where {
+        
+        return Where(relationship.keyPath, isEqualTo: object)
+    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Relationship` property.
+     ```
+     let dog = CoreStore.fetchOne(From<Dog>(), Dog.where { $0.master != me })
+     ```
+     */
+    @inline(__always)
+    public static func != (_ relationship: RelationshipContainer<O>.ToOne<D>, _ object: D?) -> Where {
+        
+        return !Where(relationship.keyPath, isEqualTo: object)
+    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Relationship` property.
+     ```
+     let dog = CoreStore.fetchOne(From<Dog>(), Dog.where { $0.master ~= me })
+     ```
+     */
+    @inline(__always)
+    public static func ~= (_ relationship: RelationshipContainer<O>.ToOne<D>, _ object: D?) -> Where {
+        
+        return Where(relationship.keyPath, isEqualTo: object)
+    }
+    
+    /**
+     Creates a `Where` clause from a `CoreStoreObject.Relationship` property.
+     ```
+     let dog = CoreStore.fetchOne(From<Dog>(), Dog.where { [john, joe, bob] ~= $0.master })
+     ```
+     */
+    @inline(__always)
+    public static func ~= <S: Sequence>(_ sequence: S, _ relationship: RelationshipContainer<O>.ToOne<D>) -> Where where S.Iterator.Element == D {
+        
+        return Where(relationship.keyPath, isMemberOf: sequence)
+    }
 }
--- a/Sources/CoreStoreSchema.swift
+++ b/Sources/CoreStoreSchema.swift
@@ -200,35 +200,39 @@ public final class CoreStoreSchema: DynamicSchema {
    
    public func rawModel() -> NSManagedObjectModel {
        
-        if let cachedRawModel = self.cachedRawModel {
+        return CoreStoreSchema.barrierQueue.sync(flags: .barrier) {
            
-            return cachedRawModel
-        }
-        let rawModel = NSManagedObjectModel()
-        var entityDescriptionsByEntity: [DynamicEntity: NSEntityDescription] = [:]
-        for entity in self.allEntities {
+            if let cachedRawModel = self.cachedRawModel {
+                
+                return cachedRawModel
+            }
+            let rawModel = NSManagedObjectModel()
+            var entityDescriptionsByEntity: [DynamicEntity: NSEntityDescription] = [:]
+            for entity in self.allEntities {
+                
+                let entityDescription = self.entityDescription(
+                    for: entity,
+                    initializer: CoreStoreSchema.firstPassCreateEntityDescription
+                )
+                entityDescriptionsByEntity[entity] = (entityDescription.copy() as! NSEntityDescription)
+            }
+            CoreStoreSchema.secondPassConnectRelationshipAttributes(for: entityDescriptionsByEntity)
+            CoreStoreSchema.thirdPassConnectInheritanceTree(for: entityDescriptionsByEntity)
+            CoreStoreSchema.fourthPassSynthesizeManagedObjectClasses(for: entityDescriptionsByEntity)
            
-            let entityDescription = self.entityDescription(
-                for: entity,
-                initializer: CoreStoreSchema.firstPassCreateEntityDescription
-            )
-            entityDescriptionsByEntity[entity] = (entityDescription.copy() as! NSEntityDescription)
+            rawModel.entities = entityDescriptionsByEntity.values.sorted(by: { $0.name! < $1.name! })
+            for (configuration, entities) in self.entitiesByConfiguration {
+                
+                rawModel.setEntities(
+                    entities
+                        .map({ entityDescriptionsByEntity[$0]! })
+                        .sorted(by: { $0.name! < $1.name! }),
+                    forConfigurationName: configuration
+                )
+            }
+            self.cachedRawModel = rawModel
+            return rawModel
        }
-        CoreStoreSchema.secondPassConnectRelationshipAttributes(for: entityDescriptionsByEntity)
-        CoreStoreSchema.thirdPassConnectInheritanceTree(for: entityDescriptionsByEntity)
-        
-        rawModel.entities = entityDescriptionsByEntity.values.sorted(by: { $0.name! < $1.name! })
-        for (configuration, entities) in self.entitiesByConfiguration {
-            
-            rawModel.setEntities(
-                entities
-                    .map({ entityDescriptionsByEntity[$0]! })
-                    .sorted(by: { $0.name! < $1.name! }),
-                forConfigurationName: configuration
-            )
-        }
-        self.cachedRawModel = rawModel
-        return rawModel
    }
    
    
@@ -264,8 +268,9 @@ public final class CoreStoreSchema: DynamicSchema {
        entityDescription.name = entity.entityName
        entityDescription.isAbstract = entity.isAbstract
        entityDescription.versionHashModifier = entity.versionHashModifier
-        entityDescription.managedObjectClassName = NSStringFromClass(NSManagedObject.self)
+        entityDescription.managedObjectClassName = "\(NSStringFromClass(CoreStoreManagedObject.self)).\(NSStringFromClass(entity.type)).\(entity.entityName)"
        
+        var keyPathsByAffectedKeyPaths: [KeyPath: Set<KeyPath>] = [:]
        func createProperties(for type: CoreStoreObject.Type) -> [NSPropertyDescription] {
            
            var propertyDescriptions: [NSPropertyDescription] = []
@@ -284,6 +289,7 @@ public final class CoreStoreSchema: DynamicSchema {
                    description.versionHashModifier = attribute.versionHashModifier
                    description.renamingIdentifier = attribute.renamingIdentifier
                    propertyDescriptions.append(description)
+                    keyPathsByAffectedKeyPaths[attribute.keyPath] = attribute.affectedByKeyPaths()
                    
                case let relationship as RelationshipProtocol:
                    let description = NSRelationshipDescription()
@@ -295,6 +301,7 @@ public final class CoreStoreSchema: DynamicSchema {
                    description.versionHashModifier = relationship.versionHashModifier
                    description.renamingIdentifier = relationship.renamingIdentifier
                    propertyDescriptions.append(description)
+                    keyPathsByAffectedKeyPaths[relationship.keyPath] = relationship.affectedByKeyPaths()
                    
                default:
                    continue
@@ -302,7 +309,7 @@ public final class CoreStoreSchema: DynamicSchema {
            }
            return propertyDescriptions
        }
-        
+        entityDescription.keyPathsByAffectedKeyPaths = keyPathsByAffectedKeyPaths
        entityDescription.properties = createProperties(for: entity.type as! CoreStoreObject.Type)
        return entityDescription
    }
@@ -425,4 +432,43 @@ public final class CoreStoreSchema: DynamicSchema {
            )
        }
    }
+    
+    private static func fourthPassSynthesizeManagedObjectClasses(for entityDescriptionsByEntity: [DynamicEntity: NSEntityDescription]) {
+        
+        func createManagedObjectSubclass(for entityDescription: NSEntityDescription) {
+            
+            let superEntity = entityDescription.superentity
+            let className = entityDescription.managedObjectClassName!
+            guard case nil = NSClassFromString(className) as! CoreStoreManagedObject.Type? else {
+                
+                return
+            }
+            if let superEntity = superEntity {
+                
+                createManagedObjectSubclass(for: superEntity)
+            }
+            let superClass = cs_lazy { () -> CoreStoreManagedObject.Type in
+                
+                if let superClassName = superEntity?.managedObjectClassName,
+                    let superClass = NSClassFromString(superClassName) {
+                    
+                    return superClass as! CoreStoreManagedObject.Type
+                }
+                return CoreStoreManagedObject.self
+            }
+            let managedObjectClass = className.withCString {
+                
+                return objc_allocateClassPair(superClass, $0, 0) as! CoreStoreManagedObject.Type
+            }
+            objc_registerClassPair(managedObjectClass)
+            managedObjectClass.cs_setKeyPathsForValuesAffectingKeys(
+                entityDescription.keyPathsByAffectedKeyPaths,
+                for: managedObjectClass
+            )
+        }
+        for (_, entityDescription) in entityDescriptionsByEntity {
+            
+            createManagedObjectSubclass(for: entityDescription)
+        }
+    }
 }
--- a/Sources/CustomSchemaMappingProvider.swift
+++ b/Sources/CustomSchemaMappingProvider.swift
@@ -32,7 +32,7 @@ import Foundation
 /**
 A `SchemaMappingProvider` that accepts custom mappings for some entities. Mappings of entities with no `CustomMapping` provided will be automatically calculated if possible.
 */
-open class CustomSchemaMappingProvider: Hashable, SchemaMappingProvider {
+public class CustomSchemaMappingProvider: Hashable, SchemaMappingProvider {
    
    /**
     The source model version for the mapping.
@@ -352,7 +352,7 @@ open class CustomSchemaMappingProvider: Hashable, SchemaMappingProvider {
        )
        func expression(forSource sourceEntity: NSEntityDescription) -> NSExpression {
            
-            return NSExpression(format: "FETCH(FUNCTION($\(NSMigrationManagerKey), \"fetchRequestForSourceEntityNamed:predicateString:\" , \"\(sourceEntity.name!)\", \"\(NSPredicate(value: true))\"), $\(NSMigrationManagerKey).\(#keyPath(NSMigrationManager.sourceContext)), \(false))")
+            return NSExpression(format: "FETCH(FUNCTION($\(NSMigrationManagerKey), \"fetchRequestForSourceEntityNamed:predicateString:\" , \"\(sourceEntity.name!)\", \"\(NSPredicate(value: true))\"), FUNCTION($\(NSMigrationManagerKey), \"\(#selector(getter: NSMigrationManager.sourceContext))\"), \(false))")
        }
        
        let sourceEntitiesByName = sourceModel.entitiesByName
@@ -427,22 +427,25 @@ open class CustomSchemaMappingProvider: Hashable, SchemaMappingProvider {
                    let destinationAttribute = destination.attribute
                    let propertyMapping = NSPropertyMapping()
                    propertyMapping.name = destinationAttribute.name
-                    propertyMapping.valueExpression = NSExpression(format: "$\(NSMigrationSourceObjectKey).\(sourceAttribute.name)")
+                    propertyMapping.valueExpression = NSExpression(format: "FUNCTION($\(NSMigrationSourceObjectKey), \"\(#selector(NSManagedObject.value(forKey:)))\", \"\(sourceAttribute.name)\")")
                    attributeMappings.append(propertyMapping)
                }
                return attributeMappings
            }
-            let entityMappingName = entityMapping.name!
            entityMapping.relationshipMappings = autoreleasepool { () -> [NSPropertyMapping] in
                
+                let sourceRelationships = sourceEntity.cs_resolvedRelationshipRenamingIdentities()
                let destinationRelationships = destinationEntity.cs_resolvedRelationshipRenamingIdentities()
                var relationshipMappings: [NSPropertyMapping] = []
-                for (_, destination) in destinationRelationships {
+                for (renamingIdentifier, destination) in destinationRelationships {
                    
+                    let sourceRelationship = sourceRelationships[renamingIdentifier]!.relationship
                    let destinationRelationship = destination.relationship
+                    let sourceRelationshipName = sourceRelationship.name
+
                    let propertyMapping = NSPropertyMapping()
                    propertyMapping.name = destinationRelationship.name
-                    propertyMapping.valueExpression = NSExpression(format: "FUNCTION($\(NSMigrationManagerKey), \"\(#selector(NSMigrationManager.destinationInstances(forEntityMappingName:sourceInstances:)))\" , \"\(entityMappingName)\", $\(NSMigrationSourceObjectKey))[0]")
+                    propertyMapping.valueExpression = NSExpression(format: "FUNCTION($\(NSMigrationManagerKey), \"destinationInstancesForSourceRelationshipNamed:sourceInstances:\", \"\(sourceRelationshipName)\", FUNCTION($\(NSMigrationSourceObjectKey), \"\(#selector(NSManagedObject.value(forKey:)))\", \"\(sourceRelationshipName)\"))")
                    relationshipMappings.append(propertyMapping)
                }
                return relationshipMappings
@@ -483,17 +486,24 @@ open class CustomSchemaMappingProvider: Hashable, SchemaMappingProvider {
                }
                userInfo[CustomEntityMigrationPolicy.UserInfoKey.sourceAttributesByDestinationKey] = sourceAttributesByDestinationKey
            }
-            let entityMappingName = entityMapping.name!
            entityMapping.relationshipMappings = autoreleasepool { () -> [NSPropertyMapping] in
                
+                let sourceRelationships = sourceEntity.cs_resolvedRelationshipRenamingIdentities()
                let destinationRelationships = destinationEntity.cs_resolvedRelationshipRenamingIdentities()
+                let transformedRenamingIdentifiers = Set(destinationRelationships.keys)
+                    .intersection(sourceRelationships.keys)
+
                var relationshipMappings: [NSPropertyMapping] = []
-                for (_, destination) in destinationRelationships {
-                    
-                    let destinationRelationship = destination.relationship
+                for renamingIdentifier in transformedRenamingIdentifiers {
+
+                    let sourceRelationship = sourceRelationships[renamingIdentifier]!.relationship
+                    let destinationRelationship = destinationRelationships[renamingIdentifier]!.relationship
+                    let sourceRelationshipName = sourceRelationship.name
+                    let destinationRelationshipName = destinationRelationship.name
+
                    let propertyMapping = NSPropertyMapping()
-                    propertyMapping.name = destinationRelationship.name
-                    propertyMapping.valueExpression = NSExpression(format: "FUNCTION($\(NSMigrationManagerKey), \"\(#selector(NSMigrationManager.destinationInstances(forEntityMappingName:sourceInstances:)))\" , \"\(entityMappingName)\", $\(NSMigrationSourceObjectKey))[0]")
+                    propertyMapping.name = destinationRelationshipName
+                    propertyMapping.valueExpression = NSExpression(format: "FUNCTION($\(NSMigrationManagerKey), \"destinationInstancesForSourceRelationshipNamed:sourceInstances:\", \"\(sourceRelationshipName)\", FUNCTION($\(NSMigrationSourceObjectKey), \"\(#selector(NSManagedObject.value(forKey:)))\", \"\(sourceRelationshipName)\"))")
                    relationshipMappings.append(propertyMapping)
                }
                return relationshipMappings
@@ -545,11 +555,7 @@ open class CustomSchemaMappingProvider: Hashable, SchemaMappingProvider {
            )
            if let dInstance = destinationObject?.rawObject {
                
-                manager.associate(
-                    sourceInstance: sInstance,
-                    withDestinationInstance: dInstance,
-                    for: mapping
-                )
+                manager.associate(sourceInstance: sInstance, withDestinationInstance: dInstance, for: mapping)
            }
        }
        
@@ -670,77 +676,76 @@ open class CustomSchemaMappingProvider: Hashable, SchemaMappingProvider {
                allMappedSourceKeys[sourceEntity] = destinationEntity
                allMappedDestinationKeys[destinationEntity] = sourceEntity
            }
+        }
+        for renamingIdentifier in transformedRenamingIdentifiers {
            
-            for renamingIdentifier in transformedRenamingIdentifiers {
+            let sourceEntity = sourceRenamingIdentifiers[renamingIdentifier]!.entity
+            let destinationEntity = destinationRenamingIdentifiers[renamingIdentifier]!.entity
+            let sourceEntityName = sourceEntity.name!
+            let destinationEntityName = destinationEntity.name!
+            switch (allMappedSourceKeys[sourceEntityName], allMappedDestinationKeys[destinationEntityName]) {
                
-                let sourceEntity = sourceRenamingIdentifiers[renamingIdentifier]!.entity
-                let destinationEntity = destinationRenamingIdentifiers[renamingIdentifier]!.entity
-                let sourceEntityName = sourceEntity.name!
-                let destinationEntityName = destinationEntity.name!
-                switch (allMappedSourceKeys[sourceEntityName], allMappedDestinationKeys[destinationEntityName]) {
+            case (nil, nil):
+                if sourceEntity.versionHash == destinationEntity.versionHash {
                    
-                case (nil, nil):
-                    if sourceEntity.versionHash == destinationEntity.versionHash {
-                        
-                        copyMappings.insert(
-                            .copyEntity(
-                                sourceEntity: sourceEntityName,
-                                destinationEntity: destinationEntityName
-                            )
+                    copyMappings.insert(
+                        .copyEntity(
+                            sourceEntity: sourceEntityName,
+                            destinationEntity: destinationEntityName
                        )
-                    }
-                    else {
-                        
-                        transformMappings.insert(
-                            .transformEntity(
-                                sourceEntity: sourceEntityName,
-                                destinationEntity: destinationEntityName,
-                                transformer: CustomMapping.inferredTransformation
-                            )
+                    )
+                }
+                else {
+                    
+                    transformMappings.insert(
+                        .transformEntity(
+                            sourceEntity: sourceEntityName,
+                            destinationEntity: destinationEntityName,
+                            transformer: CustomMapping.inferredTransformation
                        )
-                    }
-                    allMappedSourceKeys[sourceEntityName] = destinationEntityName
-                    allMappedDestinationKeys[destinationEntityName] = sourceEntityName
-                    
-                case (""?, nil):
-                    insertMappings.insert(.insertEntity(destinationEntity: destinationEntityName))
-                    allMappedDestinationKeys[destinationEntityName] = ""
-                    
-                case (nil, ""?):
-                    deleteMappings.insert(.deleteEntity(sourceEntity: sourceEntityName))
-                    allMappedSourceKeys[sourceEntityName] = ""
-                    
-                default:
-                    continue
+                    )
                }
-            }
-            for renamingIdentifier in removedRenamingIdentifiers {
+                allMappedSourceKeys[sourceEntityName] = destinationEntityName
+                allMappedDestinationKeys[destinationEntityName] = sourceEntityName
                
-                let sourceEntity = sourceRenamingIdentifiers[renamingIdentifier]!.entity
-                let sourceEntityName = sourceEntity.name!
-                switch allMappedSourceKeys[sourceEntityName] {
-                    
-                case nil:
-                    deleteMappings.insert(.deleteEntity(sourceEntity: sourceEntityName))
-                    allMappedSourceKeys[sourceEntityName] = ""
-                    
-                default:
-                    continue
-                }
-            }
-            for renamingIdentifier in addedRenamingIdentifiers {
+            case (""?, nil):
+                insertMappings.insert(.insertEntity(destinationEntity: destinationEntityName))
+                allMappedDestinationKeys[destinationEntityName] = ""
                
-                let destinationEntity = destinationRenamingIdentifiers[renamingIdentifier]!.entity
-                let destinationEntityName = destinationEntity.name!
-                switch allMappedDestinationKeys[destinationEntityName] {
-                    
-                case nil:
-                    insertMappings.insert(.insertEntity(destinationEntity: destinationEntityName))
-                    allMappedDestinationKeys[destinationEntityName] = ""
-                    
-                default:
-                    continue
-                }
+            case (nil, ""?):
+                deleteMappings.insert(.deleteEntity(sourceEntity: sourceEntityName))
+                allMappedSourceKeys[sourceEntityName] = ""
+                
+            default:
+                continue
+            }
+        }
+        for renamingIdentifier in removedRenamingIdentifiers {
+            
+            let sourceEntity = sourceRenamingIdentifiers[renamingIdentifier]!.entity
+            let sourceEntityName = sourceEntity.name!
+            switch allMappedSourceKeys[sourceEntityName] {
+                
+            case nil:
+                deleteMappings.insert(.deleteEntity(sourceEntity: sourceEntityName))
+                allMappedSourceKeys[sourceEntityName] = ""
+                
+            default:
+                continue
+            }
+        }
+        for renamingIdentifier in addedRenamingIdentifiers {
+            
+            let destinationEntity = destinationRenamingIdentifiers[renamingIdentifier]!.entity
+            let destinationEntityName = destinationEntity.name!
+            switch allMappedDestinationKeys[destinationEntityName] {
+                
+            case nil:
+                insertMappings.insert(.insertEntity(destinationEntity: destinationEntityName))
+                allMappedDestinationKeys[destinationEntityName] = ""
+                
+            default:
+                continue
            }
        }
        return (deleteMappings, insertMappings, copyMappings, transformMappings)
--- a/Sources/DynamicSchema+Convenience.swift
+++ b/Sources/DynamicSchema+Convenience.swift
@@ -32,7 +32,7 @@ import Foundation
 public extension DynamicSchema {
    
    /**
-     Prints the `DynamicSchema` as their corresponding `CoreStoreObject` Swift declarations. This is useful for converting current `XcodeDataModelSchema`-based models into the new `CoreStoreSchema` framework. Additional adjustments may need to be done to the generated source code for "Transformable" attributes.
+     Prints the `DynamicSchema` as their corresponding `CoreStoreObject` Swift declarations. This is useful for converting current `XcodeDataModelSchema`-based models into the new `CoreStoreSchema` framework. Additional adjustments may need to be done to the generated source code; for example: `Transformable` concrete types need to be provided, as well as `default` values.
     
     - Important: After transitioning to the new `CoreStoreSchema` framework, it is recommended to add the new schema as a new version that the existing versions' `XcodeDataModelSchema` can migrate to. It is discouraged to load existing SQLite files created with `XcodeDataModelSchema` directly into a `CoreStoreSchema`.
     - returns: a string that represents the source code for the `DynamicSchema` as their corresponding `CoreStoreObject` Swift declarations.
@@ -153,8 +153,7 @@ public extension DynamicSchema {
                        }
                    case .dateAttributeType:
                        valueType = Date.self
-                        if let defaultValue = (attribute.defaultValue as! Date.ImportableNativeType?).flatMap(Date.cs_fromImportableNativeType),
-                            defaultValue != Date.cs_emptyValue() {
+                        if let defaultValue = (attribute.defaultValue as! Date.ImportableNativeType?).flatMap(Date.cs_fromImportableNativeType) {
                            
                            defaultString = ", default: Date(timeIntervalSinceReferenceDate: \(defaultValue.timeIntervalSinceReferenceDate))"
                        }
@@ -194,9 +193,11 @@ public extension DynamicSchema {
                    let indexedString = attribute.isIndexed ? ", isIndexed: true" : ""
                    let transientString = attribute.isTransient ? ", isTransient: true" : ""
                    // TODO: escape strings
-                    let versionHashModifierString = attribute.versionHashModifier.flatMap({ ", versionHashModifier: \"\($0)\"" }) ?? ""
+                    let versionHashModifierString = attribute.versionHashModifier
+                        .flatMap({ ", versionHashModifier: \"\($0)\"" }) ?? ""
                    // TODO: escape strings
-                    let renamingIdentifierString = attribute.renamingIdentifier.flatMap({ ", renamingIdentifier: \"\($0)\"" }) ?? ""
+                    let renamingIdentifierString = attribute.renamingIdentifier
+                        .flatMap({ ($0 == attributeName ? "" : ", renamingIdentifier: \"\($0)\"") as String }) ?? ""
                    output.append("    let \(attributeName) = \(containerType)<\(String(describing: valueType))>(\"\(attributeName)\"\(indexedString)\(defaultString)\(transientString)\(versionHashModifierString)\(renamingIdentifierString))\n")
                }
            }
@@ -261,8 +262,10 @@ public extension DynamicSchema {
                            fatalError("Unsupported delete rule \((relationship.deleteRule)) for relationship \"\(relationshipQualifier)\"")
                        }
                    }
-                    let versionHashModifierString = relationship.versionHashModifier.flatMap({ ", versionHashModifier: \"\($0)\"" }) ?? ""
-                    let renamingIdentifierString = relationship.renamingIdentifier.flatMap({ ", renamingIdentifier: \"\($0)\"" }) ?? ""
+                    let versionHashModifierString = relationship.versionHashModifier
+                        .flatMap({ ", versionHashModifier: \"\($0)\"" }) ?? ""
+                    let renamingIdentifierString = relationship.renamingIdentifier
+                        .flatMap({ ($0 == relationshipName ? "" : ", renamingIdentifier: \"\($0)\"") as String }) ?? ""
                    output.append("    let \(relationshipName) = \(containerType)<\(relationship.destinationEntity!.name!)>(\"\(relationshipName)\"\(inverseString)\(deleteRuleString)\(minCountString)\(maxCountString)\(versionHashModifierString)\(renamingIdentifierString))\n")
                }
            }
--- a/Sources/ImportableAttributeType.swift
+++ b/Sources/ImportableAttributeType.swift
@@ -64,12 +64,6 @@ public protocol ImportableAttributeType: QueryableAttributeType {
     */
    associatedtype ImportableNativeType: QueryableNativeType
    
-    /**
-     Returns the default "empty" value for this type.
-     */
-    @inline(__always)
-    static func cs_emptyValue() -> Self
-    
    /**
     Creates an instance of this type from its `ImportableNativeType` value.
     */
@@ -84,18 +78,31 @@ public protocol ImportableAttributeType: QueryableAttributeType {
 }


+// MARK: - EmptyableAttributeType
+
+/**
+ `ImportableAttributeType`s that have a natural "empty" value. Example: `0` for `Int`, `""` for `String`.
+ 
+ - Discussion: Not all `ImportableAttributeType`s can have empty values. `URL`s and `Date`s for example have no obvious empty values.
+ */
+public protocol EmptyableAttributeType: ImportableAttributeType {
+    
+    /**
+     Returns the default "empty" value for this type.
+     */
+    @inline(__always)
+    static func cs_emptyValue() -> Self
+}
+
+
 // MARK: - Bool

-extension Bool: ImportableAttributeType {
+extension Bool: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Bool {
-        
-        return false
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Bool? {
        
@@ -107,21 +114,26 @@ extension Bool: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Bool {
+        
+        return false
+    }
 }


 // MARK: - CGFloat

-extension CGFloat: ImportableAttributeType {
+extension CGFloat: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> CGFloat {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> CGFloat? {
        
@@ -133,21 +145,26 @@ extension CGFloat: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> CGFloat {
+        
+        return 0
+    }
 }


 // MARK: - Data

-extension Data: ImportableAttributeType {
+extension Data: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSData
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Data {
-        
-        return Data()
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Data? {
        
@@ -159,6 +176,15 @@ extension Data: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Data {
+        
+        return Data()
+    }
 }


@@ -166,13 +192,9 @@ extension Data: ImportableAttributeType {

 extension Date: ImportableAttributeType {
    
-    public typealias ImportableNativeType = NSDate
+    // MARK: ImportableAttributeType
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Date {
-        
-        return Date(timeIntervalSinceReferenceDate: 0)
-    }
+    public typealias ImportableNativeType = NSDate
    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Date? {
@@ -190,16 +212,12 @@ extension Date: ImportableAttributeType {

 // MARK: - Double

-extension Double: ImportableAttributeType {
+extension Double: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Double {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Double? {
        
@@ -211,21 +229,26 @@ extension Double: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Double {
+        
+        return 0
+    }
 }


 // MARK: - Float

-extension Float: ImportableAttributeType {
+extension Float: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Float {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Float? {
        
@@ -237,21 +260,26 @@ extension Float: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Float {
+        
+        return 0
+    }
 }


 // MARK: - Int

-extension Int: ImportableAttributeType {
+extension Int: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Int {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Int? {
        
@@ -263,21 +291,26 @@ extension Int: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Int {
+        
+        return 0
+    }
 }


 // MARK: - Int8

-extension Int8: ImportableAttributeType {
+extension Int8: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Int8 {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Int8? {
        
@@ -289,21 +322,26 @@ extension Int8: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Int8 {
+        
+        return 0
+    }
 }


 // MARK: - Int16

-extension Int16: ImportableAttributeType {
+extension Int16: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Int16 {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Int16? {
        
@@ -315,21 +353,26 @@ extension Int16: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Int16 {
+        
+        return 0
+    }
 }


 // MARK: - Int32

-extension Int32: ImportableAttributeType {
+extension Int32: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Int32 {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Int32? {
        
@@ -341,21 +384,26 @@ extension Int32: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Int32 {
+        
+        return 0
+    }
 }


 // MARK: - Int64

-extension Int64: ImportableAttributeType {
+extension Int64: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @inline(__always)
-    public static func cs_emptyValue() -> Int64 {
-        
-        return 0
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Int64? {
        
@@ -367,21 +415,26 @@ extension Int64: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> Int64 {
+        
+        return 0
+    }
 }


 // MARK: - NSData

-extension NSData: ImportableAttributeType {
+extension NSData: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSData
    
-    @nonobjc @inline(__always)
-    public class func cs_emptyValue() -> Self {
-        
-        return self.init()
-    }
-    
    @nonobjc @inline(__always)
    public class func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Self? {
        
@@ -393,6 +446,15 @@ extension NSData: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @nonobjc @inline(__always)
+    public class func cs_emptyValue() -> Self {
+        
+        return self.init()
+    }
 }


@@ -400,13 +462,9 @@ extension NSData: ImportableAttributeType {

 extension NSDate: ImportableAttributeType {
    
-    public typealias ImportableNativeType = NSDate
+    // MARK: ImportableAttributeType
    
-    @nonobjc @inline(__always)
-    public class func cs_emptyValue() -> Self {
-        
-        return self.init(timeIntervalSinceReferenceDate: 0)
-    }
+    public typealias ImportableNativeType = NSDate
    
    @nonobjc @inline(__always)
    public class func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Self? {
@@ -424,16 +482,12 @@ extension NSDate: ImportableAttributeType {

 // MARK: - NSNumber

-extension NSNumber: ImportableAttributeType {
+extension NSNumber: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSNumber
    
-    @nonobjc @inline(__always)
-    public class func cs_emptyValue() -> Self {
-        
-        return self.init()
-    }
-    
    @nonobjc @inline(__always)
    public class func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Self? {
        
@@ -445,21 +499,26 @@ extension NSNumber: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @nonobjc @inline(__always)
+    public class func cs_emptyValue() -> Self {
+        
+        return self.init()
+    }
 }


 // MARK: - NSString

-extension NSString: ImportableAttributeType {
+extension NSString: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSString
    
-    @nonobjc @inline(__always)
-    public class func cs_emptyValue() -> Self {
-        
-        return self.init()
-    }
-    
    @nonobjc @inline(__always)
    public class func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Self? {
        
@@ -471,6 +530,15 @@ extension NSString: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @nonobjc @inline(__always)
+    public class func cs_emptyValue() -> Self {
+        
+        return self.init()
+    }
 }


@@ -478,13 +546,9 @@ extension NSString: ImportableAttributeType {

 extension NSURL: ImportableAttributeType {
    
-    public typealias ImportableNativeType = NSString
+    // MARK: ImportableAttributeType
    
-    @nonobjc @inline(__always)
-    public class func cs_emptyValue() -> Self {
-        
-        return self.init(string: "")!
-    }
+    public typealias ImportableNativeType = NSString
    
    @nonobjc @inline(__always)
    public class func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Self? {
@@ -504,16 +568,9 @@ extension NSURL: ImportableAttributeType {

 extension NSUUID: ImportableAttributeType {
    
-    public typealias ImportableNativeType = NSString
+    // MARK: ImportableAttributeType
    
-    public class func cs_emptyValue() -> Self {
-        
-        enum Static {
-            
-            static var zero = Array<UInt8>(repeating: 0, count: 16)
-        }
-        return self.init(uuidBytes: &Static.zero)
-    }
+    public typealias ImportableNativeType = NSString
    
    @nonobjc @inline(__always)
    public class func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Self? {
@@ -531,16 +588,12 @@ extension NSUUID: ImportableAttributeType {

 // MARK: - String

-extension String: ImportableAttributeType {
+extension String: ImportableAttributeType, EmptyableAttributeType {
+    
+    // MARK: ImportableAttributeType
    
    public typealias ImportableNativeType = NSString
    
-    @inline(__always)
-    public static func cs_emptyValue() -> String {
-        
-        return ""
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> String? {
        
@@ -552,6 +605,15 @@ extension String: ImportableAttributeType {
        
        return self.cs_toQueryableNativeType()
    }
+    
+    
+    // MARK: EmptyableAttributeType
+    
+    @inline(__always)
+    public static func cs_emptyValue() -> String {
+        
+        return ""
+    }
 }


@@ -559,16 +621,9 @@ extension String: ImportableAttributeType {

 extension URL: ImportableAttributeType {
    
-    public typealias ImportableNativeType = NSString
+    // MARK: ImportableAttributeType
    
-    public static func cs_emptyValue() -> URL {
-        
-        enum Static {
-            
-            static let empty = URL(string: "")!
-        }
-        return Static.empty
-    }
+    public typealias ImportableNativeType = NSString
    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> URL? {
@@ -588,20 +643,9 @@ extension URL: ImportableAttributeType {

 extension UUID: ImportableAttributeType {
    
-    public typealias ImportableNativeType = NSString
+    // MARK: ImportableAttributeType
    
-    public static func cs_emptyValue() -> UUID {
-        
-        enum Static {
-            
-            static let empty: UUID = cs_lazy {
-                
-                var zero = Array<UInt8>(repeating: 0, count: 16)
-                return NSUUID(uuidBytes: &zero) as UUID
-            }
-        }
-        return Static.empty
-    }
+    public typealias ImportableNativeType = NSString
    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> UUID? {
@@ -623,11 +667,6 @@ extension RawRepresentable where RawValue: ImportableAttributeType {
    
    public typealias ImportableNativeType = RawValue.ImportableNativeType
    
-    public static func cs_emptyValue() -> Self {
-        
-        return self.init(rawValue: RawValue.cs_emptyValue())!
-    }
-    
    @inline(__always)
    public static func cs_fromImportableNativeType(_ value: ImportableNativeType) -> Self? {
        
--- a/Sources/InferredSchemaMappingProvider.swift
+++ b/Sources/InferredSchemaMappingProvider.swift
@@ -32,7 +32,7 @@ import Foundation
 /**
 A `SchemaMappingProvider` that tries to infer model migration between two `DynamicSchema` versions by searching all `xcmappingmodel`s from `Bundle.allBundles` or by relying on lightweight migration if possible. Throws an error if lightweight migration is impossible for the two `DynamicSchema`. This mapping is automatically used as a fallback mapping provider, even if no mapping providers are explicitly declared in the `StorageInterface`.
 */
-final class InferredSchemaMappingProvider: Hashable, SchemaMappingProvider {
+public final class InferredSchemaMappingProvider: Hashable, SchemaMappingProvider {
    
    // MARK: Equatable
    
--- a/Sources/Info.plist
+++ b/Sources/Info.plist
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>4.0.0</string>
+	<string>4.0.3</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
--- a/Sources/NSEntityDescription+DynamicModel.swift
+++ b/Sources/NSEntityDescription+DynamicModel.swift
@@ -54,17 +54,43 @@ internal extension NSEntityDescription {
            
            if let newValue = newValue {
                
-                var userInfo: [AnyHashable : Any] = [
-                    UserInfoKey.CoreStoreManagedObjectTypeName: NSStringFromClass(newValue.type),
-                    UserInfoKey.CoreStoreManagedObjectEntityName: newValue.entityName,
-                    UserInfoKey.CoreStoreManagedObjectIsAbstract: newValue.isAbstract
-                ]
-                userInfo[UserInfoKey.CoreStoreManagedObjectVersionHashModifier] = newValue.versionHashModifier
-                self.userInfo = userInfo
+                cs_setUserInfo { (userInfo) in
+                    
+                    userInfo[UserInfoKey.CoreStoreManagedObjectTypeName] = NSStringFromClass(newValue.type)
+                    userInfo[UserInfoKey.CoreStoreManagedObjectEntityName] = newValue.entityName
+                    userInfo[UserInfoKey.CoreStoreManagedObjectIsAbstract] = newValue.isAbstract
+                    userInfo[UserInfoKey.CoreStoreManagedObjectVersionHashModifier] = newValue.versionHashModifier
+                }
            }
            else {
                
-                self.userInfo = [:]
+                cs_setUserInfo { (userInfo) in
+                    
+                    userInfo[UserInfoKey.CoreStoreManagedObjectTypeName] = nil
+                    userInfo[UserInfoKey.CoreStoreManagedObjectEntityName] = nil
+                    userInfo[UserInfoKey.CoreStoreManagedObjectIsAbstract] = nil
+                    userInfo[UserInfoKey.CoreStoreManagedObjectVersionHashModifier] = nil
+                }
+            }
+        }
+    }
+    
+    internal var keyPathsByAffectedKeyPaths: [KeyPath: Set<KeyPath>] {
+        
+        get {
+            
+            if let userInfo = self.userInfo,
+                let function = userInfo[UserInfoKey.CoreStoreManagedObjectKeyPathsByAffectedKeyPaths] as! [KeyPath: Set<KeyPath>]? {
+                
+                return function
+            }
+            return [:]
+        }
+        set {
+            
+            cs_setUserInfo { (userInfo) in
+                
+                userInfo[UserInfoKey.CoreStoreManagedObjectKeyPathsByAffectedKeyPaths] = newValue
            }
        }
    }
@@ -74,11 +100,20 @@ internal extension NSEntityDescription {
    
    // MARK: - UserInfoKey
    
-    fileprivate enum UserInfoKey {
+    private enum UserInfoKey {
        
        fileprivate static let CoreStoreManagedObjectTypeName = "CoreStoreManagedObjectTypeName"
        fileprivate static let CoreStoreManagedObjectEntityName = "CoreStoreManagedObjectEntityName"
        fileprivate static let CoreStoreManagedObjectIsAbstract = "CoreStoreManagedObjectIsAbstract"
        fileprivate static let CoreStoreManagedObjectVersionHashModifier = "CoreStoreManagedObjectVersionHashModifier"
+        
+        fileprivate static let CoreStoreManagedObjectKeyPathsByAffectedKeyPaths = "CoreStoreManagedObjectKeyPathsByAffectedKeyPaths"
+    }
+    
+    private func cs_setUserInfo(_ closure: (_ userInfo: inout [AnyHashable: Any]) -> Void) {
+        
+        var userInfo = self.userInfo ?? [:]
+        closure(&userInfo)
+        self.userInfo = userInfo
    }
 }
--- a/Sources/NSFetchedResultsController+Convenience.swift
+++ b/Sources/NSFetchedResultsController+Convenience.swift
@@ -201,7 +201,7 @@ public extension UnsafeDataTransaction {
 // MARK: - Private

@available(OSX 10.12, *)
-fileprivate func createFRC<T: NSManagedObject>(fromContext context: NSManagedObjectContext, from: From<T>? = nil, sectionBy: SectionBy? = nil, fetchClauses: [FetchClause]) -> NSFetchedResultsController<T> {
+fileprivate func createFRC<T: NSManagedObject>(fromContext context: NSManagedObjectContext, from: From<T>, sectionBy: SectionBy? = nil, fetchClauses: [FetchClause]) -> NSFetchedResultsController<T> {
    
    let controller = CoreStoreFetchedResultsController(
        context: context,
--- a/Sources/NSFetchedResultsController+ObjectiveC.swift
+++ b/Sources/NSFetchedResultsController+ObjectiveC.swift
@@ -68,12 +68,12 @@ public extension CSUnsafeDataTransaction {
 // MARK: - Private

@available(OSX 10.12, *)
-fileprivate func createFRC(fromContext context: NSManagedObjectContext, from: CSFrom? = nil, sectionBy: CSSectionBy?, fetchClauses: [CSFetchClause]) -> NSFetchedResultsController<NSManagedObject> {
+fileprivate func createFRC(fromContext context: NSManagedObjectContext, from: CSFrom, sectionBy: CSSectionBy?, fetchClauses: [CSFetchClause]) -> NSFetchedResultsController<NSManagedObject> {
    
    let controller = CoreStoreFetchedResultsController(
        context: context,
        fetchRequest: CoreStoreFetchRequest().dynamicCast(),
-        from: from?.bridgeToSwift,
+        from: from.bridgeToSwift,
        sectionBy: sectionBy?.bridgeToSwift,
        applyFetchClauses: { (fetchRequest) in
            
--- a/Sources/ObjectMonitor.swift
+++ b/Sources/ObjectMonitor.swift
@@ -272,7 +272,7 @@ public final class ObjectMonitor<D: DynamicObject>: Equatable {
        let fetchedResultsController = CoreStoreFetchedResultsController(
            context: context,
            fetchRequest: fetchRequest.dynamicCast(),
-            from: nil as From<ObjectType>?,
+            from: From<ObjectType>([objectID.persistentStore?.configurationName]),
            applyFetchClauses: Where("SELF", isEqualTo: objectID).applyToFetchRequest
        )
        
--- a/Sources/Relationship.swift
+++ b/Sources/Relationship.swift
@@ -92,10 +92,23 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { nil }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { nil },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -113,10 +126,24 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, inverse: @escaping (D) -> RelationshipContainer<D>.ToOne<O>, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToOne<O>,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -134,10 +161,24 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, inverse: @escaping (D) -> RelationshipContainer<D>.ToManyOrdered<O>, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToManyOrdered<O>,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -155,10 +196,24 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, inverse: @escaping (D) -> RelationshipContainer<D>.ToManyUnordered<O>, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToManyUnordered<O>,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -189,6 +244,7 @@ public enum RelationshipContainer<O: CoreStoreObject> {
        internal let inverse: (type: CoreStoreObject.Type, keyPath: () -> KeyPath?)
        internal let versionHashModifier: String?
        internal let renamingIdentifier: String?
+        internal let affectedByKeyPaths: () -> Set<String>
        
        internal var parentObject: () -> CoreStoreObject = {
            
@@ -230,13 +286,14 @@ public enum RelationshipContainer<O: CoreStoreObject> {
        
        // MARK: Private
        
-        private init(keyPath: KeyPath, inverseKeyPath: @escaping () -> KeyPath?, deleteRule: DeleteRule, versionHashModifier: String?, renamingIdentifier: String?) {
+        private init(keyPath: KeyPath, inverseKeyPath: @escaping () -> KeyPath?, deleteRule: DeleteRule, versionHashModifier: String?, renamingIdentifier: String?, affectedByKeyPaths: @autoclosure @escaping () -> Set<String>) {
            
            self.keyPath = keyPath
            self.deleteRule = deleteRule.nativeValue
            self.inverse = (D.self, inverseKeyPath)
            self.versionHashModifier = versionHashModifier
            self.renamingIdentifier = renamingIdentifier
+            self.affectedByKeyPaths = affectedByKeyPaths
        }
    }
    
@@ -273,10 +330,27 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, minCount: Int = 0, maxCount: Int = 0, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, minCount: minCount, maxCount: maxCount, inverseKeyPath: { nil }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                minCount: minCount,
+                maxCount: maxCount,
+                inverseKeyPath: { nil },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -296,10 +370,28 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, minCount: Int = 0, maxCount: Int = 0, inverse: @escaping (D) -> RelationshipContainer<D>.ToOne<O>, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToOne<O>,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, minCount: minCount, maxCount: maxCount, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                minCount: minCount,
+                maxCount: maxCount,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -319,10 +411,28 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, minCount: Int = 0, maxCount: Int = 0, inverse: @escaping (D) -> RelationshipContainer<D>.ToManyOrdered<O>, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToManyOrdered<O>,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, minCount: minCount, maxCount: maxCount, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                minCount: minCount,
+                maxCount: maxCount,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -342,10 +452,28 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, minCount: Int = 0, maxCount: Int = 0, inverse: @escaping (D) -> RelationshipContainer<D>.ToManyUnordered<O>, deleteRule: DeleteRule = .nullify, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToManyUnordered<O>,
+            deleteRule: DeleteRule = .nullify,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, minCount: minCount, maxCount: maxCount, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                minCount: minCount,
+                maxCount: maxCount,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -377,6 +505,7 @@ public enum RelationshipContainer<O: CoreStoreObject> {
        internal let inverse: (type: CoreStoreObject.Type, keyPath: () -> KeyPath?)
        internal let versionHashModifier: String?
        internal let renamingIdentifier: String?
+        internal let affectedByKeyPaths: () -> Set<String>
        
        internal var parentObject: () -> CoreStoreObject = {
            
@@ -418,7 +547,7 @@ public enum RelationshipContainer<O: CoreStoreObject> {
        
        // MARK: Private
        
-        private init(keyPath: String, minCount: Int, maxCount: Int, inverseKeyPath: @escaping () -> String?, deleteRule: DeleteRule, versionHashModifier: String?, renamingIdentifier: String?) {
+        private init(keyPath: String, minCount: Int, maxCount: Int, inverseKeyPath: @escaping () -> String?, deleteRule: DeleteRule, versionHashModifier: String?, renamingIdentifier: String?, affectedByKeyPaths: @autoclosure @escaping () -> Set<String>) {
            
            self.keyPath = keyPath
            self.deleteRule = deleteRule.nativeValue
@@ -429,6 +558,7 @@ public enum RelationshipContainer<O: CoreStoreObject> {
            let range = (Swift.max(0, minCount) ... maxCount)
            self.minCount = range.lowerBound
            self.maxCount = range.upperBound
+            self.affectedByKeyPaths = affectedByKeyPaths
        }
    }
    
@@ -466,10 +596,27 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, deleteRule: DeleteRule = .nullify, minCount: Int = 0, maxCount: Int = 0, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            deleteRule: DeleteRule = .nullify,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { nil }, deleteRule: deleteRule, minCount: minCount, maxCount: maxCount, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { nil },
+                deleteRule: deleteRule,
+                minCount: minCount,
+                maxCount: maxCount,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -489,10 +636,28 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, inverse: @escaping (D) -> RelationshipContainer<D>.ToOne<O>, deleteRule: DeleteRule = .nullify, minCount: Int = 0, maxCount: Int = 0, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToOne<O>,
+            deleteRule: DeleteRule = .nullify,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, minCount: minCount, maxCount: maxCount, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                minCount: minCount,
+                maxCount: maxCount,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -512,10 +677,28 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, inverse: @escaping (D) -> RelationshipContainer<D>.ToManyOrdered<O>, deleteRule: DeleteRule = .nullify, minCount: Int = 0, maxCount: Int = 0, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToManyOrdered<O>,
+            deleteRule: DeleteRule = .nullify,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, minCount: minCount, maxCount: maxCount, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                minCount: minCount,
+                maxCount: maxCount,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -535,10 +718,28 @@ public enum RelationshipContainer<O: CoreStoreObject> {
         - parameter deleteRule: defines what happens to relationship when an object is deleted. Valid values are `.nullify`, `.cascade`, and `.delete`. Defaults to `.nullify`.
         - parameter versionHashModifier: used to mark or denote a relationship as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
         - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public convenience init(_ keyPath: KeyPath, inverse: @escaping (D) -> RelationshipContainer<D>.ToManyUnordered<O>, deleteRule: DeleteRule = .nullify, minCount: Int = 0, maxCount: Int = 0, versionHashModifier: String? = nil, renamingIdentifier: String? = nil) {
+        public convenience init(
+            _ keyPath: KeyPath,
+            inverse: @escaping (D) -> RelationshipContainer<D>.ToManyUnordered<O>,
+            deleteRule: DeleteRule = .nullify,
+            minCount: Int = 0,
+            maxCount: Int = 0,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
-            self.init(keyPath: keyPath, inverseKeyPath: { inverse(D.meta).keyPath }, deleteRule: deleteRule, minCount: minCount, maxCount: maxCount, versionHashModifier: versionHashModifier, renamingIdentifier: renamingIdentifier)
+            self.init(
+                keyPath: keyPath,
+                inverseKeyPath: { inverse(D.meta).keyPath },
+                deleteRule: deleteRule,
+                minCount: minCount,
+                maxCount: maxCount,
+                versionHashModifier: versionHashModifier,
+                renamingIdentifier: renamingIdentifier,
+                affectedByKeyPaths: affectedByKeyPaths
+            )
        }
        
        /**
@@ -570,6 +771,7 @@ public enum RelationshipContainer<O: CoreStoreObject> {
        internal let inverse: (type: CoreStoreObject.Type, keyPath: () -> KeyPath?)
        internal let versionHashModifier: String?
        internal let renamingIdentifier: String?
+        internal let affectedByKeyPaths: () -> Set<String>
        
        internal var parentObject: () -> CoreStoreObject = {
            
@@ -611,7 +813,7 @@ public enum RelationshipContainer<O: CoreStoreObject> {
        
        // MARK: Private
        
-        private init(keyPath: KeyPath, inverseKeyPath: @escaping () -> KeyPath?, deleteRule: DeleteRule, minCount: Int, maxCount: Int, versionHashModifier: String?, renamingIdentifier: String?) {
+        private init(keyPath: KeyPath, inverseKeyPath: @escaping () -> KeyPath?, deleteRule: DeleteRule, minCount: Int, maxCount: Int, versionHashModifier: String?, renamingIdentifier: String?, affectedByKeyPaths: @autoclosure @escaping () -> Set<String>) {
            
            self.keyPath = keyPath
            self.deleteRule = deleteRule.nativeValue
@@ -622,6 +824,7 @@ public enum RelationshipContainer<O: CoreStoreObject> {
            let range = (Swift.max(0, minCount) ... maxCount)
            self.minCount = range.lowerBound
            self.maxCount = range.upperBound
+            self.affectedByKeyPaths = affectedByKeyPaths
        }
    }
    
@@ -658,7 +861,7 @@ extension RelationshipContainer.ToManyOrdered: RandomAccessCollection {
    public func makeIterator() -> Iterator {
        
        let iterator = self.nativeValue.makeIterator()
-        return AnyIterator({ D.cs_fromRaw(object: iterator.next() as! NSManagedObject) })
+        return AnyIterator({ iterator.next().flatMap({ D.cs_fromRaw(object: $0 as! NSManagedObject) }) })
    }
    
    
@@ -713,7 +916,7 @@ extension RelationshipContainer.ToManyUnordered: Sequence {
    public func makeIterator() -> Iterator {
        
        let iterator = self.nativeValue.makeIterator()
-        return AnyIterator({ D.cs_fromRaw(object: iterator.next() as! NSManagedObject) })
+        return AnyIterator({ iterator.next().flatMap({ D.cs_fromRaw(object: $0 as! NSManagedObject) }) })
    }
 }

@@ -988,6 +1191,7 @@ internal protocol RelationshipProtocol: class {
    var isOrdered: Bool { get }
    var deleteRule: NSDeleteRule { get }
    var inverse: (type: CoreStoreObject.Type, keyPath: () -> KeyPath?) { get }
+    var affectedByKeyPaths: () -> Set<String> { get }
    var parentObject: () -> CoreStoreObject { get set }
    var versionHashModifier: String? { get }
    var renamingIdentifier: String? { get }
--- a/Sources/Value.swift
+++ b/Sources/Value.swift
@@ -102,7 +102,7 @@ public enum ValueContainer<O: CoreStoreObject> {
         }
         ```
         - parameter keyPath: the permanent attribute name for this property.
-         - parameter default: the initial value for the property when the object is first created. Defaults to the `ImportableAttributeType`'s empty value if not specified.
+         - parameter default: the initial value for the property when the object is first created. For types that implement `EmptyableAttributeType`s, this argument may be omitted and the type's "empty" value will be used instead (e.g. `false` for `Bool`, `0` for `Int`, `""` for `String`, etc.)
         - parameter isIndexed: `true` if the property should be indexed for searching, otherwise `false`. Defaults to `false` if not specified.
         - parameter isTransient: `true` if the property is transient, otherwise `false`. Defaults to `false` if not specified. The transient flag specifies whether or not a property's value is ignored when an object is saved to a persistent store. Transient properties are not saved to the persistent store, but are still managed for undo, redo, validation, and so on.
         - parameter versionHashModifier: used to mark or denote a property as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
@@ -114,8 +114,18 @@ public enum ValueContainer<O: CoreStoreObject> {
         - parameter setValue: the original setter for the property
         - parameter finalNewValue: the transformed new value
         - parameter originalNewValue: the original new value
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public init(_ keyPath: KeyPath, `default`: V = V.cs_emptyValue(), isIndexed: Bool = false, isTransient: Bool = false, versionHashModifier: String? = nil, renamingIdentifier: String? = nil, customGetter: @escaping (_ `self`: O, _ getValue: () -> V) -> V = { $1() }, customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V) -> Void, _ originalNewValue: V) -> Void = { $1($2) }) {
+        public init(
+            _ keyPath: KeyPath,
+            `default`: V,
+            isIndexed: Bool = false,
+            isTransient: Bool = false,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            customGetter: @escaping (_ `self`: O, _ getValue: () -> V) -> V = { $1() },
+            customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V) -> Void, _ originalNewValue: V) -> Void = { $1($2) },
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
            self.keyPath = keyPath
            self.isIndexed = isIndexed
@@ -125,6 +135,7 @@ public enum ValueContainer<O: CoreStoreObject> {
            self.renamingIdentifier = renamingIdentifier
            self.customGetter = customGetter
            self.customSetter = customSetter
+            self.affectedByKeyPaths = affectedByKeyPaths
        }
        
        /**
@@ -192,6 +203,7 @@ public enum ValueContainer<O: CoreStoreObject> {
        internal let defaultValue: Any?
        internal let versionHashModifier: String?
        internal let renamingIdentifier: String?
+        internal let affectedByKeyPaths: () -> Set<String>
        
        internal var parentObject: () -> CoreStoreObject = {
            
@@ -247,8 +259,18 @@ public enum ValueContainer<O: CoreStoreObject> {
         - parameter setValue: the original setter for the property
         - parameter finalNewValue: the transformed new value
         - parameter originalNewValue: the original new value
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public init(_ keyPath: KeyPath, `default`: V? = nil, isIndexed: Bool = false, isTransient: Bool = false, versionHashModifier: String? = nil, renamingIdentifier: String? = nil, customGetter: @escaping (_ `self`: O, _ getValue: () -> V?) -> V? = { $1() }, customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V?) -> Void, _ originalNewValue: V?) -> Void = { $1($2) }) {
+        public init(
+            _ keyPath: KeyPath,
+            `default`: V? = nil,
+            isIndexed: Bool = false,
+            isTransient: Bool = false,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            customGetter: @escaping (_ `self`: O, _ getValue: () -> V?) -> V? = { $1() },
+            customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V?) -> Void, _ originalNewValue: V?) -> Void = { $1($2) },
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
            self.keyPath = keyPath
            self.isIndexed = isIndexed
@@ -258,6 +280,7 @@ public enum ValueContainer<O: CoreStoreObject> {
            self.renamingIdentifier = renamingIdentifier
            self.customGetter = customGetter
            self.customSetter = customSetter
+            self.affectedByKeyPaths = affectedByKeyPaths
        }
        
        /**
@@ -324,6 +347,7 @@ public enum ValueContainer<O: CoreStoreObject> {
        internal let defaultValue: Any?
        internal let versionHashModifier: String?
        internal let renamingIdentifier: String?
+        internal let affectedByKeyPaths: () -> Set<String>
        
        internal var parentObject: () -> CoreStoreObject = {
            
@@ -338,6 +362,53 @@ public enum ValueContainer<O: CoreStoreObject> {
    }
 }

+public extension ValueContainer.Required where V: EmptyableAttributeType {
+    
+    /**
+     Initializes the metadata for the property. This convenience initializer uses the `EmptyableAttributeType`'s "empty" value as the initial value for the property when the object is first created (e.g. `false` for `Bool`, `0` for `Int`, `""` for `String`, etc.)
+     ```
+     class Person: CoreStoreObject {
+         let title = Value.Required<String>("title") // initial value defaults to empty string
+     }
+     ```
+     - parameter keyPath: the permanent attribute name for this property.
+     - parameter isIndexed: `true` if the property should be indexed for searching, otherwise `false`. Defaults to `false` if not specified.
+     - parameter isTransient: `true` if the property is transient, otherwise `false`. Defaults to `false` if not specified. The transient flag specifies whether or not a property's value is ignored when an object is saved to a persistent store. Transient properties are not saved to the persistent store, but are still managed for undo, redo, validation, and so on.
+     - parameter versionHashModifier: used to mark or denote a property as being a different "version" than another even if all of the values which affect persistence are equal. (Such a difference is important in cases where the properties are unchanged but the format or content of its data are changed.)
+     - parameter renamingIdentifier: used to resolve naming conflicts between models. When creating an entity mapping between entities in two managed object models, a source entity property and a destination entity property that share the same identifier indicate that a property mapping should be configured to migrate from the source to the destination. If unset, the identifier will be the property's name.
+     - parameter customGetter: use this closure to make final transformations to the property's value before returning from the getter.
+     - parameter self: the `CoreStoreObject`
+     - parameter getValue: the original getter for the property
+     - parameter customSetter: use this closure to make final transformations to the new value before assigning to the property.
+     - parameter setValue: the original setter for the property
+     - parameter finalNewValue: the transformed new value
+     - parameter originalNewValue: the original new value
+     - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
+     */
+    public convenience init(
+        _ keyPath: KeyPath,
+        isIndexed: Bool = false,
+        isTransient: Bool = false,
+        versionHashModifier: String? = nil,
+        renamingIdentifier: String? = nil,
+        customGetter: @escaping (_ `self`: O, _ getValue: () -> V) -> V = { $1() },
+        customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V) -> Void, _ originalNewValue: V) -> Void = { $1($2) },
+        affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
+        
+        self.init(
+            keyPath,
+            default: V.cs_emptyValue(),
+            isIndexed: isIndexed,
+            isTransient: isTransient,
+            versionHashModifier: versionHashModifier,
+            renamingIdentifier: renamingIdentifier,
+            customGetter: customGetter,
+            customSetter: customSetter,
+            affectedByKeyPaths: affectedByKeyPaths
+        )
+    }
+}
+

 // MARK: - TransformableContainer

@@ -388,8 +459,18 @@ public enum TransformableContainer<O: CoreStoreObject> {
         - parameter setValue: the original setter for the property
         - parameter finalNewValue: the transformed new value
         - parameter originalNewValue: the original new value
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public init(_ keyPath: KeyPath, `default`: V, isIndexed: Bool = false, isTransient: Bool = false, versionHashModifier: String? = nil, renamingIdentifier: String? = nil, customGetter: @escaping (_ `self`: O, _ getValue: () -> V) -> V = { $1() }, customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V) -> Void, _ originalNewValue: V) -> Void = { $1($2) }) {
+        public init(
+            _ keyPath: KeyPath,
+            `default`: V,
+            isIndexed: Bool = false,
+            isTransient: Bool = false,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            customGetter: @escaping (_ `self`: O, _ getValue: () -> V) -> V = { $1() },
+            customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V) -> Void, _ originalNewValue: V) -> Void = { $1($2) },
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
            self.keyPath = keyPath
            self.defaultValue = `default`
@@ -399,6 +480,7 @@ public enum TransformableContainer<O: CoreStoreObject> {
            self.renamingIdentifier = renamingIdentifier
            self.customGetter = customGetter
            self.customSetter = customSetter
+            self.affectedByKeyPaths = affectedByKeyPaths
        }
        
        /**
@@ -465,6 +547,7 @@ public enum TransformableContainer<O: CoreStoreObject> {
        internal let defaultValue: Any?
        internal let versionHashModifier: String?
        internal let renamingIdentifier: String?
+        internal let affectedByKeyPaths: () -> Set<String>
        
        internal var parentObject: () -> CoreStoreObject = {
            
@@ -514,8 +597,18 @@ public enum TransformableContainer<O: CoreStoreObject> {
         - parameter setValue: the original setter for the property
         - parameter finalNewValue: the transformed new value
         - parameter originalNewValue: the original new value
+         - parameter affectedByKeyPaths: a set of key paths for properties whose values affect the value of the receiver. This is similar to `NSManagedObject.keyPathsForValuesAffectingValue(forKey:)`.
         */
-        public init(_ keyPath: KeyPath, `default`: V? = nil, isIndexed: Bool = false, isTransient: Bool = false, versionHashModifier: String? = nil, renamingIdentifier: String? = nil, customGetter: @escaping (_ `self`: O, _ getValue: () -> V?) -> V? = { $1() }, customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V?) -> Void, _ originalNewValue: V?) -> Void = { $1($2) }) {
+        public init(
+            _ keyPath: KeyPath,
+            `default`: V? = nil,
+            isIndexed: Bool = false,
+            isTransient: Bool = false,
+            versionHashModifier: String? = nil,
+            renamingIdentifier: String? = nil,
+            customGetter: @escaping (_ `self`: O, _ getValue: () -> V?) -> V? = { $1() },
+            customSetter: @escaping (_ `self`: O, _ setValue: (_ finalNewValue: V?) -> Void, _ originalNewValue: V?) -> Void = { $1($2) },
+            affectedByKeyPaths: @autoclosure @escaping () -> Set<String> = []) {
            
            self.keyPath = keyPath
            self.defaultValue = `default`
@@ -525,6 +618,7 @@ public enum TransformableContainer<O: CoreStoreObject> {
            self.renamingIdentifier = renamingIdentifier
            self.customGetter = customGetter
            self.customSetter = customSetter
+            self.affectedByKeyPaths = affectedByKeyPaths
        }
        
        /**
@@ -591,6 +685,7 @@ public enum TransformableContainer<O: CoreStoreObject> {
        internal let defaultValue: Any?
        internal let versionHashModifier: String?
        internal let renamingIdentifier: String?
+        internal let affectedByKeyPaths: () -> Set<String>
        
        internal var parentObject: () -> CoreStoreObject = {
            
@@ -907,5 +1002,6 @@ internal protocol AttributeProtocol: class {
    var defaultValue: Any? { get }
    var versionHashModifier: String? { get }
    var renamingIdentifier: String? { get }
+    var affectedByKeyPaths: () -> Set<String> { get }
    var parentObject: () -> CoreStoreObject { get set }
 }
--- a/Sources/XcodeSchemaMappingProvider.swift
+++ b/Sources/XcodeSchemaMappingProvider.swift
@@ -32,7 +32,7 @@ import Foundation
 /**
 A `SchemaMappingProvider` that tries to infer model migration between two `DynamicSchema` versions by loading an xcmappingmodel file from the specified `Bundle`. Throws `CoreStoreError.mappingModelNotFound` if the xcmappingmodel file cannot be found, or if the xcmappingmodel doesn't resolve the source and destination `DynamicSchema`.
 */
-final class XcodeSchemaMappingProvider: Hashable, SchemaMappingProvider {
+public final class XcodeSchemaMappingProvider: Hashable, SchemaMappingProvider {
    
    /**
     The source model version for the mapping.
Author	SHA1	Message	Date
John Rommel Estropia	129f975d96	version bump	2017-06-08 01:17:39 +09:00
John Rommel Estropia	a2e463e58c	Merge branch 'prototype/customMigrationTest' of github.com:JohnEstropia/CoreStore into prototype/customMigrationTest	2017-06-08 01:07:00 +09:00
John Rommel Estropia	5fd50f0e15	fix migration for CoreStoreObject relationships	2017-06-08 01:06:51 +09:00
John Estropia	0a81736b7a	Merge branch 'develop' into prototype/customMigrationTest	2017-06-07 12:31:42 +09:00
John Estropia	f9b6dd0c6a	fix bug when using ObjectMonitor with CoreStoreObjects	2017-06-06 17:40:29 +09:00
John Rommel Estropia	0354401b56	WIP: bugfix for CustomSchemaMappingProvider relationship migration bug	2017-06-06 08:39:59 +09:00
John Rommel Estropia	0304067beb	fix ToManyOrdered and ToManyUnordered enumeration crash	2017-06-06 00:49:16 +09:00
John Rommel Estropia	ddd83da434	add Where comparison operators for optional values	2017-06-05 23:09:19 +09:00
John Estropia	fc7df671de	Fixes https://bugs.swift.org/browse/SR-4981	2017-06-05 12:45:35 +09:00
John Rommel Estropia	5fde9030c7	use stronger namespace for CoreStoreObject's internal managed object type	2017-06-05 08:03:37 +09:00
John Rommel Estropia	d7b07b3f00	Added alternative way to set keyPathsForValuesAffectingValue(forKey:) for CoreStoreObjects	2017-06-05 01:30:26 +09:00
John Rommel Estropia	ddd1ffb29f	added ~= operation to create Where clauses for value arrays	2017-06-03 08:51:52 +09:00
John Rommel Estropia	98094000bb	Merge branch 'master' into develop	2017-06-02 23:10:31 +09:00
John Estropia	d5026ef996	Merge branch 'temp/develop' into develop	2017-06-02 19:35:01 +09:00
John Estropia	2cd913b9dd	added more utilities for CoreStoreObject meta	2017-06-02 19:34:54 +09:00
John Estropia	ad9520abbc	Update README.md	2017-06-02 13:24:15 +09:00
John Estropia	c0fc57d10c	Update README.md	2017-06-02 11:34:04 +09:00
John Estropia	0cf4d303e4	Added README sample on how to version CoreStoreObjects	2017-06-02 11:32:48 +09:00
John Rommel Estropia	6de397958a	fix demo app warnings	2017-06-02 02:06:47 +09:00
John Rommel Estropia	55292a84dc	made mapping modell providers public	2017-06-02 02:03:41 +09:00
John Estropia	981b560d53	test travis ci	2017-05-30 11:14:57 +09:00
John Estropia	c4c4dd55cd	test travis build	2017-05-30 11:06:30 +09:00
John Rommel Estropia	1ddbe20c86	Updated README, fixed demo app, and bumped to 4.0.1	2017-05-28 11:37:40 +09:00
John Rommel Estropia	da9e8c1550	disallow "empty" default values on some ImportableAttributeTypes	2017-05-28 10:50:25 +09:00