Java Code Examples for javax.persistence.TypedQuery#getResultList()

public List<T> getAll(MultivaluedMap<String, String> queryParameters) {
      final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      final CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(entityClass);
      Root<T> root = criteriaQuery.from(entityClass);
      Predicate[] predicates = extractPredicates(queryParameters, criteriaBuilder, root);
      criteriaQuery.select(criteriaQuery.getSelection()).where(predicates);
      criteriaQuery.orderBy(criteriaBuilder.asc(root.get("id")));
      TypedQuery<T> query = entityManager.createQuery(criteriaQuery);
      if (queryParameters.containsKey("first")) {
      	Integer firstRecord = Integer.parseInt(queryParameters.getFirst("first"))-1;
      	query.setFirstResult(firstRecord);
      }
      if (queryParameters.containsKey("maxResults")) {
      	Integer maxResults = Integer.parseInt(queryParameters.getFirst("maxResults"));
      	query.setMaxResults(maxResults);
      }
return query.getResultList();
  }
 

@Override
public Optional<T> findOne() {
    EntityManager em = database.em();
    try {
        TypedQuery<T> query = em.createQuery(sql.selectSQL(), entityClass);
        for (int i = 0; i < params.size(); i++) {
            query.setParameter(i, params.get(i));
        }
        query.setFirstResult(0);
        query.setMaxResults(1);
        List<T> results = query.getResultList();
        if (results.isEmpty()) {
            return Optional.empty();
        }
        return Optional.of(results.get(0));
    } finally {
        em.close();
    }
}
 

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;
    }
 

@Override
public List<DeptEmployee> filterbyTitleUsingExpression(List<String> titles) {
    CriteriaQuery<DeptEmployee> criteriaQuery = createCriteriaQuery(DeptEmployee.class);
    Root<DeptEmployee> root = criteriaQuery.from(DeptEmployee.class);
    criteriaQuery.select(root)
        .where(root.get("title")
            .in(titles));
    TypedQuery<DeptEmployee> query = entityManager.createQuery(criteriaQuery);
    return query.getResultList();
}
 

@Override
public List<ClientModel> getAlwaysDisplayInConsoleClients(RealmModel realm) {
    TypedQuery<String> query = em.createNamedQuery("getAlwaysDisplayInConsoleClients", String.class);
    query.setParameter("realm", realm.getId());
    List<String> clients = query.getResultList();
    if (clients.isEmpty()) return Collections.EMPTY_LIST;
    List<ClientModel> list = new LinkedList<>();
    for (String id : clients) {
        ClientModel client = session.realms().getClientById(id, realm);
        if (client != null) list.add(client);
    }
    return Collections.unmodifiableList(list);
}
 

/**
 * Returns a List of all link sources of <code>to</code> and a special
 * <code>type</code>
 *
 * @param to
 *            Destination-ID
 * @param type
 *            Link reference type, this can be null. Current types are
 *            child, classid, parent, reference and derivate.
 * @return List of Strings (Source-IDs)
 */
@Override
public Collection<String> getSourcesOf(String to, String type) {
    boolean withType = type != null && type.trim().length() != 0;
    EntityManager em = MCREntityManagerProvider.getCurrentEntityManager();
    TypedQuery<String> toQuery = em.createNamedQuery(
        withType ? "MCRLINKHREF.getSourcesWithType" : "MCRLINKHREF.getSources", String.class);
    toQuery.setParameter("to", to);
    if (withType) {
        toQuery.setParameter("type", type);
    }
    return toQuery.getResultList();
}
 

@Override
public void deleteRoleMapping(RoleModel role) {
    if (group == null || role == null) return;

    TypedQuery<GroupRoleMappingEntity> query = getGroupRoleMappingEntityTypedQuery(role);
    query.setLockMode(LockModeType.PESSIMISTIC_WRITE);
    List<GroupRoleMappingEntity> results = query.getResultList();
    if (results.size() == 0) return;
    for (GroupRoleMappingEntity entity : results) {
        em.remove(entity);
    }
    em.flush();
}
 

protected List<Book> queryBooks(String expression,
                              Map<String, String> visitorProps,
                              Map<String, String> parserBinProps,
                              List<String> joinProps) throws Exception {
    SearchCondition<Book> filter = getParser(visitorProps, parserBinProps)
        .parse(expression);
    SearchConditionVisitor<Book, TypedQuery<Book>> jpa =
        new JPATypedQueryVisitor<Book>(em, Book.class, visitorProps, joinProps);
    filter.accept(jpa);
    TypedQuery<Book> query = jpa.getQuery();
    return query.getResultList();
}
 

@Test
public final void whenSortingFooWithCriteria_thenPrintSortedFoos() {
    final CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    final CriteriaQuery<Foo> criteriaQuery = criteriaBuilder.createQuery(Foo.class);
    final Root<Foo> from = criteriaQuery.from(Foo.class);
    final CriteriaQuery<Foo> select = criteriaQuery.select(from);
    criteriaQuery.orderBy(criteriaBuilder.asc(from.get("name")));
    final TypedQuery<Foo> typedQuery = entityManager.createQuery(select);
    final List<Foo> fooList = typedQuery.getResultList();
    for (final Foo foo : fooList) {
        System.out.println("Name:" + foo.getName() + "--------Id:" + foo.getId());
    }
}
 

@Transactional(readOnly = true)
@Override
public List<Report> findAll() {
    TypedQuery<Report> query = entityManager().createQuery(
            "SELECT e FROM " + JPAReport.class.getSimpleName() + " e", Report.class);

    return query.getResultList();
}
 

