How to use

Association

in

org.grails.datastore.mapping.model.types

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

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

protected boolean canBindOneToOneWithSingleColumnAndForeignKey(Association currentGrailsProp) {
  if (currentGrailsProp.isBidirectional()) {
    final Association otherSide = currentGrailsProp.getInverseSide();
    if(otherSide != null) {
      if (isHasOne(otherSide)) {
        return false;
      }
      if (!currentGrailsProp.isOwningSide() && (otherSide.isOwningSide())) {
        return true;
      }
    }
  }
  return false;
}

protected boolean isBidirectionalOneToManyMap(Association property) {
  return Map.class.isAssignableFrom(property.getType()) && property.isBidirectional();
}

protected boolean isBidirectionalManyToOneWithListMapping(PersistentProperty grailsProperty, Property prop) {
  if(grailsProperty instanceof Association) {
    Association association = (Association) grailsProperty;
    Association otherSide = association.getInverseSide();
    return association.isBidirectional() && otherSide != null &&
        prop.getValue() instanceof ManyToOne &&
        List.class.isAssignableFrom(otherSide.getType());
  }
  return false;
}

PersistentEntity refDomainClass = property instanceof ManyToMany ? property.getOwner() : property.getAssociatedEntity();
Mapping mapping = getMapping(refDomainClass);
boolean isComposite = hasCompositeIdentifier(mapping);
  if (property.isCircular() && (property instanceof ManyToMany)) {
    PropertyConfig pc = getPropertyConfig(property);
      mapping.getColumns().put(property.getName(), pc);
      columnConfig.setName(namingStrategy.propertyToColumnName(property.getName()) +
          UNDERSCORE + FOREIGN_KEY_SUFFIX);
      jt.setKey(columnConfig);
    c.setUnique(config.isUnique());
  else if (property.isBidirectional() && isHasOne(property.getInverseSide())) {
    c.setUnique(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();
}

private String getAssociationPath(String propertyName) {
  StringBuilder fullPath = new StringBuilder();
  for (Iterator<Association> iterator = associationStack.iterator(); iterator.hasNext(); ) {
    Association association = iterator.next();
    fullPath.append(association.getName());
    fullPath.append('.');
  }
  fullPath.append(propertyName);
  return fullPath.toString();
}

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;
}

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);
        }
      }
    }
  }
}

@Override
public String toString() {
  return getOwner().getName() + "->" + getName();
}

        embeddedEa.setProperty(inverseSide.getName(), obj);
      query.eq(association.getInverseSide().getName(), obj)
         .projections().id();
        EntityAccess embeddedEa =
            createEntityAccess(embeddedCollection.getAssociatedEntity(), embeddedInstance);
        embeddedEa.setProperty(inverseSide.getName(), obj);
PropertyMapping<Property> associationPropertyMapping = association.getMapping();
  if (List.class.isAssignableFrom(association.getType())) {
    ea.setPropertyNoConversion(association.getName(),
        new PersistentList(keys, association.getAssociatedEntity().getJavaClass(), session));
  else if (Set.class.isAssignableFrom(association.getType())) {
    ea.setPropertyNoConversion(association.getName(),
        new PersistentSet(keys, association.getAssociatedEntity().getJavaClass(), session));
    nativeKey = convertIdIfNecessary(getPersistentEntity(), nativeKey );
    if (isLazy) {
      if (List.class.isAssignableFrom(association.getType())) {
        ea.setPropertyNoConversion(association.getName(),
            new PersistentList(nativeKey, session, indexer));
      else if (SortedSet.class.isAssignableFrom(association.getType())) {
        ea.setPropertyNoConversion(association.getName(),
            new PersistentSortedSet(nativeKey, session, indexer));

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

  column.setNullable(false);
else if (property instanceof org.grails.datastore.mapping.model.types.OneToOne && association.isBidirectional() && !association.isOwningSide()) {
  if (isHasOne(((Association) property).getInverseSide())) {
    column.setNullable(false);
else if ((property instanceof ToOne) && association.isCircular()) {
  column.setNullable(true);

PersistentEntity entity = association.getAssociatedEntity();
List<Selection> selections = (set == null ? new ArrayList<>() : set.getSelections());
if (!association.isEmbedded()) {
  if (isForeignKeyInChild(association)) {
    joinProperties.add(resolvedName);
    .map(Field.class::cast)
    .forEach((Field field) -> {
      if (field.getName().equals(association.getReferencedPropertyName())) {
        if (field.getSelectionSet() != null) {

Association inverseSide = association.getInverseSide();
if (inverseSide != null) {
  setEntryValue(cachedAssociationEntry, inverseSide.getName(), formulateDatabaseReference(association.getAssociatedEntity(), inverseSide, (Serializable) k));
} else {
  setEntryValue(cachedAssociationEntry, key, formulateDatabaseReference(association.getAssociatedEntity(), inverseSide, (Serializable) k));
Association inverseSide = association.getInverseSide();
if (inverseSide != null) {
  EntityAccess inverseAccess = createEntityAccess(inverseSide.getOwner(), associatedObject);
  inverseAccess.setProperty(inverseSide.getName(), obj);
  Object entity = entityAccess.getEntity();
  if (inverse instanceof OneToMany) {
    Collection existingValues = (Collection) inverseAccess.getProperty(inverse.getName());
    if (existingValues == null) {
      existingValues = MappingUtils.createConcreteCollection(inverse.getType());
      inverseAccess.setProperty(inverse.getName(), existingValues);
    inverseAccess.setProperty(inverse.getName(), entity);

private void buildCascadeOperations() {
  T mappedForm = this.getMapping().getMappedForm();
  this.orphanRemoval = mappedForm.isOrphanRemoval();
  final String cascade = mappedForm.getCascade();
      this.cascadeOperations = Collections.unmodifiableSet(new HashSet<>(cascades));
    else if (isOwningSide()) {
      cascadeOperations = DEFAULT_OWNER_CASCADE;
      if((this instanceof ManyToOne) && isBidirectional()) {

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();
    }
  };
}

/**
 * Checks whether a property is a unidirectional non-circular one-to-many
 *
 * @param property The property to check
 * @return true if it is unidirectional and a one-to-many
 */
protected boolean isUnidirectionalOneToMany(PersistentProperty property) {
  return ((property instanceof org.grails.datastore.mapping.model.types.OneToMany) && !((Association)property).isBidirectional());
}

  @Override
  public boolean isOwningSide() {
    return super.isOwningSide() || isForeignKeyInChild();
  }
}