java类javax.persistence.TypedQuery的实例源码

public static Certifications getByName(String name) {
    if (name != null && !name.isEmpty()) {
        EntityManager em = EMFUtil.getEMFactory().createEntityManager();
        String query = "SELECT cert from Certifications cert where cert.certification = :name";

        try {
            TypedQuery<Certifications> q = em.createQuery(query, Certifications.class);
            q.setParameter("name", name);
            return q.getSingleResult();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            em.close();
        }
    }
    return null;
}

public List<PlayerDetails> getPlayersByPositionAndName(String position, String name) {
    logger.info("getPlayersByPositionAndName");
    List<Player> players = null;

    try {
        CriteriaQuery<Player> cq = cb.createQuery(Player.class);
        if (cq != null) {
            Root<Player> player = cq.from(Player.class);

            // Get MetaModel from Root
            //EntityType<Player> Player_ = player.getModel();

            // set the where clause
            cq.where(cb.equal(player.get(Player_.position), position),
                    cb.equal(player.get(Player_.name), name));
            cq.select(player).distinct(true);
            TypedQuery<Player> q = em.createQuery(cq);
            players = q.getResultList();
        }
        return copyPlayersToDetails(players);
    } catch (Exception ex) {
        throw new EJBException(ex);
    }
}

@Override
@TransactionAttribute(TransactionAttributeType.MANDATORY)
public Date loadPriceModelStartDate(long priceModelKeyForSubscription) {
    TypedQuery<PriceModelHistory> query = dm.createNamedQuery(
            "PriceModelHistory.findByObjectAndProvisioningCompleted",
            PriceModelHistory.class);
    query.setParameter("objKey", Long.valueOf(priceModelKeyForSubscription));
    query.setParameter("provisioningCompleted", Boolean.TRUE);

    List<PriceModelHistory> resultList = query.getResultList();
    if (resultList.isEmpty()) {
        throw new BillingRunFailed(
                "History data is missing for price model with key "
                        + priceModelKeyForSubscription);
    }

    return resultList.get(0).getModdate();
}

public List<PlayerDetails> getAllPlayers() {
    logger.info("getAllPlayers");
    List<Player> players = null;

    try {
        CriteriaQuery<Player> cq = cb.createQuery(Player.class);
        if (cq != null) {
            Root<Player> player = cq.from(Player.class);

            cq.select(player);
            TypedQuery<Player> q = em.createQuery(cq);
            players = q.getResultList();
        }
        return copyPlayersToDetails(players);
    } catch (Exception ex) {
        throw new EJBException(ex);
    }
}

private void queryButtonActionPerformed(ActionEvent e)
{
   // query that returns all contacts
   TypedQuery<Addresses> findByLastname = 
      entityManager.createNamedQuery(
         "Addresses.findByLastname", Addresses.class);

   // configure parameter for query
   findByLastname.setParameter("lastname", queryTextField.getText());
   results = findByLastname.getResultList(); // get all addresses
   numberOfEntries = results.size();

   if (numberOfEntries != 0)
   {
      currentEntryIndex = 0;
      displayRecord();
      nextButton.setEnabled(true);
      previousButton.setEnabled(true);
   } 
   else
      browseButtonActionPerformed(e);
}

public List<PublisherEntity> findAll() {
    EntityManager em = connection.createEntityManager();
    List<PublisherEntity> result;

    try {
        em.getTransaction().begin();
        TypedQuery<PublisherEntity> query = em.createQuery("Select p from PublisherEntity p", PublisherEntity.class);
        result = query.getResultList();
        em.getTransaction().commit();
    } finally {
        if (em.getTransaction().isActive()) {
            em.getTransaction().rollback();
        }
        em.close();
    }

    return result;
}

public List<TemplateFile> getTemplateFilesByControllerId(
        String controllerId) {

    TypedQuery<TemplateFile> query = em.createNamedQuery(
            "TemplateFile.getForControllerId", TemplateFile.class);
    query.setParameter("controllerId", controllerId);

    try {
        return query.getResultList();
    } catch (NoResultException e) {
        return Collections.emptyList();
    }
}

