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