public abstract class Model implements Externalizable {
	private MetaModel metaModelLocal;
    private Map<Class, Model> cachedParents = new HashMap<Class, Model>();
    private Map<Class, List<Model>> cachedChildren = new HashMap<Class, List<Model>>();
    
    public <T extends Model> T parent(Class<T> parentClass) {

        T cachedParent = (T)cachedParents.get(parentClass);
        if(cachedParent != null){
            return cachedParent;
        }
        MetaModel parentMM = Registry.instance().getMetaModel(parentClass);
        String parentTable = parentMM.getTableName();

        BelongsToAssociation ass = (BelongsToAssociation)getMetaModelLocal().getAssociationForTarget(parentTable, BelongsToAssociation.class);
        BelongsToPolymorphicAssociation assP = (BelongsToPolymorphicAssociation)getMetaModelLocal()
                .getAssociationForTarget(parentTable, BelongsToPolymorphicAssociation.class);

        String fkValue;
        String fkName;
        if(ass != null){
            fkValue = getString(ass.getFkName());
            fkName = ass.getFkName();
        }else if(assP != null){
            fkValue = getString("parent_id");            
            fkName = "parent_id";

            if(!assP.getTypeLabel().equals(getString("parent_type"))){
                throw new IllegalArgumentException("Wrong parent: '" + parentClass + "'. Actual parent type label of this record is: '" + getString("parent_type") + "'");
            }
        }else{
            throw new IllegalArgumentException("there is no association with table: " + parentTable);
        }

        if(fkValue == null){
            throw new OrphanRecordException("Attribute:  "  + fkName + " is null, cannot determine parent. Child record: " + this);
        }
        String parentIdName = parentMM.getIdName();
        String query = getMetaModelLocal().getDialect().selectStarParametrized(parentTable, parentIdName);

        T parent;
        if(parentMM.cached()){
            parent = (T)QueryCache.instance().getItem(parentTable, query, new Object[]{fkValue});
            if(parent != null){
                return parent;
            }
        }

        List<Map> results = new DB(getMetaModelLocal().getDbName()).findAll(query, Integer.parseInt(fkValue));
        //expect only one result here
        if (results.size() == 0) { //ths could be covered by referential integrity constraint
            return null;
        } else {
            try {
                parent = parentClass.newInstance();
                parent.hydrate(results.get(0));
                if(parentMM.cached()){
                    QueryCache.instance().addItem(parentTable, query, new Object[]{fkValue}, parent);
                }
                return parent;
            } catch (Exception e) {
                throw new InitException(e.getMessage(), e);
            }
        }
    }
}

@BelongsTo(parent = Department.class, foreignKeyName = "department_id")
public class Employee extends Model {
    private Long id;
    private Department department;
    public Long getId() { return id; }
    public Department getDepartment() { return getParent(Department.class); }
}


public class Department extends Model {
    private Long id;
    private String name;
    public Long getId() { return id; }
    public String getName() { return name; }
    
}