/**
 * count the number of auditLogs by operationIds and date range, if
 * operationIds is null or empty, count the number of AuditLogs only by date
 * range
 * 
 * @param operationIds
 * @param startTime
 * @param endTime
 * @return
 */
public long countAuditLogs(List<String> operationIds, long startTime,
        long endTime) {
    TypedQuery<Number> query;
    if (operationIds == null || operationIds.isEmpty()) {
        query = em.createNamedQuery("AuditLog.countByDateRange",
                Number.class);
    } else {
        query = em.createNamedQuery(
                "AuditLog.countByOperationAndDateRange", Number.class);
        query.setParameter("operationIds", operationIds);
    }
    query.setParameter("startTime", Long.valueOf(startTime));
    query.setParameter("endTime", Long.valueOf(endTime));
    return query.getSingleResult().longValue();
}

public List<BookEntity> findAll() {
    EntityManager em = connection.createEntityManager();
    List<BookEntity> result;

    try {
        em.getTransaction().begin();
        TypedQuery<BookEntity> query = em.createQuery("Select b from BookEntity b", BookEntity.class);
        result = query.getResultList();
        em.getTransaction().commit();
    } finally {
        if (em.getTransaction().isActive()) {
            em.getTransaction().rollback();
        }
        em.close();
    }

    return result;
}

public void loadAll() {

        List<DocumentDetail> ListDocumentDetail = new ArrayList<DocumentDetail>();

        Items it = new Items();
        EntityManager em = it.getEntityManager();
        TypedQuery<DocumentDetail> consultItems = em.createNamedQuery("DocumentDetail.findAll", DocumentDetail.class);
        ListDocumentDetail = consultItems.getResultList();

        ListProducts = new ArrayList<Products>();

        for (DocumentDetail selectedItem : ListDocumentDetail) {
            Products newProduct = new Products();
            newProduct.setArticulo(selectedItem.getItemId().getName());
            newProduct.setBodega(selectedItem.getWarehousesId().getName());
            if (selectedItem.getDocumentId().getTypedocId().getCode().equals("1")) {
                newProduct.setEntradas(selectedItem.getQuantity());
            } else {
                newProduct.setSallidas(selectedItem.getQuantity());

            }
            newProduct.setFecha(selectedItem.getDocumentId().getDocumentDate().toString());
            newProduct.setConsecutivo(selectedItem.getDocumentId().getConsecutive() + "");
            ListProducts.add(newProduct);
        }
    }

@Test
public void test201_Insert() throws Exception {
    em.getTransaction().begin();

    Employee e = new Employee();
    e.setEmpNo(99999);
    e.setFirstName("John");
    e.setLastName("Doe");
    e.setBirthDate(DATE_FORMATTER.parse("2008-04-12"));
    e.setGender(Gender.MALE);
    e.setHireDate(DATE_FORMATTER.parse("2016-01-30"));
    e.setSalaries(null);
    em.persist(e);

    em.getTransaction().commit();

    TypedQuery<Employee> q = em.createQuery("select e from employee e where e.empNo = :empNo", Employee.class);
    q.setParameter("empNo", 99999);
    Employee inserted = q.getSingleResult();
    Assert.assertEquals(e, inserted);
}

public Long getTaskCount(Long jobId) throws InterruptedException, VmidcException {

        try {
            EntityManager em = this.dbMgr.getTransactionalEntityManager();
            return this.dbMgr.getTransactionControl().required(() -> {

                String hql = "SELECT count(*) FROM TaskRecord WHERE job_fk = :jobId";

                TypedQuery<Long> query = em.createQuery(hql, Long.class);
                query.setParameter("jobId", jobId);
                return query.getSingleResult();
            });
        } catch (ScopedWorkException swe) {
            throw swe.as(RuntimeException.class);
        }
    }

/**
 * HQL version of the query
 */
