org.apache.deltaspike.data.api.QueryResult Java Examples

@Override
public <X> QueryResult<T> changeOrder(final SingularAttribute<T, X> attribute)
{
    changeOrder(new ChangeOrder()
    {
        @Override
        public boolean matches(OrderByQueryStringPostProcessor orderBy)
        {
            return orderBy.matches(attribute);
        }

        @Override
        public void addDefault()
        {
            orderAsc(attribute);
        }
    });
    return this;
}
 

public QueryProcessor build(RepositoryMethodMetadata methodMetadata)
{
    if (ClassUtils.returns(methodMetadata.getMethod(), QueryResult.class))
    {
        return noOp;
    }
    
    if (ClassUtils.returns(methodMetadata.getMethod(), List.class))
    {
        return listResult;
    }
    
    if (methodMetadata.isReturnsStream())
    {
        return streamResult;
    }
    
    if (isModifying(methodMetadata))
    {
        return executeUpdate;
    }

    return singleResult;
}
 

@Override
public QueryResult<T> changeOrder(final String attribute)
{
    changeOrder(new ChangeOrder()
    {
        @Override
        public boolean matches(OrderByQueryStringPostProcessor orderBy)
        {
            return orderBy.matches(attribute);
        }

        @Override
        public void addDefault()
        {
            orderAsc(attribute);
        }
    });
    return this;
}
 

@Test
public void should_paginate_with_orderby()
{
    // given
    SimpleStringIdBuilder builder = new SimpleStringIdBuilder(getEntityManager());


    final String name = "should_paginate_with_orderby";
    final String name2 = "should_paginate_with_orderby2";
    builder.createSimple("a", name);
    builder.createSimple("b", name2);

    // when
    QueryResult<SimpleStringId> allOrderByNamePaginate = repo.findAllOrderByIdPaginate(0, 10);

    // then
    assertNotNull(allOrderByNamePaginate);

    List<SimpleStringId> resultList = allOrderByNamePaginate.getResultList();
    assertEquals(2, resultList.size());
    assertEquals("a", resultList.get(0).getId());
    assertEquals("b", resultList.get(1).getId());
}
 

@Test
public void should_change_sort_order()
{
    // given
    final String name = "testChangeSortOrder";
    builder.createSimple(name, Integer.valueOf(99));
    builder.createSimple(name, Integer.valueOf(22));
    builder.createSimple(name, Integer.valueOf(229));

    // when
    QueryResult<Simple> query = repo.findByName(name);
    List<Simple> result1 = query
            .changeOrder(Simple_.counter)
            .getResultList();
    List<Simple> result2 = query
            .changeOrder(Simple_.counter)
            .getResultList();

    // then
    assertEquals(22, result1.get(0).getCounter().intValue());
    assertEquals(229, result2.get(0).getCounter().intValue());
}
 

@Test
public void should_page_with_page_api()
{
    // given
    final String name = "testPageAPI";
    builder.createSimple(name, Integer.valueOf(22));
    builder.createSimple(name, Integer.valueOf(56));
    builder.createSimple(name, Integer.valueOf(99));
    builder.createSimple(name, Integer.valueOf(123));
    builder.createSimple(name, Integer.valueOf(229));
    builder.createSimple(name, Integer.valueOf(299));
    builder.createSimple(name, Integer.valueOf(389));

    // when
    QueryResult<Simple> pagedQuery = repo
            .findByName(name)
            .withPageSize(2);
    List<Simple> result1 = pagedQuery.getResultList();
    List<Simple> result2 = pagedQuery.nextPage().nextPage().getResultList();
    int current = pagedQuery.currentPage();
    List<Simple> result3 = pagedQuery.toPage(1).getResultList();
    int total = pagedQuery.countPages();
    int pageSize = pagedQuery.pageSize();

    // then
    assertEquals(2, result1.size());
    assertEquals(2, result2.size());
    assertEquals(2, result3.size());
    assertEquals(2, current);
    assertEquals(4, total);
    assertEquals(2, pageSize);

    assertEquals(22, result1.get(0).getCounter().intValue());
    assertEquals(229, result2.get(0).getCounter().intValue());
    assertEquals(99, result3.get(0).getCounter().intValue());

}
 

@Override
public QueryResult<T> orderDesc(String attribute, boolean appendEntityName)
{
    context.addQueryStringPostProcessor(new OrderByQueryStringPostProcessor(attribute, OrderDirection.DESC,
            appendEntityName));
    return this;
}
 

@Override
public <X> QueryResult<T> orderDesc(SingularAttribute<T, X> attribute, boolean appendEntityName)
{
    context.addQueryStringPostProcessor(new OrderByQueryStringPostProcessor(attribute, OrderDirection.DESC,
            appendEntityName));
    return this;
}
 

@Override
public QueryResult<T> orderAsc(String attribute, boolean appendEntityName)
{
    context.addQueryStringPostProcessor(new OrderByQueryStringPostProcessor(attribute, OrderDirection.ASC,
            appendEntityName));
    return this;
}
 

