How to use

getAssociatedEntity

method

in

org.grails.datastore.mapping.model.types.Association

  @Override
  public PersistentEntity getIndexedEntity() {
    return association.getAssociatedEntity();
  }
};

/**
 * @return Whether the association is circular
 */
public boolean isCircular() {
  PersistentEntity associatedEntity = getAssociatedEntity();
  return associatedEntity != null && associatedEntity.getJavaClass().isAssignableFrom(owner.getJavaClass());
}

private static int handleAssociationCriteria(StringBuilder query, StringBuilder whereClause, String logicalName, int position, List parameters, ConversionService conversionService, boolean allowJoins, Association<?> association, Query.Junction associationCriteria, List<Query.Criterion> associationCriteriaList, boolean hibernateCompatible) {
  if (association instanceof ToOne) {
    final String associationName = association.getName();
    logicalName = logicalName + DOT + associationName;
    return buildWhereClauseForCriterion(association.getAssociatedEntity(), associationCriteria, query, whereClause, logicalName, associationCriteriaList, position, parameters, conversionService, allowJoins, hibernateCompatible);
  }
  if (association != null) {
    final String associationName = association.getName();
    // TODO: Allow customization of join strategy!
    String joinType = " INNER JOIN ";
    query.append(joinType)
     .append(logicalName)
     .append(DOT)
     .append(associationName)
     .append(SPACE)
     .append(associationName);
    return buildWhereClauseForCriterion(association.getAssociatedEntity(), associationCriteria, query, whereClause, associationName, associationCriteriaList, position, parameters, conversionService, allowJoins, hibernateCompatible);
  }
  return position;
}

/**
 * Creates an association query
 *
 * @param associationName The assocation name
 * @return The Query instance
 */
public AssociationQuery createQuery(String associationName) {
  final PersistentProperty property = entity.getPropertyByName(associationName);
  if (property == null || !(property instanceof Association)) {
    throw new InvalidDataAccessResourceUsageException("Cannot query association [" +
       associationName + "] of class [" + entity +
       "]. The specified property is not an association.");
  }
  Association association = (Association) property;
  final PersistentEntity associatedEntity = association.getAssociatedEntity();
  return new AssociationQuery(session, associatedEntity, association);
}

PersistentEntity entity = association.getAssociatedEntity();

public static String associationtoString(String desc, Association a) {
  return desc + a.getOwner().getName() + "-> " + a.getName() + " ->" + a.getAssociatedEntity().getName();
}

/**
 * Add order to criteria, creating necessary subCriteria if nested sort property (ie. sort:'nested.property').
 */
private static void addOrderPossiblyNested(Criteria c, PersistentEntity entity, String sort, String order, boolean ignoreCase) {
  int firstDotPos = sort.indexOf(".");
  if (firstDotPos == -1) {
    addOrder(c, sort, order, ignoreCase);
  } else { // nested property
    String sortHead = sort.substring(0,firstDotPos);
    String sortTail = sort.substring(firstDotPos+1);
    PersistentProperty property = entity.getPropertyByName(sortHead);
    if (property instanceof Embedded) {
      // embedded objects cannot reference entities (at time of writing), so no more recursion needed
      addOrder(c, sort, order, ignoreCase);
    } else if(property instanceof Association) {
      Association a = (Association) property;
      Criteria subCriteria = c.createCriteria(sortHead);
      PersistentEntity associatedEntity = a.getAssociatedEntity();
      Class<?> propertyTargetClass = associatedEntity.getJavaClass();
      cacheCriteriaByMapping(propertyTargetClass, subCriteria);
      addOrderPossiblyNested( subCriteria, associatedEntity, sortTail, order, ignoreCase); // Recurse on nested sort
    }
  }
}

@Override
public AssociationQuery createQuery(String associationName) {
  final PersistentProperty property = entity.getPropertyByName(calculatePropertyName(associationName));
  if (property != null && (property instanceof Association)) {
    String alias = generateAlias(associationName);
    CriteriaAndAlias subCriteria = getOrCreateAlias(associationName, alias);
    Association association = (Association) property;
    if(subCriteria.criteria != null) {
      return new HibernateAssociationQuery(subCriteria.criteria, (AbstractHibernateSession) getSession(), association.getAssociatedEntity(), association, alias);
    }
    else if(subCriteria.detachedCriteria != null) {
      return new HibernateAssociationQuery(subCriteria.detachedCriteria, (AbstractHibernateSession) getSession(), association.getAssociatedEntity(), association, alias);
    }
  }
  throw new InvalidDataAccessApiUsageException("Cannot query association [" + calculatePropertyName(associationName) + "] of entity [" + entity + "]. Property is not an association!");
}