private <T extends RouteLeg> RouteLeg findRouteLegByFromToHQL(GeoCoord from, GeoCoord to, Class clazz) throws DatabaseException {
    final String bikeQuery = "SELECT leg from BikeLeg leg WHERE leg.from = :fromGeo AND leg.to = :toGeo";
    final String carQuery = "SELECT leg from CarLeg leg WHERE leg.from = :fromGeo AND leg.to = :toGeo";

    try {
        TypedQuery<? extends RouteLeg> query;
        if (clazz == BikeLeg.class) {
            query = entityManager.createQuery(bikeQuery, BikeLeg.class);
        } else {
            query = entityManager.createQuery(carQuery, CarLeg.class);
        }

        List<? extends RouteLeg> resultList = query.setParameter("fromGeo", from)
                                                   .setParameter("toGeo", to)
                                                   .getResultList();

        return extractOne(resultList);

    } catch (IndexOutOfBoundsException e) {
        throw new DatabaseException("Could not find entity " + clazz + " for coordinates " + from + " -> " + to);
    }
}

public static Conversations getByClientAndCandidateID(int clientID, int candidateID) throws NoResultException {
    if (clientID > 0 && candidateID > 0) {
        EntityManager em = EMFUtil.getEMFactory().createEntityManager();
        String query = "SELECT c FROM Conversations c WHERE c.clientID = :clientID AND c.candidateID = :candidateID";
        try {
            TypedQuery<Conversations> q = em.createQuery(query, Conversations.class);
            q.setParameter("clientID", clientID);
            q.setParameter("candidateID", candidateID);
            Conversations conversation = q.getSingleResult();
            em.close();
            return conversation;
        } finally {
            if (em.isOpen()) {
                em.close();
            }
        }
    }
    return null;
}

@Test
   public void subSelectTest() {
StrQLBuilder jpa = StrQLBuilder.createJPQL()
    .select("p.id")
    .from("Person p")
    .where("not exists (:jpa)", StrQLBuilder.createNative()
        .select("1")
        .from("Job j")
        .where("j.id = p.id")
        .and("1 = :val", 1)
        .and("exists (:jpa2)", StrQLBuilder.createNative()
            .select("1")
            .from("Person p")
            .where("1 = :val2", 1)));
TypedQuery<Long> query = jpa.createQuery(entityManager, Long.class);
List<Long> persons = query.getResultList();
assertThat(persons, is(not(empty())));
   }

public Usuario buscarUsuario(String apelido) {
    StringBuilder sb = new StringBuilder();
    sb.append("select u from Usuario u where apelido = '").append(apelido).append("'");

    TypedQuery<Usuario> query = super.em.createQuery(sb.toString(), Usuario.class);
    try {
        return query.getSingleResult();
    } catch (NoResultException e) {
        return null;
    }
}

@SuppressWarnings("unchecked")
    @Override
    public List<User> findByEmail(String email) {
        Session session = this.sessionFactory.getCurrentSession();
        TypedQuery<User> query = session.getNamedQuery("findByEmail");  
        query.setParameter("email", email);
//      Query query = session.getNamedQuery("findByEmail");
//      query.setString("email", email);
        return query.getResultList();
    }

public static List<Candidates> getApprovalList() {
    EntityManager em = EMFUtil.getEMFactory().createEntityManager();
    String query = "SELECT candidate FROM Candidates candidate WHERE candidate.approved = 'No' OR " +
            "candidate.approved IS NULL";
    TypedQuery<Candidates> qCandidate = em.createQuery(query, Candidates.class);
    List<Candidates> candidates = qCandidate.getResultList();
    em.close();
    return candidates;
}

/**
 * Listar as transa��es j� efetivadas na conta
 * 
 * @param conta Id do Telegram
 * @param tipoTransacao Tipo de transa��o que deve ser retornada
 * 
 * @return Lista das transa��es
 */
public List<Transacao> buscarTransacoes(long conta, TipoTransacao tipoTransacao) {
    TypedQuery<Transacao> query = super.em.createQuery("select t from Transacao t where conta = " + conta + " and tipo_transacao = " + tipoTransacao.getCodigo(), Transacao.class);
    try {
        return query.getResultList();
    } catch (NoResultException e) {
        return null;
    }
}

