@Override public PersistentEntity getParentEntity() { Class superclass = this.javaClass.getSuperclass(); if( superclass != null ) { return context.getPersistentEntity(superclass.getName()); } return null; }
public AbstractCriteriaBuilder(final Class targetClass, QueryCreator queryCreator, final MappingContext mappingContext) { Assert.notNull(targetClass, "Argument [targetClass] cannot be null"); Assert.notNull(mappingContext, "Argument [session] cannot be null"); persistentEntity = mappingContext.getPersistentEntity( targetClass.getName()); if (persistentEntity == null) { throw new IllegalArgumentException("Class [" + targetClass.getName() + "] is not a persistent entity"); } this.targetClass = targetClass; this.queryCreator = queryCreator; }
private PersistentEntity getPersistentEntity(Class javaClass, MappingContext context, ClassMapping classMapping) { if (classMapping != null) { return classMapping.getEntity(); } return context.getPersistentEntity(javaClass.getName()); }
@Override protected Persister createPersister(Class cls, MappingContext mappingContext) { PersistentEntity entity = mappingContext.getPersistentEntity(cls.getName()); if (entity == null) { return null; } return new SimpleMapEntityPersister(mappingContext, entity, this, (SimpleMapDatastore) getDatastore(), publisher); }
public List retrieveAll(final Class type, final Iterable keys) { final PersistentEntity persistentEntity = getMappingContext().getPersistentEntity(type.getName()); return hibernateTemplate.execute(new HibernateCallback<List>() { public List doInHibernate(org.hibernate.Session session) throws HibernateException, SQLException { Criteria criteria = session.createCriteria(type); hibernateTemplate.applySettings(criteria); return criteria.add( Restrictions.in(persistentEntity.getIdentity().getName(), getIterableAsCollection(keys))) .list(); } }); }
protected void cascadeDeleteCollection(EntityAccess entityAccess, Association association) { Object propValue = entityAccess.getProperty(association.getName()); if (!(propValue instanceof Collection)) { return; } Collection collection = ((Collection) propValue); for (Iterator iter = collection.iterator(); iter.hasNext(); ) { Object child = iter.next(); deleteEntity(getMappingContext().getPersistentEntity(child.getClass().getName()), child); iter.remove(); } }
public boolean isCached(Class type, Serializable key) { PersistentEntity entity = getMappingContext().getPersistentEntity(type.getName()); if (type == null || key == null || isStateless(entity)) { return false; } return getInstanceCache(type).containsKey(key); }
public void cacheInstance(Class type, Serializable key, Object instance) { if (type == null || key == null || instance == null) { return; } if(isStateless(getMappingContext().getPersistentEntity(type.getName()))) return; getInstanceCache(type).put(key, instance); }
private Serializable findInstanceId(Object value) { MappingContext ctx = entity.getMappingContext(); PersistentEntity pe = ctx.getPersistentEntity(value.getClass().getName()); return ctx.getEntityReflector(pe).getIdentifier(value); }
private static PersistentEntity getDomainClass(Object instance) { PersistentEntity domainClass = null; if(!Environment.isInitializing()) { final GrailsApplication grailsApplication = Holders.findApplication(); if (grailsApplication != null) { try { domainClass = grailsApplication.getMappingContext().getPersistentEntity(instance.getClass().getName()); } catch (GrailsConfigurationException e) { //no-op } } } return domainClass; }
public Object getCachedInstance(Class type, Serializable key) { if(isStateless()) return null; if (type == null || key == null) { return null; } if(isStateless(getMappingContext().getPersistentEntity(type.getName()))) return null; return getInstanceCache(type).get(key); }
protected AbstractPersistenceEvent(final Datastore source, final Object entity) { super(source); MappingContext mappingContext = source.getMappingContext(); entityObject = mappingContext.getProxyHandler().unwrap(entity); this.entity = mappingContext.getPersistentEntity(entityObject.getClass().getName()); if(this.entity != null) { this.entityAccess = mappingContext.createEntityAccess(this.entity, entityObject); } else { this.entityAccess = null; } }
public Query createQuery(Class type) { final PersistentEntity persistentEntity = getMappingContext().getPersistentEntity(type.getName()); final Criteria criteria = hibernateTemplate.getSessionFactory().getCurrentSession().createCriteria(type); hibernateTemplate.applySettings(criteria); return new HibernateQuery(criteria, this, persistentEntity); }
/** * Tries to obtain or create an associated entity. Note that if #canExpandMappingContext is set to false then this method may return null * * @param entity The main entity * @param context The context * @param propType The associated property type * @return The associated entity or null */ protected PersistentEntity getOrCreateAssociatedEntity(PersistentEntity entity, MappingContext context, Class propType) { PersistentEntity associatedEntity = context.getPersistentEntity(propType.getName()); if (associatedEntity == null) { if(canExpandMappingContext) { if (entity.isExternal()) { associatedEntity = context.addExternalPersistentEntity(propType); } else { associatedEntity = context.addPersistentEntity(propType); } } } else { if(!associatedEntity.isInitialized()) { associatedEntity.initialize(); } } return associatedEntity; }
private static void autowire(Object instance) { if(!Environment.isInitializing()) { GrailsApplication application = Holders.findApplication(); if(application != null) { try { PersistentEntity domainClass = application.getMappingContext().getPersistentEntity(instance.getClass().getName()); if(domainClass != null) { if (domainClass.getMapping().getMappedForm().isAutowire()) { final ApplicationContext applicationContext = Holders.findApplicationContext(); if (applicationContext != null) { applicationContext .getAutowireCapableBeanFactory() .autowireBeanProperties(instance, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, false); } } } } catch (GrailsConfigurationException e) { // ignore, Mapping Context not initialized yet } } } } }
/** * @see org.grails.datastore.mapping.model.MappingConfigurationStrategy#getIdentity(Class, org.grails.datastore.mapping.model.MappingContext) */ public PersistentProperty getIdentity(Class javaClass, MappingContext context) { ClassPropertyFetcher cpf = ClassPropertyFetcher.forClass(javaClass); PersistentEntity entity = context.getPersistentEntity(javaClass.getName()); ClassMapping mapping = entity.getMapping(); IdentityMapping id = mapping.getIdentifier(); final String[] names = id.getIdentifierName(); if (names.length == 1) { final PropertyDescriptor pd = cpf.getPropertyDescriptor(names[0]); if (pd != null) { return propertyFactory.createIdentity(entity, context, pd); } if (!entity.isExternal() && isAbstract(entity)) { throw new IllegalMappingException("Mapped identifier [" + names[0] + "] for class [" + javaClass.getName() + "] is not a valid property"); } return null; } return null; }
protected Criteria getCriteria(HibernateDatastore datastore, GrailsApplication appliation, Session session, DetachedCriteria detachedCriteria, Closure additionalCriteria, Class<?> clazz) { if (additionalCriteria != null) { HibernateCriteriaBuilder builder = new HibernateCriteriaBuilder(clazz, session.getSessionFactory()); builder.setGrailsApplication(appliation); return builder.buildCriteria(additionalCriteria); } Criteria criteria = session.createCriteria(clazz); if (detachedCriteria != null) { HibernateSession hibernateSession = new HibernateSession(datastore, session.getSessionFactory()); PersistentEntity persistentEntity = datastore.getMappingContext().getPersistentEntity(clazz.getName()); if (persistentEntity != null) { DynamicFinder.applyDetachedCriteria(new HibernateQuery(criteria, hibernateSession, persistentEntity), detachedCriteria); } } hibernateTemplate.applySettings(criteria); return criteria; }
private void activateDirtyChecking(Object entity) { if(entity instanceof DirtyCheckable && proxyHandler.isInitialized(entity)) { PersistentEntity persistentEntity = mappingContext.getPersistentEntity(Hibernate.getClass(entity).getName()); entity = proxyHandler.unwrap(entity); DirtyCheckable dirtyCheckable = (DirtyCheckable) entity; Map<String, Object> dirtyCheckingState = persistentEntity.getReflector().getDirtyCheckingState(entity); if(dirtyCheckingState == null) { dirtyCheckable.trackChanges(); for (Embedded association : persistentEntity.getEmbedded()) { if(DirtyCheckable.class.isAssignableFrom(association.getType())) { Object embedded = association.getReader().read(entity); if(embedded != null) { DirtyCheckable embeddedCheck = (DirtyCheckable) embedded; if(embeddedCheck.listDirtyPropertyNames().isEmpty()) { embeddedCheck.trackChanges(); } } } } } } }
public boolean onPreInsert(PreInsertEvent hibernateEvent) { Object entity = hibernateEvent.getEntity(); Class type = Hibernate.getClass(entity); PersistentEntity persistentEntity = mappingContext.getPersistentEntity(type.getName()); AbstractPersistenceEvent grailsEvent; ModificationTrackingEntityAccess entityAccess = null; if(persistentEntity != null) { entityAccess = new ModificationTrackingEntityAccess(mappingContext.createEntityAccess(persistentEntity, entity)); grailsEvent = new org.grails.datastore.mapping.engine.event.PreInsertEvent(this.datastore, persistentEntity, entityAccess); } else { grailsEvent = new org.grails.datastore.mapping.engine.event.PreInsertEvent(this.datastore, entity); } publishEvent(hibernateEvent, grailsEvent); boolean cancelled = grailsEvent.isCancelled(); if(!cancelled && entityAccess != null) { synchronizeHibernateState(hibernateEvent, entityAccess); } return cancelled; }
public boolean onPreUpdate(PreUpdateEvent hibernateEvent) { Object entity = hibernateEvent.getEntity(); Class type = Hibernate.getClass(entity); MappingContext mappingContext = datastore.getMappingContext(); PersistentEntity persistentEntity = mappingContext.getPersistentEntity(type.getName()); AbstractPersistenceEvent grailsEvent; ModificationTrackingEntityAccess entityAccess = null; if(persistentEntity != null) { entityAccess = new ModificationTrackingEntityAccess(mappingContext.createEntityAccess(persistentEntity, entity)); grailsEvent = new org.grails.datastore.mapping.engine.event.PreUpdateEvent(this.datastore, persistentEntity, entityAccess); } else { grailsEvent = new org.grails.datastore.mapping.engine.event.PreUpdateEvent(this.datastore, entity); } publishEvent(hibernateEvent, grailsEvent); boolean cancelled = grailsEvent.isCancelled(); if(!cancelled && entityAccess != null) { synchronizeHibernateState(hibernateEvent, entityAccess); } return cancelled; }