Core data and sorting after a join condition

I have 3 tables in my core data tables.

Item table: items, which开发者_JAVA技巧 has an ID column and a connection to a properties table.

Properties table: it has a propertyValue column and a connection to item table and a connection to property table.

Property table: it has a propertyName column and a connection to properties table.

The property table contains a propertyName called "price".

The properties table contains a propertyValue "20" for the property "price".

Do you think I can sort the Items table by price?

I am using a NSFetchedResultsController and I am creating a NSFetchRequest for it. I have tried to write a NSSortDescriptor with a comparator block object for the NSFetchRequest. It isn't working. After this I tried to write a NSSortDescriptor without any selector or block object, I just setup a key called "dealPrice" and created a category on the Item managed object with a method called - (NSString *)dealPrice. It wasn't working neither.

Do you know any other method? Or do you know the solution?

You've obviously got a bad case of SQL fever. Your trying to treat Core Data like an SQL wrapper and that is messing everything up.

Core Data is not SQL. Entities are not tables. Objects are not rows. Attributes are not columns. Relationships are not joins. Core Data is an object graph management system that may or may not persist the object graph and may or may not use SQL far behind the scenes to do so. Trying to think of Core Data in SQL terms will cause you to completely misunderstand Core Data and result in much grief and wasted time.

A Core Data datamodel should not be configured depending on the needs of the UI or any other non-data requirement. Instead, it should accurately model/simulate the real world objects, events or conditions that the app deals with.

In this case, you are modeling:

1. A type of property that has a name and a price.
2. An item denoted by an id of some kind
3. A relationship between one or more particular property instances and one or more instances of item.

Therefore, your data model only needs two entities connected by a relationship. You don't need a "join" because the relationship handles the connection between the two entities automatically.

The simplest model has just a one-to-one relationship:

Item{
  id:string
  property<-->Property.item
}

Property{
  name:string
  price:number
  item<-->Item.property
}

If each Item object can have several associated Property objects then you would have:

Item{
  id:string
  properties<-->>Property.item
}

Property{
  name:string
  price:number
  item<<-->Item.properties
}

If each Property object can have several associated Item objects:

Item{
  id:string
  property<<-->Property.items
}

Property{
  name:string
  price:number
  items<-->>Item.properties
}

How you configure your sort descriptors depends on the details of the relationships and which entity's objects your tableview will display.

What I would first recommend is to stop thinking about CoreData like a database. It is NOT a database. The things you call "tables" are actually Entities. Think of them as objects, that have properties and relationships to other objects. Think about making your data model as simple as possible. Do not try to optimize your structure for database performance etc. The actual backing schema is not under your control.

With that in mind, from what you've posted about your data model, it seems like you should be able to collapse into at least 2 entities instead of 3 (perhaps 1 but not sure without seeing your entire data model). Then, you should be able to do a simple fetch on the Items entity with a predicate that sorts on a property of it's related object.

It sounds like your real object model is and entity named Deal with an attribute named "price".