/** * Find multiple objects. * * @deprecated use {@link Queries#named} findAll(EntityManager, String, Object[]) */ @Deprecated public static <A> List<A> findAll(EntityManager em, final String queryName, final Tuple<String, ?>... params) { return createNamedQuery(em, queryName, params).getResultList(); }
/** * Shortcut for <code>newPersistenceEnvironment(newEntityManagerFactory(cc, emName, persistenceProps))</code>. * * @see #newEntityManagerFactory(org.osgi.service.component.ComponentContext, String, java.util.Map) */ public static PersistenceEnv newPersistenceEnvironment(ComponentContext cc, String emName, Map persistenceProps) { return newPersistenceEnvironment(newEntityManagerFactory(cc, emName, persistenceProps)); }
/** * Create a new persistence environment based on an entity manager factory backed by an in-memory H2 database for * testing purposes. * * @param emName * name of the persistence unit (see META-INF/persistence.xml) * @deprecated use {@link PersistenceEnvs#testPersistenceEnv(String)} */ @Deprecated public static PersistenceEnv newTestPersistenceEnv(String emName) { return newPersistenceEnvironment(newTestEntityManagerFactory(emName)); } }
/** * Create a new entity manager factory backed by an in-memory H2 database for testing purposes. * * @param emName * name of the persistence unit (see META-INF/persistence.xml) */ public static EntityManagerFactory newTestEntityManagerFactory(String emName) { Map<String, String> persistenceProperties = new HashMap<>(); persistenceProperties.put("eclipselink.ddl-generation", "create-tables"); persistenceProperties.put("eclipselink.ddl-generation.output-mode", "database"); return newEntityManagerFactory(emName, "Auto", "org.h2.Driver", "jdbc:h2:./target/db" + System.currentTimeMillis(), "sa", "sa", persistenceProperties, testPersistenceProvider()); }
/** * Shortcut for <code>newPersistenceEnvironment(newEntityManagerFactory(cc, emName, persistenceProps))</code>. * * @see PersistenceUtil#newEntityManagerFactory(org.osgi.service.component.ComponentContext, String, java.util.Map) */ public static PersistenceEnv persistenceEnvironment(ComponentContext cc, String emName, Map persistenceProps) { return persistenceEnvironment(newEntityManagerFactory(cc, emName, persistenceProps)); }
/** * Create a new persistence environment based on an entity manager factory backed by an in-memory H2 database for * testing purposes. * * @param emName * name of the persistence unit (see META-INF/persistence.xml) */ public static PersistenceEnv testPersistenceEnv(String emName) { return persistenceEnvironment(newTestEntityManagerFactory(emName)); } }
/** Create a new persistence environment. This method is the preferred way of creating a persitence environment. */ public static PersistenceEnv newPersistenceEnvironment(PersistenceProvider persistenceProvider, String emName, Map persistenceProps) { return newPersistenceEnvironment(persistenceProvider.createEntityManagerFactory(emName, persistenceProps)); }
/** * Find a single object. * * @param params * the query parameters * @param toA * map to the desired result object * @deprecated */ @Deprecated public static <A, B> Option<A> find(EntityManager em, final Function<B, A> toA, final String queryName, final Tuple<String, ?>... params) { return PersistenceUtil.<B> runSingleResultQuery(em, queryName, params).map(toA); }
/** * Test if a connection to the given data source can be established. * * @return none, if the connection could be established */ public static Option<SQLException> testConnection(DataSource ds) { Connection connection = null; try { connection = ds.getConnection(); return none(); } catch (SQLException e) { return some(e); } finally { closeQuietly(connection); } }
@Override public <A> A tx(Function<EntityManager, A> transactional) { for (final EntityManager em : createEntityManager(emf)) { final EntityTransaction tx = em.getTransaction(); try { tx.begin(); emStore.set(Option.<Transactional>some(new Transactional() { @Override public <A> A tx(Function<EntityManager, A> transactional) { return transactional.apply(em); } })); A ret = transactional.apply(em); tx.commit(); return ret; } catch (Exception e) { if (tx.isActive()) { tx.rollback(); } // propagate exception return chuck(e); } finally { if (em.isOpen()) em.close(); emStore.remove(); } } return chuck(new IllegalStateException("EntityManager is already closed")); } };
/** * Shortcut for <code>persistenceEnvironment(newEntityManagerFactory(cc, emName))</code>. * * @see PersistenceUtil#newEntityManagerFactory(org.osgi.service.component.ComponentContext, String) */ public static PersistenceEnv persistenceEnvironment(ComponentContext cc, String emName) { return persistenceEnvironment(newEntityManagerFactory(cc, emName)); }
/** * Run an update (UPDATE or DELETE) query and ensure that at least one row got affected. * * @deprecated use {@link Queries#named} #update(EntityManager, String, Object[]) */ @Deprecated public static boolean runUpdate(EntityManager em, String queryName, Tuple<String, ?>... params) { return createNamedQuery(em, queryName, params).executeUpdate() > 0; }
/** * Shortcut for <code>newPersistenceEnvironment(newEntityManagerFactory(cc, emName))</code>. * * @see #newEntityManagerFactory(org.osgi.service.component.ComponentContext, String) */ public static PersistenceEnv newPersistenceEnvironment(ComponentContext cc, String emName) { return newPersistenceEnvironment(newEntityManagerFactory(cc, emName)); }
/** * Execute a <code>COUNT(x)</code> query. * * @deprecated use {@link Queries#named} count(EntityManager, String, Object[]) */ @Deprecated public static long runCountQuery(EntityManager em, String queryName, Tuple<String, ?>... params) { return ((Number) createNamedQuery(em, queryName, params).getSingleResult()).longValue(); }
/** * Find multiple objects with optional pagination. * * @deprecated use {@link Queries#named} findAll(EntityManager, String, Option, Option, Object[]) */ @Deprecated public static <A> List<A> findAll(EntityManager em, final String queryName, Option<Integer> offset, Option<Integer> limit, final Tuple<String, ?>... params) { final Query q = createNamedQuery(em, queryName, params); for (Integer x : offset) q.setFirstResult(x); for (Integer x : limit) q.setMaxResults(x); return q.getResultList(); }
/** * Run a query that should return the first result of it. * * @deprecated use {@link Queries#named} findFirst(EntityManager, String, Object[]) */ @Deprecated public static <A> Option<A> runFirstResultQuery(EntityManager em, String queryName, Tuple<String, ?>... params) { try { return some((A) createNamedQuery(em, queryName, params).setMaxResults(1).getSingleResult()); } catch (NoResultException e) { return none(); } catch (NonUniqueResultException e) { return none(); } }
/** * Find multiple objects. * * @param params * the query parameters * @param toA * map to the desired result object * @deprecated use {@link Queries#named} findAll(EntityManager, String, Object[]) instead */ @Deprecated public static <A, B> List<A> findAll(EntityManager em, final Function<B, A> toA, final String queryName, final Tuple<String, ?>... params) { return mlist((List<B>) createNamedQuery(em, queryName, params).getResultList()).map(toA).value(); }
/** * Run a query (SELECT) that should return a single result. * * @deprecated use {@link Queries#named} #findSingle(EntityManager, String, Object[]) */ @Deprecated public static <A> Option<A> runSingleResultQuery(EntityManager em, String queryName, Tuple<String, ?>... params) { try { return some((A) createNamedQuery(em, queryName, params).getSingleResult()); } catch (NoResultException e) { return none(); } catch (NonUniqueResultException e) { return none(); } }
/** * Find multiple objects with optional pagination. * * @param params * the query parameters * @param toA * map to the desired result object * @deprecated use {@link Queries#named} findAll(EntityManager, String, Option, Option, Object[]) instead */ @Deprecated public static <A, B> List<A> findAll(EntityManager em, final Function<B, A> toA, Option<Integer> offset, Option<Integer> limit, final String queryName, final Tuple<String, ?>... params) { final Query q = createNamedQuery(em, queryName, params); for (Integer x : offset) q.setFirstResult(x); for (Integer x : limit) q.setMaxResults(x); return mlist((List<B>) q.getResultList()).map(toA).value(); }