@Override
public <X> QueryResult<T> orderAsc(SingularAttribute<T, X> attribute, boolean appendEntityName)
{
    context.addQueryStringPostProcessor(new OrderByQueryStringPostProcessor(attribute, OrderDirection.ASC,
            appendEntityName));
    return this;
}
 

@Test
public void should_clear_sort_order()
{
    // given
    final String name = "testClearSortOrder";
    builder.createSimple(name, Integer.valueOf(99));
    builder.createSimple(name, Integer.valueOf(22));
    builder.createSimple(name, Integer.valueOf(229));

    // when
    QueryResult<Simple> query = repo.findByName(name);
    List<Simple> result1 = query
            .changeOrder(Simple_.counter)
            .getResultList();
    List<Simple> result2 = query
            .clearOrder()
            .getResultList();

    // then
    assertEquals(result1.size(), result2.size());
    for (int i = 0; i < result1.size(); i++)
    {
        int count1 = result1.get(i).getCounter().intValue();
        int count2 = result2.get(i).getCounter().intValue();
        if (count1 != count2)
        {
            return;
        }
    }
    fail("Both collections sorted: " + result1 + "," + result2);
}
 

public QueryBuilder build(RepositoryMethodMetadata methodMetadata, CdiQueryInvocationContext context)
{
    QueryBuilder builder = getQueryBuilder(context.getRepositoryMethodMetadata().getMethodType());

    if (QueryResult.class.equals(methodMetadata.getMethod().getReturnType()))
    {
        return new WrappedQueryBuilder(builder);
    }

    return builder;
}
 

/**
 * Finds a set of entries from database with given filter, starting from
 * given row. The "page size" (aka max results limit passed for the query)
 * is 45.
 *
 * @param filter the filters string
 * @param firstRow the first row to be fetched
 * @param maxresults maximum number of results
 * @return
 */
public List<PhoneBookEntry> getEntriesPaged(String filter, int firstRow, int maxresults, List<QuerySortOrder> sortOrder) {
    QueryResult<PhoneBookEntry> qr = entryRepo.findByNameLikeIgnoreCase("%" + filter + "%");
    for (QuerySortOrder qso : sortOrder) {
        if(qso.getDirection() == SortDirection.ASCENDING) {
            qr = qr.orderAsc(qso.getSorted());
        } else {
            qr = qr.orderDesc(qso.getSorted());
        }
    }
    return qr
            .firstResult(firstRow).maxResults(maxresults)
            .getResultList();
}
 

@Override
public QueryResult<T> clearOrder()
{
    for (Iterator<QueryStringPostProcessor> it = context.getQueryStringPostProcessors().iterator(); it.hasNext();)
    {
        if (it.next() instanceof OrderByQueryStringPostProcessor)
        {
            it.remove();
        }
    }
    return this;
}
 

@Override
public QueryResult<T> maxResults(int max)
{
    context.addJpaQueryPostProcessor(new MaxResultPostProcessor(max));
    pageSize = max;
    return this;
}
 

@Override
public QueryResult<T> toPage(int page)
{
    this.page = page;
    return firstResult(pageSize * page);
}
 

@Override
public QueryResult<T> nextPage()
{
    page = page + 1;
    return firstResult(pageSize * page);
}
 

@Query("select e from Simple e where e.name = ?1")
QueryResult<SimpleDto> findByNameToo(String name);
 

@Override
public QueryResult<T> previousPage()
{
    page = page > 0 ? page - 1 : page;
    return firstResult(pageSize * page);
}
 

@Query("select s from Simple s where s.name = ?1 order by s.counter desc")
public abstract QueryResult<Simple> findByQueryWithOrderBy(String name);
 

@Query(named = Simple.BY_NAME_LIKE)
public abstract QueryResult<Simple> queryResultWithNamed(String name);
 

@Query("select s from Simple s")
public abstract QueryResult<Simple> queryAll();
 

@Query(named = SimpleStringId.FIND_ALL_ORDER_BY_ID)
public abstract QueryResult<SimpleStringId> findAllOrderByIdPaginate(@FirstResult int start, @MaxResults int pageSize);
 

public QueryResult findByCompanyAndNameLikeIgnoreCase(Company company,
String string);
 

@Override
public QueryResult<T> withPageSize(int pageSize)
{
    return maxResults(pageSize);
}
 

@Override
public QueryResult<T> firstResult(int first)
{
    context.addJpaQueryPostProcessor(new FirstResultPostProcessor(first));
    return this;
}
 

@Override
public QueryResult<T> orderDesc(String attribute)
{
    return orderDesc(attribute, true);
}
 

@Override
public <X> QueryResult<T> orderDesc(SingularAttribute<T, X> attribute)
{
    return orderDesc(attribute, true);
}
 

@Override
public QueryResult<T> orderAsc(String attribute)
{
    return orderAsc(attribute, true);
}
 

@Override
public <X> QueryResult<T> orderAsc(SingularAttribute<T, X> attribute)
{
    return orderAsc(attribute, true);
}