protected AbstractPersistentCollection(final Association association, Serializable associationKey, final Session session, Collection collection) {
  this.collection = collection;
  this.session = session;
  this.associationKey = associationKey;
  this.proxyEntities = association.getMapping().getMappedForm().isLazy();
  this.childType = association.getAssociatedEntity().getJavaClass();
  this.indexer = new AssociationQueryExecutor() {
    @Override
    public boolean doesReturnKeys() {
      return true;
    }
    @Override
    public List query(Object primaryKey) {
      Association inverseSide = association.getInverseSide();
      Query query = session.createQuery(association.getAssociatedEntity().getJavaClass());
      query.eq(inverseSide.getName(), primaryKey);
      query.projections().id();
      return query.list();
    }
    @Override
    public PersistentEntity getIndexedEntity() {
      return association.getAssociatedEntity();
    }
  };
}

  @Override
  public org.hibernate.criterion.Criterion toHibernateCriterion(HibernateQuery hibernateQuery, Query.Criterion criterion, String alias) {
    DetachedAssociationCriteria<?> existing = (DetachedAssociationCriteria<?>) criterion;
    String newAlias = hibernateQuery.handleAssociationQuery(existing.getAssociation(), existing.getCriteria());
    if(alias == null) {
      alias = newAlias;
    }
    else {
      alias = alias + '.' + newAlias;
    }
    Junction conjunction = Restrictions.conjunction();
    applySubCriteriaToJunction(existing.getAssociation().getAssociatedEntity(), hibernateQuery, existing.getCriteria(), conjunction, alias);
    return conjunction;
  }
});

  @Override
  public Criterion toHibernateCriterion(AbstractHibernateQuery hibernateQuery, Query.Criterion criterion, String alias) {
    DetachedAssociationCriteria<?> existing = (DetachedAssociationCriteria<?>) criterion;
    if(alias == null) alias = existing.getAlias();
    alias = hibernateQuery.handleAssociationQuery(existing.getAssociation(), existing.getCriteria(), alias);
    Junction conjunction = Restrictions.conjunction();
    applySubCriteriaToJunction(existing.getAssociation().getAssociatedEntity(), hibernateQuery, existing.getCriteria(), conjunction, alias);
    return conjunction;
  }
});

@Override
public List query(Object primaryKey) {
  Association inverseSide = association.getInverseSide();
  Query query = session.createQuery(association.getAssociatedEntity().getJavaClass());
  query.eq(inverseSide.getName(), primaryKey);
  query.projections().id();
  return query.list();
}

@Override
public AssociationQuery createQuery(String associationName) {
  final PersistentProperty property = entity.getPropertyByName(calculatePropertyName(associationName));
  if (property != null && (property instanceof Association)) {
    @SuppressWarnings("hiding") String alias = generateAlias(associationName);
    CriteriaAndAlias subCriteria = getOrCreateAlias(associationName, alias);
    Association association = (Association) property;
    return new HibernateAssociationQuery(subCriteria.criteria, (HibernateSession) getSession(), association.getAssociatedEntity(), association, alias);
  }
  throw new InvalidDataAccessApiUsageException("Cannot query association [" + calculatePropertyName(associationName) + "] of entity [" + entity + "]. Property is not an association!");
}

  @Override
  public org.hibernate.criterion.Criterion toHibernateCriterion(HibernateQuery hibernateQuery, Query.Criterion criterion, String alias) {
    AssociationQuery existing = (AssociationQuery) criterion;
    Junction conjunction = Restrictions.conjunction();
    String newAlias = hibernateQuery.handleAssociationQuery(existing.getAssociation(), existing.getCriteria().getCriteria());
    if(alias == null) {
      alias = newAlias;
    }
    else {
      alias = alias + '.' + newAlias;
    }
    applySubCriteriaToJunction(existing.getAssociation().getAssociatedEntity(), hibernateQuery, existing.getCriteria().getCriteria(), conjunction, alias);
    return conjunction;
  }
});

  @Override
  public Criterion toHibernateCriterion(AbstractHibernateQuery hibernateQuery, Query.Criterion criterion, String alias) {
    AssociationQuery existing = (AssociationQuery) criterion;
    Junction conjunction = Restrictions.conjunction();
    String newAlias = hibernateQuery.handleAssociationQuery(existing.getAssociation(), existing.getCriteria().getCriteria());
    if (alias == null) {
      alias = newAlias;
    }
    else {
      alias += '.' + newAlias;
    }
    applySubCriteriaToJunction(existing.getAssociation().getAssociatedEntity(), hibernateQuery, existing.getCriteria().getCriteria(), conjunction, alias);
    return conjunction;
  }
});

persistentEntity = association.getAssociatedEntity();
logicalExpressionStack = new ArrayList<Query.Junction>();
invokeClosureNode(args[0]);

/**
 */
protected void bindManyToOneValues(org.grails.datastore.mapping.model.types.Association property, ManyToOne manyToOne) {
  PropertyConfig config = getPropertyConfig(property);
  if (config != null && config.getFetchMode() != null) {
    manyToOne.setFetchMode(config.getFetchMode());
  }
  else {
    manyToOne.setFetchMode(FetchMode.DEFAULT);
  }
  manyToOne.setLazy(getLaziness(property));
  if (config != null) {
    manyToOne.setIgnoreNotFound(config.getIgnoreNotFound());
  }
  // set referenced entity
  manyToOne.setReferencedEntityName(property.getAssociatedEntity().getName());
}

} else if (grailsProperty instanceof Association) {
  Association association = (Association) grailsProperty;
  PersistentEntity referenced = association.getAssociatedEntity();
  if (isHasOne(association)) {
    cascadeStrategy = CASCADE_ALL;
    referenced = association.getAssociatedEntity();
    if (referenced != null && referenced.isOwningEntity(domainClass)) {
      cascadeStrategy = CASCADE_ALL;

protected void configureOwningSide(Association association) {
  PersistentEntity associatedEntity = association.getAssociatedEntity();
  if(associatedEntity == null) {
    association.setOwningSide(true);
  }
  else {
    if (association.isBidirectional()) {
      if (associatedEntity.isOwningEntity(association.getOwner())) {
        association.setOwningSide(true);
      }
    }
    else {
      if (association instanceof OneToOne) {
        if (associatedEntity.isOwningEntity(association.getOwner()))
          association.setOwningSide(true);
      } else if (!(association instanceof Basic)) {
        if (associatedEntity.isOwningEntity(association.getOwner())) {
          association.setOwningSide(true);
        }
        else {
          association.setOwningSide(false);
        }
      }
    }
  }
}

PersistentEntity refDomainClass = property instanceof ManyToMany ? property.getOwner() : property.getAssociatedEntity();
Mapping mapping = getMapping(refDomainClass);
boolean isComposite = hasCompositeIdentifier(mapping);