public List<Piece> getPiecesInRange(DateTime start, DateTime end) {
    TypedQuery<Piece> query = getEntityManager().createQuery("SELECT p FROM Piece p WHERE p.generationTime > :start AND p.generationTime < :end", Piece.class);
    query.setParameter("start", start);
    query.setParameter("end", end);

    return query.getResultList();
}
 

public void readUserTable(EntityManager entityManager) {
	TypedQuery<UserEntity> query = entityManager.createQuery("from UserEntity", UserEntity.class);
	List<UserEntity> resultList = query.getResultList();
	if (false) {
		resultList.stream()
				.forEach(user -> LOGGER.info(user.getId() + " " + user.getName() + " " + user.getEmail()));
		new UserEntity().findAll(entityManager).stream()
				.forEach(user -> LOGGER.info(user.getId() + " " + user.getName() + " " + user.getEmail()));
	}
}
 

@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();
}
 

@Override
public Set<FederatedIdentityModel> getFederatedIdentities(String userId, RealmModel realm) {
    TypedQuery<BrokerLinkEntity> query = em.createNamedQuery("findBrokerLinkByUser", BrokerLinkEntity.class)
            .setParameter("userId", userId);
    List<BrokerLinkEntity> results = query.getResultList();
    Set<FederatedIdentityModel> set = new HashSet<>();
    for (BrokerLinkEntity entity : results) {
        FederatedIdentityModel model = new FederatedIdentityModel(entity.getIdentityProvider(), entity.getBrokerUserId(), entity.getBrokerUserName(), entity.getToken());
        set.add(model);
    }
    return set;
}
 

@Transactional(readOnly = true)
@Override
public List<AccessToken> findAll(final int page, final int itemsPerPage, final List<OrderByClause> orderByClauses) {
    StringBuilder queryString = buildFindAllQuery().append(toOrderByStatement(orderByClauses));

    TypedQuery<AccessToken> query = entityManager().createQuery(queryString.toString(), AccessToken.class);

    query.setFirstResult(itemsPerPage * (page <= 0 ? 0 : page - 1));

    if (itemsPerPage > 0) {
        query.setMaxResults(itemsPerPage);
    }

    return query.getResultList();
}
 

private List<ADynGroupMembership> findWithADynMemberships(final AnyType anyType) {
    TypedQuery<ADynGroupMembership> query = entityManager().createQuery(
            "SELECT e FROM " + JPAADynGroupMembership.class.getSimpleName() + " e  WHERE e.anyType=:anyType",
            ADynGroupMembership.class);
    query.setParameter("anyType", anyType);
    return query.getResultList();
}
 

@Transactional
@Cacheable("users")
@Override
public List<Login> getusers() {
	//EntityManager entityManagerFactory = entityManagerFactory.createEntityManager();
	String qlString = "SELECT l FROM Login l";
	TypedQuery<Login> query = entityManagerFactory.createQuery(qlString, Login.class);	
	List<Login> login = query.getResultList();
	
	return login;
}
 

@Transactional
public LocalStorageCapacityRecalculator calculateTotalCapacity(String psUuid) {
    final long totalCapacity;
    final long availableCapacity;
    final long totalPhysicalCapacity;
    final long availablePhysicalCapacity;

    String sql = "select sum(ref.totalCapacity)," +
            " sum(ref.availableCapacity)," +
            " sum(ref.totalPhysicalCapacity)," +
            " sum(ref.availablePhysicalCapacity)" +
            " from LocalStorageHostRefVO ref" +
            " where ref.primaryStorageUuid = :psUuid" +
            " group by ref.primaryStorageUuid";
    TypedQuery<Tuple> q = dbf.getEntityManager().createQuery(sql, Tuple.class);
    q.setParameter("psUuid", psUuid);
    List<Tuple> resultList =  q.getResultList();

    if (resultList != null && !resultList.isEmpty()) {
        Tuple ts = resultList.get(0);
        totalCapacity = ts.get(0) == null ? 0 : ts.get(0, Long.class);
        availableCapacity = ts.get(1) == null ? 0 : ts.get(1, Long.class);
        totalPhysicalCapacity = ts.get(2) == null ? 0 : ts.get(2, Long.class);
        availablePhysicalCapacity = ts.get(3) == null ? 0 : ts.get(3, Long.class);
    } else {
        // LocalStorage not mounted
        // Cluster no host
        totalCapacity = 0;
        totalPhysicalCapacity = 0;
        availablePhysicalCapacity = 0;

        Long used = SQL.New("select sum(ref.size)" +
                " from LocalStorageResourceRefVO ref" +
                " where ref.primaryStorageUuid = :psUuid")
                .param("psUuid", psUuid).find();

        availableCapacity = used != null ? totalCapacity - used : 0;
    }

    PrimaryStorageCapacityUpdater pupdater = new PrimaryStorageCapacityUpdater(psUuid);
    pupdater.run(new PrimaryStorageCapacityUpdaterRunnable() {
        @Override
        public PrimaryStorageCapacityVO call(PrimaryStorageCapacityVO cap) {
            cap.setTotalCapacity(totalCapacity);
            cap.setAvailableCapacity(availableCapacity);
            cap.setTotalPhysicalCapacity(totalPhysicalCapacity);
            cap.setAvailablePhysicalCapacity(availablePhysicalCapacity);
            return cap;
        }
    });

    return this;
}
 

public List<Room> getGroupRooms(long groupId) {
	TypedQuery<Room> q = em.createNamedQuery("getGroupRooms", Room.class);
	q.setParameter("groupId", groupId);
	return q.getResultList();
}
 

@Override
public List<ReportTemplate> findAll() {
    TypedQuery<ReportTemplate> query = entityManager().createQuery(
            "SELECT e FROM " + JPAReportTemplate.class.getSimpleName() + " e", ReportTemplate.class);
    return query.getResultList();
}