@Override public boolean equals(Object o) { if (o == null || !(o instanceof PersistentEntity)) return false; if (this == o) return true; PersistentEntity other = (PersistentEntity) o; return javaClass.equals(other.getJavaClass()); }
/** * 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()); }
@Override public PropertyWriter getPropertyWriter(String name) { final PropertyWriter writer = writerMap.get(name); if(writer != null) { return writer; } else { throw new IllegalArgumentException("Property ["+name+"] is not a valid property of " + entity.getJavaClass()); } }
public TPCacheAdapter<T> getTPCacheAdapter(PersistentEntity entity) { if (entity == null) { return null; } return adapters.get(entity.getJavaClass().getName()); }
protected Mapping getRootMapping(PersistentEntity referenced) { if (referenced == null) return null; Class<?> current = referenced.getJavaClass(); while (true) { Class<?> superClass = current.getSuperclass(); if (Object.class.equals(superClass)) break; current = superClass; } return getMapping(current); }
@Override public FastClass fastClass() { if(fastClass == null) { fastClass = FastClass.create(entity.getJavaClass()); } return fastClass; }
protected AbstractPersistentCollection(Serializable associationKey, Session session, AssociationQueryExecutor indexer, Collection collection) { this.session = session; this.associationKey = associationKey; this.indexer = indexer; this.collection = collection; this.childType = indexer.getIndexedEntity().getJavaClass(); }
public AssociationQueryProxyHandler(Session session, AssociationQueryExecutor executor, Serializable associationKey) { super(executor.getIndexedEntity().getJavaClass()); this.session = session; this.executor = executor; this.associationKey = associationKey; }
public Collection getCachedCollection(PersistentEntity entity, Serializable key, String name) { if(isStateless(entity)) return null; if (key == null || name == null) { return null; } return firstLevelCollectionCache.get( new CollectionKey(entity.getJavaClass(), key, name)); }
public Object getCachedEntry(PersistentEntity entity, Serializable key, boolean forDirtyCheck) { if(isStateless(entity)) return null; if (key == null) { return null; } return getEntryCache(entity.getJavaClass(), forDirtyCheck).get(key); }
public void cacheCollection(PersistentEntity entity, Serializable key, Collection collection, String name) { if(isStateless(entity)) return; if (key == null || collection == null || name == null) { return; } firstLevelCollectionCache.put( new CollectionKey(entity.getJavaClass(), key, name), collection); }
public void cacheEntry(PersistentEntity entity, Serializable key, Object entry) { if(isStateless(entity)) return; if (key == null || entry == null) { return; } cacheEntry(key, entry, getEntryCache(entity.getJavaClass(), true), true); cacheEntry(key, entry, getEntryCache(entity.getJavaClass(), false), false); }
@Override public Object clone() { Session session = getSession(); if(session == null) throw new IllegalStateException("Cannot clone a stateless query"); Query newQuery = session.createQuery(entity.getJavaClass()); for (Criterion criterion : criteria.getCriteria()) { newQuery.add(criterion); } return newQuery; }
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; }
public static org.hibernate.criterion.DetachedCriteria getHibernateDetachedCriteria(QueryableCriteria<?> queryableCriteria) { org.hibernate.criterion.DetachedCriteria detachedCriteria = org.hibernate.criterion.DetachedCriteria.forClass( queryableCriteria.getPersistentEntity().getJavaClass()); populateHibernateDetachedCriteria(detachedCriteria, queryableCriteria); return detachedCriteria; }
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 boolean isComponentPropertyNullable(PersistentProperty componentProperty) { if (componentProperty == null) return false; final PersistentEntity domainClass = componentProperty.getOwner(); final Mapping mapping = getMapping(domainClass.getJavaClass()); return !domainClass.isRoot() && (mapping == null || mapping.isTablePerHierarchy()) || componentProperty.isNullable(); }
@Override public <T, K extends Serializable> T createProxy(Session session, AssociationQueryExecutor<K, T> executor, K associationKey) { MethodHandler mi = createMethodHandler(session, executor, associationKey); Class proxyClass = getProxyClass(executor.getIndexedEntity().getJavaClass()); Object proxy = ReflectionUtils.instantiate(proxyClass); ((ProxyObject)proxy).setHandler(mi); return (T) proxy; }
@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); }
@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(); }