Question

I have models corresponding to database tables. For example, the House class has “color”, “price”, “square_feet”, “real_estate_agent_id” columns.

It is very common for me to want to display the agent name when I display information about a house. As a result, my House class has the following fields:

class House {
  String color;
  Double price;
  Integer squareFeet;
  Integer realEstateAgentId;

  String realEstateAgentName;
}

I’ve been referring to realEstateAgentName as a virtual field, as it is pulled from a foreign table (join on real_estate_agent_id).

This doesn’t feel right to me, as it mixes actual database columns with foreign object’s properties. But it’s quick, and in many cases it really works out well.

Other times I find myself doing something like this:

class House {
  String color;
  Double price;
  Integer squareFeet;
  Integer realEstateAgentId;

  RealEstateAgent realEstateAgent;
}

As you can see, I’m storing the actual object corresponding to the ID that is stored in the House table.

I tend to make the decision to store the entire object vs some key information associated with the ID (e.g. Name) depending on the likelihood I see of needing to access other information about the object it represents.

I have a few questions:

Of the two methods I’ve been mixing and matching, which is best? I’m leaning towards storing the id + the object, rather than pulling out just the properties from the foreign object that I think I may need. Of the two, this seems more “correct.” But it’s not perfect, because in many cases I don’t have any need to hydrate the entire foreign object, and doing so would cause undue waste of resources or would not be feasible because of the amount of data or the number of joins that would be required when I don’t have any use for all the info being brought in. Given that this is the case, it seems like a poor design choice because I will have lots of null fields that aren’t really null in my database, but are so in memory simply because there was no need to populate them — now I have to keep track of which ones I populated.

But is it best practice to store an ID alongside the object it represents? Should I even be storing the object as a property, or should it live externally in some map, with the ID being the key?

In an Object world it seems like the ID shouldn’t even be stored as a property, with the foreign Object it represents being the logical replacement. But with everything being tightly coupled with a relational database it doesn’t seem very feasible.

Is this frustrating impurity of my models/classes something I just have to live with, or are there patterns out there that address this by having some kind of fork or parent/child subclassing going on where one is a “pure” object while the other is flat like the database?

EDIT: I am looking for design suggestions here rather than specific ORM frameworks like Hibernate/nHibernate/etc. The particular language I’m working in does not have an ORM solution for my language version that I am satisfied with, and the examples were Java-esque but that’s not what my source code is written in.

Answer 1

I can tell about Hibernate, because this is the ORM tool I am most familiar with. I believe that other ORM tools also support similar behaviour to some extent.

Hibernate solves your problem with lazy loading. You add your agent as a property to the house, and by default, when the house object is loaded, the agent is represented by a proxy object generated by Hibernate, which contains only the ID. If you query some other property of the agent, Hibernate loads the full object in the background:

class House {
    String color;
    Double price;
    Integer squareFeet;
    RealEstateAgent realEstateAgent;
    // getters, setters,...
}

House house = (House) session.load(House.class, new Long(123));
// at this point, house refers to a proxy object created by Hibernate
// in the background - no house or agent data has been loaded from DB
house.getId();
// house still refers to the proxy object
RealEstateAgent agent = house.getRealEstateAgent();
// house is now loaded, but agent not - it refers to a proxy object
String name = agent.getName(); // Now the agent data is loaded from DB

OTOH if you are sure that for a specific class you (almost) always need a specific property, you can specify eager loading in the ORM mapping for that property, in which case the property is loaded as soon as the containing object. In the mapping you can also specify whether you want a join query or a subselect query.