/** * Create a new entity manager around the given broker. */ protected EntityManagerImpl newEntityManagerImpl(Broker broker) { return new EntityManagerImpl(this, broker); }
public OpenJPAQuery createQuery(Query query) { if (query == null) return createQuery((String) null); assertNotCloseInvoked(); org.apache.openjpa.kernel.Query q = ((QueryImpl) query).getDelegate(); return newQueryImpl(_broker.newQuery(q.getLanguage(), q), null); }
public boolean containsAll(Object... entities) { for (Object entity : entities) if (!contains(entity)) return false; return true; }
public OpenJPAQuery createNativeQuery(String query) { validateSQL(query); return createQuery(QueryLanguages.LANG_SQL, query); }
public void lock(Object entity, LockModeType mode, int timeout) { assertNotCloseInvoked(); assertValidAttchedEntity(LOCK, entity); configureCurrentFetchPlan(pushFetchPlan(), null, mode, false); try { _broker.lock(entity, MixedLockLevelsHelper.toLockLevel(mode), timeout, this); } finally { popFetchPlan(); } }
public void lock(Object entity) { assertNotCloseInvoked(); assertValidAttchedEntity(LOCK, entity); _broker.lock(entity, this); }
PreparedQueryCache cache = _em.getPreparedQueryCache(); if (cache == null) { return false; if (alreadyCached && LANG_PREPARED_SQL.equals(lang)) { PreparedQuery pq = _em.getPreparedQuery(_id); if (pq.isInitialized()) { try { Map rep = pq.reparametrize(params, _em.getBroker()); params.clear(); params.putAll(rep); } catch (UserException ue) { invalidatePreparedQuery(); Log log = _em.getConfiguration().getLog(OpenJPAConfiguration.LOG_RUNTIME); if (log.isWarnEnabled()) log.warn(ue.getMessage());
/** * Ignores this query from PreparedQueryCache by recreating the original * query if it has been cached. */ void ignorePreparedQuery() { PreparedQuery cached = _em.getPreparedQuery(_id); if (cached == null) return; Broker broker = _em.getBroker(); // Critical assumption: Only JPQL queries are cached and more // importantly, the identifier of the prepared query is the original // JPQL String String JPQL = JPQLParser.LANG_JPQL; String jpql = _id; org.apache.openjpa.kernel.Query newQuery = broker.newQuery(JPQL, jpql); newQuery.getFetchConfiguration().copy(_query.getFetchConfiguration()); newQuery.compile(); _query = new DelegatingQuery(newQuery, _em.getExceptionTranslator()); }
public OpenJPAQuery<X> removeFilterListener(FilterListener listener) { _em.assertNotCloseInvoked(); _query.removeFilterListener(listener); return this; }
public FlushModeType getFlushMode() { assertNotCloseInvoked(); _broker.assertOpen(); return fromFlushBeforeQueries(_broker.getFetchConfiguration(). getFlushBeforeQueries()); }
public OpenJPAQuery setFlushMode(FlushModeType flushMode) { _em.assertNotCloseInvoked(); _query.getFetchConfiguration().setFlushBeforeQueries (EntityManagerImpl.toFlushBeforeQueries(flushMode)); return this; }
public OpenJPAQuery createNativeQuery(String query, String mappingName) { assertNotCloseInvoked(); validateSQL(query); org.apache.openjpa.kernel.Query kernelQuery = _broker.newQuery( QueryLanguages.LANG_SQL, query); kernelQuery.setResultMapping(null, mappingName); return new QueryImpl(this, ret, kernelQuery); }
public OpenJPAQuery createQuery(Query query) { if (query == null) return createQuery((String) null); assertNotCloseInvoked(); org.apache.openjpa.kernel.Query q = ((QueryImpl) query).getDelegate(); return new QueryImpl(this, ret, _broker.newQuery(q.getLanguage(), q)); }
@SuppressWarnings("unchecked") public <T> T[] findAll(Class<T> cls, Object... oids) { if (oids.length == 0) return (T[]) Array.newInstance(cls, 0); Collection<T> ret = findAll(cls, Arrays.asList(oids)); return ret.toArray((T[]) Array.newInstance(cls, ret.size())); }
public OpenJPAQuery createQuery(String query) { return createQuery(JPQLParser.LANG_JPQL, query); }
public FlushModeType getFlushMode() { return EntityManagerImpl.fromFlushBeforeQueries(_query. getFetchConfiguration().getFlushBeforeQueries()); }
public void evictAll(Object... entities) { evictAll(Arrays.asList(entities)); }
/** * Return the underlying broker for the given entity manager facade. */ public static Broker toBroker(EntityManager em) { if (em == null) return null; if (!(em instanceof EntityManagerImpl)) { Class c = em.getClass(); try { // either cast here may fail em = (EntityManagerImpl) ((OpenJPAEntityManager) em). getUserObject(EM_KEY); } catch (ClassCastException cce) { throw new ArgumentException(_loc.get("cant-convert-broker", c), new Throwable[] { cce }, null, false); } } return ((EntityManagerImpl) em).getBroker(); }
@SuppressWarnings("unchecked") public <T> TypedQuery<T> createNamedQuery(String name, Class<T> resultClass) { checkTuple(resultClass); return createNamedQuery(name).setResultClass(resultClass); }
@SuppressWarnings("unchecked") public <T> TypedQuery<T> createQuery(String query, Class<T> resultClass) { checkTuple(resultClass); return createQuery(query).setResultClass(resultClass); }