Explore Posterous

//- (NSPersistentStore *)addPersistentStoreWithType:(NSString *)storeType configuration:nil URL:(NSURL *)storeURL options:(NSDictionary *)options error:(NSError **)error     // this is what you use to set up the database type, etc.  In this snippet I don't worry about it because I just want it to compile and display something.

// Build an NSURL to our physical database file.

NSFileManager *fileManager = [NSFileManager defaultManager];

NSString *folder = @"~/Library/Application Support/Tiny±Git/";

folder = [folder stringByExpandingTildeInPath];

if ([fileManager fileExistsAtPath: folder] == NO)

{

[fileManager createDirectoryAtPath:folder withIntermediateDirectories:NO attributes:nil error:error];

}

    

NSURL *fileURL  = [NSURL fileURLWithPath: [folder stringByAppendingPathComponent: @"TinyGit.sqlite"]];

// Now tell our NSPersistanceStoreCoordinator the type of DB you want (I'm using SQLite, you can also use XML, etc.) 

// Pass in our fileURL NSURL which is where the database will be strored. 

// There are also configurations, and options, but we can ignore this--I'll worry about those once I get this working.

[psc addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:fileURL options:nil error:error];

[newContext save:error];

after you have created them and added them to the NSManagedObjectContext.  The interesting thing here is that the the save: actually forces all the objects within the context to be saved all at once.  It's all or nothing.  So make sure you only add the objects to the context that you want to end up in the database.

Just to verify that this actually did work, I went to my Application Support folder and sure enough there was a new Tiny±Git folder and within it a new file TinyGit.sqlite.  Just to see what got stored (if anything) I opened it up with SQLiteManager:

Compare this with the actual data model:

So, it looks like CoreData builds lots of infrastructure.  Just to see what data got stored I drilled into the data:

Well at least the data that I specified for my simple example in the previous post got saved properly, but there sure is a lot of extraneous stuff going on under the covers.

What do I conclude from all this?  I honestly am not sure. I'm feeling a bit more confident after seeing how relatively easy it is (although limiting) to save a context.  I'll have to see what it's like to actually retrieve/fetch data using CoreData.

• It's not a relational-file system per se.
• It's not based on understanding rows, columns, tables.
• It has no declarative language (SQL).
• It is a relationship between objects that manage various layers of the environment.
• You need to create and manage these objects properly to create a working "object graph".
• The XCode data model document that ends in .xcdatamodel is NOT the data model you load.  It gets compiled into an intermediate form which you then have to find and load.
• You can't use the entities in the data model directly to create object instances.  This is not obvious from the docs, but you have to create a subclass of the entity in the model and THAT is what you use.  There is no way around this (which is a pain).  I'd like to just use the entity as is with no extra step UNLESS I want to subclass it.
• The documentation from Apple is fragmented and assumes a lot without explaining a lot.
• The sample code is minimal.
• The online internet samples/tutorials are again minimal and mostly assume you want to know how to bind things rather than implement things.

// find the location of the COMPILED xcdatamodel document named "Resource"

NSString *path = [[NSBundle mainBundle] pathForResource:@"Resource" ofType:@"momd"];

if (!path) {

path = [[NSBundle mainBundle] pathForResource:@"Resource" ofType:@"mom"];

}

NSAssert(path != nil, @"Unable to find Resource in main bundle");

// Create a URL to the path

NSURL *url = [NSURL fileURLWithPath:path];

// Create the thing that manages the model and its relationship with the graph, point it to the compiled model document.

NSManagedObjectModel * managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:url];

// Create the thing that manages the file/db-type to use to store the data objects. Give it our object model so it knows about the entities, etc.

NSPersistentStoreCoordinator *psc = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:managedObjectModel];

//- (NSPersistentStore *)addPersistentStoreWithType:(NSString *)storeType configuration:nil URL:(NSURL *)storeURL options:(NSDictionary *)options error:(NSError **)error     // this is what you use to set up the database type, etc.  In this snippet I don't worry about it because I just want it to compile and display something.

// set up a context in which the objects live--think of this as a business context. You have to have one.

newContext = [[NSManagedObjectContext alloc] init];

[newContext setPersistentStoreCoordinator:psc];  // This context will use our store coordinator (database mgmt object)

// Create an instance of an object based on an entity in our xcdatamodel document.  Here it is called Recent.  Insert it into our context to be managed.

// Before this will work you need to subclass NSManagedObject -- Recent :  NSManagedObject otherwise you will get an entity not found error.

NSManagedObject * o = [NSEntityDescription  insertNewObjectForEntityForName:@"Recent" inManagedObjectContext:newContext];

// set up some attributes within the entity object

[o setValue:@"/path/here" forKey:@"path"]; 

[o setValue:@"Name" forKey:@"gitName"];

// Add it to an array to be bound to a control in IB.

[a addObject:o];