@Override public final Query createNamedQuery(String name) { checkClosed(); checkTransactionNeeded(); return getPersistenceDelegator().createQuery(name); }
@Override public final void close() { clear(); getPersistenceDelegator().close(); this.closed = true; }
@Override public <T> TypedQuery<T> createNamedQuery(String paramString, Class<T> paramClass) { Query q = createNamedQuery(paramString); return onTypedQuery(paramClass, q); }
@Override public <T> TypedQuery<T> createQuery(String paramString, Class<T> paramClass) { Query q = createQuery(paramString); return onTypedQuery(paramClass, q); }
/** * Remove the entity instance. * * @param entity * @throws IllegalArgumentException * if the instance is not an entity or is a detached entity * @throws TransactionRequiredException * if invoked on a container-managed entity manager of type * PersistenceContextType.TRANSACTION and there is no * transaction */ @Override public final void remove(Object e) { checkClosed(); checkTransactionNeeded(); try { getPersistenceDelegator().remove(e); } catch (Exception ex) { // on rollback. doRollback(); throw new KunderaException(ex); } }
@Override public final Object getDelegate() { checkClosed(); return getPersistenceDelegator().getDelegate(); }
public <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties) checkClosed(); checkTransactionNeeded(); Map<String, Object> currentProperties = getProperties(); getPersistenceDelegator().populateClientProperties(properties); T result = find(entityClass, primaryKey); getPersistenceDelegator().populateClientProperties(currentProperties); return result;
/** * Instantiates a new entity manager impl. * * @param factory * the factory * @param properties * the properties */ EntityManagerImpl(final EntityManagerFactory factory, final Map properties, PersistenceUnitTransactionType transactionType, final PersistenceContextType persistenceContextType) { this(factory, transactionType, persistenceContextType); this.properties = properties; getPersistenceDelegator().populateClientProperties(this.properties); }
public void refresh(Object entity, Map<String, Object> properties) checkClosed(); Map<String, Object> currentProperties = getProperties(); getPersistenceDelegator().populateClientProperties(properties); refresh(entity); getPersistenceDelegator().populateClientProperties(currentProperties);
@Override public final Query createNativeQuery(String sqlString) { checkClosed(); return getPersistenceDelegator().createQuery(sqlString, getPersistenceUnit()); }
private void checkTransactionNeeded() { onLookUp(transactionType); if ((getPersistenceContextType() != PersistenceContextType.TRANSACTION) || (getPersistenceDelegator().isTransactionInProgress())) { return; } throw new TransactionRequiredException( "no transaction is in progress for a TRANSACTION type persistence context"); }
/** * Set an entity manager property or hint. If a vendor-specific property or * hint is not recognized, it is silently ignored. * * @param propertyName * name of property or hint * @param value * @throws IllegalArgumentException * if the second argument is not valid for the implementation * @see javax.persistence.EntityManager#setProperty(java.lang.String, * java.lang.Object) */ @Override public void setProperty(String paramString, Object paramObject) { checkClosed(); if (getProperties() == null) { this.properties = new HashMap<String, Object>(); } this.properties.put(paramString, paramObject); getPersistenceDelegator().populateClientProperties(this.properties); }
@Override public EntityManagerFactory getEntityManagerFactory() { checkClosed(); return this.factory; }
@Override public CriteriaBuilder getCriteriaBuilder() { checkClosed(); return getEntityManagerFactory().getCriteriaBuilder(); }
@Override public <T> TypedQuery<T> createQuery(CriteriaQuery<T> paramCriteriaQuery) { checkClosed(); return this.createQuery(CriteriaQueryTranslator.translate(paramCriteriaQuery), paramCriteriaQuery.getResultType()); }
/** * Instantiates a new entity manager impl. * * @param factory * the factory */ EntityManagerImpl(final EntityManagerFactory factory, final PersistenceUnitTransactionType transactionType, final PersistenceContextType persistenceContextType) { this.factory = factory; if (logger.isDebugEnabled()) { logger.debug("Creating EntityManager for persistence unit : " + getPersistenceUnit()); } this.persistenceContextType = persistenceContextType; this.persistenceCache = new PersistenceCache((Cache) factory.getCache()); this.persistenceCache.setPersistenceContextType(this.persistenceContextType); this.transactionType = transactionType; this.persistenceDelegator = new PersistenceDelegator( ((EntityManagerFactoryImpl) this.factory).getKunderaMetadataInstance(), this.persistenceCache); for (String pu : ((EntityManagerFactoryImpl) this.factory).getPersistenceUnits()) { this.persistenceDelegator.loadClient(pu, discoverClient(pu)); } if (logger.isDebugEnabled()) { logger.debug("Created EntityManager for persistence unit : " + getPersistenceUnit()); } }
/** * Create a new application-managed EntityManager. This method returns a new * EntityManager instance each time it is invoked. The isOpen method will * return true on the returned instance. * * @return entity manager instance * @throws IllegalStateException * if the entity manager factory has been closed */ @Override public final EntityManager createEntityManager() { // For Application managed persistence context, type is always EXTENDED if (isOpen()) { return new EntityManagerImpl(this, transactionType, PersistenceContextType.EXTENDED); } throw new IllegalStateException("Entity manager factory has been closed."); }
/** * Merge the state of the given entity into the current persistence context. * * @param entity * @return the managed instance that the state was merged to * @throws IllegalArgumentException * if instance is not an entity or is a removed entity * @throws TransactionRequiredException * if invoked on a container-managed entity manager of type * PersistenceContextType.TRANSACTION and there is no * transaction * @see javax.persistence.EntityManager#merge(java.lang.Object) */ @Override public final <E> E merge(E e) { checkClosed(); checkTransactionNeeded(); try { return getPersistenceDelegator().merge(e); } catch (Exception ex) { // on Rollback doRollback(); throw new KunderaException(ex); } }
@Override public final void setFlushMode(FlushModeType flushMode) { checkClosed(); this.flushMode = flushMode; getPersistenceDelegator().setFlushMode(flushMode); }
@Override public void rollback() { onTransaction(TxAction.ROLLBACK); ((EntityManagerImpl) entityManager).getPersistenceDelegator().rollback(); }