public Mapping evaluateMapping(PersistentEntity domainClass, Closure<?> defaultMapping, boolean cache) { try { final Mapping m = (Mapping) domainClass.getMapping().getMappedForm(); trackCustomCascadingSaves(m, domainClass.getPersistentProperties()); if (cache) { MAPPING_CACHE.put(domainClass.getJavaClass(), m); } return m; } catch (Exception e) { throw new DatastoreConfigurationException("Error evaluating ORM mappings block for domain [" + domainClass.getName() + "]: " + e.getMessage(), e); } }
protected void validatePropertyName(String propertyName, String methodName) { if (persistentEntity == null) return; if (propertyName == null) { throw new IllegalArgumentException("Cannot use [" + methodName + "] restriction with null property name"); } PersistentProperty property = persistentEntity.getPropertyByName(propertyName); if (property == null && persistentEntity.getIdentity().getName().equals(propertyName)) { property = persistentEntity.getIdentity(); } if (property == null && !queryCreator.isSchemaless()) { throw new IllegalArgumentException("Property [" + propertyName + "] is not a valid property of class [" + persistentEntity + "]"); } }
protected boolean canApplyNullableConstraint(String propertyName, PersistentProperty property, Constrained constrained) { if (property == null || property.getType() == null) return false; final PersistentEntity domainClass = property.getOwner(); // only apply default nullable to Groovy entities not legacy Java ones if (!GroovyObject.class.isAssignableFrom(domainClass.getJavaClass())) return false; final PersistentProperty versionProperty = domainClass.getVersion(); final boolean isVersion = versionProperty != null && versionProperty.equals(property); return !constrained.hasAppliedConstraint(ConstrainedProperty.NULLABLE_CONSTRAINT) && isConstrainableProperty(property, propertyName) && !isVersion; }
@Override public void convertArguments(PersistentEntity persistentEntity) { ConversionService conversionService = persistentEntity .getMappingContext().getConversionService(); String propertyName = this.propertyName; PersistentProperty<?> prop = persistentEntity .getPropertyByName(propertyName); Object[] arguments = this.arguments; convertArgumentsForProp(persistentEntity, prop, propertyName, arguments, conversionService); } }
protected void initializeJoinStatus() { Boolean cachedStatus = JOIN_STATUS_CACHE.get(entity.getName()); if(cachedStatus != null) hasJoins = cachedStatus; else { for(Association a : entity.getAssociations()) { if( a.getFetchStrategy() == FetchType.EAGER ) hasJoins = true; } } }
protected void storeDateCreatedAndLastUpdatedInfo(PersistentEntity persistentEntity) { if(persistentEntity.isInitialized()) { ClassMapping<?> classMapping = persistentEntity.getMapping(); Entity mappedForm = classMapping.getMappedForm(); if(mappedForm == null || mappedForm.isAutoTimestamp()) { storeTimestampAvailability(entitiesWithDateCreated, persistentEntity, persistentEntity.getPropertyByName(DATE_CREATED_PROPERTY)); storeTimestampAvailability(entitiesWithLastUpdated, persistentEntity, persistentEntity.getPropertyByName(LAST_UPDATED_PROPERTY)); } } else { uninitializedEntities.add(persistentEntity.getName()); } }
/** * Obtains a mapping object for the given domain class nam * * @param domainClass The domain class in question * @return A Mapping object or null */ public static Mapping getMapping(PersistentEntity domainClass) { return domainClass == null ? null : MAPPING_CACHE.get(domainClass.getJavaClass()); }
public FieldEntityReflector(PersistentEntity entity) { this.entity = entity; PersistentProperty identity = entity.getIdentity(); dirtyCheckingStateField = ReflectionUtils.findField(entity.getJavaClass(), getTraitFieldName(DirtyCheckable.class, "$changedProperties")); if(dirtyCheckingStateField != null) { ReflectionUtils.makeAccessible(dirtyCheckingStateField); ClassPropertyFetcher cpf = ClassPropertyFetcher.forClass(entity.getJavaClass()); if(identity != null) { String identityName = identity.getName(); PersistentProperty[] composite = entity.getCompositeIdentity(); if(composite != null) { for (PersistentProperty property : composite) { List<PersistentProperty> properties = entity.getPersistentProperties(); readers = new PropertyReader[properties.size()]; writers = new PropertyWriter[properties.size()];
final List<PersistentProperty> properties = domainClass.getPersistentProperties(); Table table = component.getOwner().getTable(); PersistentClass persistentClass = component.getOwner(); String path = property.getName(); Class<?> propertyType = property.getOwner().getJavaClass(); if (currentGrailsProp.equals(domainClass.getIdentity())) continue; if (currentGrailsProp.getName().equals(GormProperties.VERSION)) continue;
public void convertArguments(PersistentEntity persistentEntity) { ConversionService conversionService = persistentEntity .getMappingContext().getConversionService(); PersistentProperty<?> prop = persistentEntity .getPropertyByName(propertyName); if (prop == null) { if (propertyName.equals(persistentEntity.getIdentity().getName())) { prop = persistentEntity.getIdentity();
final NativeEntryModifyingEntityAccess entityAccess = (NativeEntryModifyingEntityAccess) createEntityAccess(persistentEntity, obj, tmp); K k = readObjectIdentifier(entityAccess, persistentEntity.getMapping()); entityAccess.setNativeEntry(e); final List<PersistentProperty> props = persistentEntity.getPersistentProperties(); final Map<Association, List<Serializable>> toManyKeys = new HashMap<Association, List<Serializable>>(); final Map<OneToMany, Serializable> inverseCollectionUpdates = new HashMap<OneToMany, Serializable>(); Class associationType = associatedEntity.getJavaClass(); persistentCollection = getPersistentCollection(associatedObjects, associationType); entityAccess.setPropertyNoConversion(oneToMany.getName(), persistentCollection);
Object resolvePropertyValue(PersistentEntity entity, String property, Object value) { PersistentProperty persistentProperty = entity.getPropertyByName(property); Object resolved; if(persistentProperty instanceof Embedded) { resolved = value; } else { resolved = resolveIdIfEntity(value); } return resolved; }
@SuppressWarnings("unchecked") public Object proxy(Serializable key) { PersistentEntity entity = getPersistentEntity(); PersistentProperty identity = entity.getIdentity(); if(identity != null) { key = (Serializable) mappingContext.getConversionService().convert(key, identity.getType()); } return getProxyFactory().createProxy(session, entity.getJavaClass(), key); }
if(entity.isMultiTenant()) { if(datastore == null) { datastore = GormEnhancer.findDatastore(entity.getJavaClass()); TenantId tenantId = entity.getTenantId(); if(tenantId != null) { Serializable currentId; AbstractPersistenceEvent preInsertEvent = (AbstractPersistenceEvent) event; PersistentEntity entity = preInsertEvent.getEntity(); if(entity.isMultiTenant()) { TenantId tenantId = entity.getTenantId(); if(datastore == null) { datastore = GormEnhancer.findDatastore(entity.getJavaClass());
private static void convertArgumentsForProp(PersistentEntity persistentEntity, PersistentProperty<?> prop, String propertyName, Object[] arguments, ConversionService conversionService) { if (prop == null) { if (propertyName.equals(persistentEntity.getIdentity().getName())) { prop = persistentEntity.getIdentity(); } } if (prop != null) { Class<?> type = prop.getType(); Collection<?> collection = (Collection<?>) arguments[0]; List<Object> converted; if(collection == null) { converted = Collections.emptyList(); } else { converted = new ArrayList<>(collection.size()); for (Object o : collection) { if (o != null && !type.isAssignableFrom(o.getClass())) { o = conversionService.convert(o, type); } converted.add(o); } } arguments[0] = converted; } } }
if(entity != null) { properties = entity.getPersistentProperties(); if (properties != null) { PersistentProperty version = entity.getVersion(); if (canPropertyBeConstrained(p) && !p.equals(version)) { if (mappedForm.isDerived()) { ConstrainedProperty cp = constrainedProperties.get(propertyName); if (cp == null) { DefaultConstrainedProperty constrainedProperty = new DefaultConstrainedProperty(entity.getJavaClass(), propertyName, p.getType(), constraintRegistry); cp = constrainedProperty; constrainedProperty.setOrder(constrainedProperties.size() + 1);
public NativeEntryEntityPersister(MappingContext mappingContext, PersistentEntity entity, Session session, ApplicationEventPublisher publisher) { super(mappingContext, entity, session, publisher); classMapping = entity.getMapping(); }
throw new DatastoreConfigurationException("Default sort for associations ["+property.getOwner().getName()+"->" + property.getName() + "] are not supported with unidirectional one to many relationships."); PersistentProperty propertyToSortBy = referenced.getPropertyByName(propConfig.getSort()); String associatedClassName = property.getAssociatedEntity().getName(); boolean tablePerSubclass = m != null && !m.getTablePerHierarchy(); if (referenced != null && !referenced.isRoot() && !tablePerSubclass) { Mapping rootMapping = getRootMapping(referenced); String discriminatorColumnName = RootClass.DEFAULT_DISCRIMINATOR_COLUMN_NAME; if(referenced != null && referenced.isMultiTenant()) { String filterCondition = getMultiTenantFilterCondition(sessionFactoryBeanName, referenced); if(filterCondition != null) { LOG.debug("[GrailsDomainBinder] Mapping other side " + otherSide.getOwner().getName() + "." + otherSide.getName() + " -> " + collection.getCollectionTable().getName() + " as ManyToOne"); ManyToOne element = new ManyToOne(mappings, collection.getCollectionTable()); bindManyToMany((Association)otherSide, element, mappings, sessionFactoryBeanName);
protected void logCascadeMapping(Association grailsProperty, String cascadeStrategy, PersistentEntity referenced) { if (LOG.isDebugEnabled() & referenced != null) { String assType = getAssociationDescription(grailsProperty); LOG.debug("Mapping cascade strategy for " + assType + " property " + grailsProperty.getOwner().getName() + "." + grailsProperty.getName() + " referencing type [" + referenced.getJavaClass().getName() + "] -> [CASCADE: " + cascadeStrategy + "]"); } }
private void registerEntityWithContext(PersistentEntity entity) { persistentEntities.remove(entity); persistentEntities.add(entity); persistentEntitiesByName.put(entity.getName(), entity); }