public List<PlayerDetails> getPlayersBySalaryRange(int low, int high) {
    logger.info("getPlayersBySalaryRange");
    List<Player> players = null;

    try {
        CriteriaQuery<Player> cq = cb.createQuery(Player.class);
        if (cq != null) {
            Root<Player> player = cq.from(Player.class);

            // Get MetaModel from Root
            //EntityType<Player> Player_ = player.getModel();

            // set the where clause
            cq.where(cb.between(player.get(
                    Player_.salary),
                    (double)low,
                    (double)high));
            // set the select clause
            cq.select(player).distinct(true);
            TypedQuery<Player> q = em.createQuery(cq);
            players = q.getResultList();
        }
        return copyPlayersToDetails(players);
    } catch (Exception ex) {
        throw new EJBException(ex);
    }
}

/**
 * Creates a new count query for the given {@link Specification}.
 */
private <T> TypedQuery<Long> getCountQuery(final Class<T> entityType, final Specification<T> spec) {

    final CriteriaBuilder builder = em.getCriteriaBuilder();
    final CriteriaQuery<Long> query = builder.createQuery(Long.class);

    final Root<T> root = query.from(entityType);
    applySpecificationToCriteria(root, spec, query);
    query.select(builder.count(root));

    return em.createQuery(query);
}

@Before
public void setup() throws Exception {
    csb = new ConfigurationServiceBean();
    ds = mock(DataService.class);
    csb.dm = ds;
    query = mock(TypedQuery.class);
}

@SuppressWarnings("unchecked")
@Override
public List<User> findByEmailAndPassword(String email, String password) {
    Session session = this.sessionFactory.getCurrentSession();
    TypedQuery<User> query = session.getNamedQuery("findByEmailAndPassword");  
       query.setParameter("email", email); 
       query.setParameter("password", password);
       return query.getResultList();
}

@GET
@Produces("application/json")
public List<Person> listAll(@QueryParam("start") Integer startPosition,
        @QueryParam("max") Integer maxResult) {
    TypedQuery<Person> findAllQuery = em.createQuery(
            "SELECT DISTINCT p FROM Person p ORDER BY p.id", Person.class);
    if (startPosition != null) {
        findAllQuery.setFirstResult(startPosition);
    }
    if (maxResult != null) {
        findAllQuery.setMaxResults(maxResult);
    }
    final List<Person> results = findAllQuery.getResultList();
    return results;
}

public void getUserByUsername1() {
    String username = unknownSource();

    TypedQuery<UserEntity> q = em.createQuery(
            String.format("select * from Users where name = %s", username),
            UserEntity.class);

    UserEntity res = q.getSingleResult();
}

public static List<WeeklyStats> getAll () {
    EntityManager em = EMFUtil.getEMFactory().createEntityManager();
    String statsQuery = "SELECT stats FROM WeeklyStats stats ORDER BY stats.weeklyStatsID DESC";
    TypedQuery<WeeklyStats> qStats = em.createQuery(statsQuery, WeeklyStats.class);
    List<WeeklyStats> list = qStats.getResultList();
       em.close();
       return list;
}

@SuppressWarnings("unchecked")
@Override
public List<User> findByEmailAndPassword(String email, String password) {
    Session session = this.sessionFactory.getCurrentSession();
    TypedQuery<User> query = session.getNamedQuery("findByEmailAndPassword");  
       query.setParameter("email", email); 
       query.setParameter("password", password);
       return query.getResultList();
}

public List<Category> getAllCategories(boolean withSub){

        TypedQuery<Category> query = em.createQuery("select c from Category c", Category.class);
        List<Category> categories = query.getResultList();

        if(withSub){
            //force loading
            categories.forEach(c -> c.getSubCategories().size());
        }

        return categories;
    }

/***Supprime un client de la base de donnee***/
public void deleteClient(Integer id){
    TypedQuery<Client> query = em.createQuery("SELECT c FROM Client c WHERE c.id = :id", Client.class);
    query.setParameter("id", id);
    Client c = query.getSingleResult();

    em.remove(c);
}

public List<User> getTopUsersWithoutCounter(int n) {

        TypedQuery<User> query = em.createQuery(
                "select u from User u order by size(u.posts) + size(u.comments) DESC",
                User.class);
        query.setMaxResults(n);

        return query.getResultList();
    }