<p>applyPageList.</p>

@param queryParams a {@link javax.ws.rs.core.MultivaluedMap} object.
@param query       a {@link io.ebean.Query} object.
@return a {@link io.ebean.FutureRowCount} object.
168835
public static FutureRowCount applyPageList(MultivaluedMap<String, String> queryParams, Query query) {

        FutureRowCount futureRowCount = fetchRowCount(queryParams, query);

        applyPageConfig(queryParams, query);

        return futureRowCount;
    }
981533
public static Query setParameter(Query query, QueryParameterWrap parameterWrap){
		setBasicParameter(query, parameterWrap);
		setPageParameter(query, parameterWrap.getPageable());
		setResultTransformerType(query, parameterWrap.getResultTransformerType());
		return query;
	}
879660
protected void applyQueryFilter(Map<String, Object> params, QueryFilter queryFilter) {
    	if (queryFilter != null) {
    	    applyQueryContext(params, queryFilter);
        	if (queryFilter.getFilterParams() != null && !queryFilter.getFilterParams().isEmpty()) {
        		params.put(FILTER, queryFilter.getFilterParams());
        		for(String key : queryFilter.getParams().keySet()){
                    params.put(key, queryFilter.getParams().get(key));
                }
        	}
        }
    }
557471
public void init(final MultivaluedMap<String, String> queryParameters) {
        final String scopeCompileParam = queryParameters.getFirst(ServerAPI.SCOPE_COMPILE_PARAM);
        if(scopeCompileParam != null){
            this.scopeComp = Boolean.valueOf(scopeCompileParam);
        }
        final String scopeProvidedParam = queryParameters.getFirst(ServerAPI.SCOPE_PROVIDED_PARAM);
        if(scopeProvidedParam != null){
            this.scopePro = Boolean.valueOf(scopeProvidedParam);
        }
        final String scopeRuntimeParam = queryParameters.getFirst(ServerAPI.SCOPE_RUNTIME_PARAM);
        if(scopeRuntimeParam != null){
            this.scopeRun = Boolean.valueOf(scopeRuntimeParam);
        }
        final String scopeTestParam = queryParameters.getFirst(ServerAPI.SCOPE_TEST_PARAM);
        if(scopeTestParam != null){
            this.scopeTest = Boolean.valueOf(scopeTestParam);
        }
    }
903184
protected void bind(EbeanQueryWrapper query, Parameter parameter, Object value, int position) {
        if (parameter.isNamedParameter()) {
            query.setParameter(parameter.getName().get(), value);
        } else {
            query.setParameter(position, value);
        }
    }
913126
@SuppressWarnings(UNCHECKED)
    protected List<E> list(Query query)
    {
        return new ArrayList<E>(query.list());
    }
668790
@Override
    public synchronized List<Map<String, ResultColumn>> query(final String query) throws DatabaseEngineException {
        return processResultIterator(iterator(query));
    }
716892
public static Query setPageParameter(Query query, Pageable pageable){
		if( notNull( pageable ) ){
			query.setFirstResult( (pageable.getPageNumber()-1) * pageable.getPageSize() );
			query.setMaxResults(pageable.getPageSize());
		}
		return query;
	}
1136322
private Param getQueryParam(List<Param> optionalParams) {
		for (Param p : optionalParams) {
			if (p == null) {
				continue;
			}
			
			if (p.getType().equals(ParamEnum.QUERY.name)) {
				return p;
			}
		}

		return null;
	}
1183551
public static HashMap<String, String> getParameters(String query) {
        HashMap<String, String> params = new HashMap<String, String>();
        if (query == null || query.length() == 0) {
            return params;
        }

        String[] splitQuery = query.split("&");
        for (String splitItem : splitQuery) {
            String[] items = splitItem.split("=");

            if (items.length == 1) {
                params.put(items[0], "");
            } else {
                params.put(items[0], items[1]);
            }
        }

        return params;
    }
351770
private <K, C> Iterator<Column<C>> executePaginated(final RowQuery<K, C> query) {
        return Iterators.concat(new AbstractIterator<Iterator<Column<C>>>() {
            @Override
            protected Iterator<Column<C>> computeNext() {
                ColumnList<C> page = execute(query);
                return !page.isEmpty() ? page.iterator() : endOfData();
            }
        });
    }
289881
public List<SearchResult> search(String query) throws MovieMeterException {
        String url = buildSearchUrl(query);

        try {
            return mapper.readValue(requestWebPage(url), new TypeReference<List<SearchResult>>() {
            });
        } catch (IOException ex) {
            throw new MovieMeterException(ApiExceptionType.MAPPING_FAILED, "Failed to map search results", url, ex);
        }
    }
450086
protected MultivaluedMap<String, String> getPageQueryParams(int page, int perPage) {
        return (new GitLabApiForm().withParam(PAGE_PARAM, page).withParam(PER_PAGE_PARAM, perPage).asMap());
    }
458434
public static <T> ExpressionList<T> applyWhere(ExpressionList<T> expressionList, Object queryObject) {
        if (queryObject != null) {
            Class clz = queryObject.getClass();
            Field[] fields = clz.getDeclaredFields();
            for (Field field : fields) {
                field.setAccessible(true);
                String param = field.getName();
                Object value = null;
                try {
                    value = field.get(queryObject);
                } catch (Exception e) {
                    e.printStackTrace();
                    break;
                }
                ExprType exprType = ExprType.DEFAULT;
                boolean ignoreCase = false;
                boolean escapeNull = true;
                boolean isString = field.getType() == String.class;
                boolean isArray = field.getType().isArray();
                if (field.isAnnotationPresent(ExprParam.class)) {
                    ExprParam exprParam = field.getAnnotation(ExprParam.class);
                    String qpv = exprParam.value();
                    String qpn = exprParam.name();
                    exprType = exprParam.expr();
                    ignoreCase = exprParam.ignoreCase();
                    escapeNull = exprParam.escapeNull();
                    if (escapeNull && value == null) {
                        break;
                    }
                    if (StringUtils.hasText(qpv)) {
                        param = qpv;
                    }
                    if (StringUtils.hasText(qpn)) {
                        param = qpn;
                    }
                }
                switch (exprType) {
                    case EQ:
                        if (isString && ignoreCase) {
                            expressionList.add(Expr.ieq(param, (String) value));
                        } else {
                            expressionList.add(Expr.eq(param, value));
                        }
                        break;
                    case NE:
                        expressionList.add(Expr.ne(param, value));
                        break;
                    case GE:
                        expressionList.add(Expr.ge(param, value));
                        break;
                    case GT:
                        expressionList.add(Expr.gt(param, value));
                        break;
                    case LE:
                        expressionList.add(Expr.le(param, value));
                        break;
                    case LT:
                        expressionList.add(Expr.lt(param, value));
                        break;
                    case LIKE:
                        if (isString) {
                            if (ignoreCase) {
                                expressionList.add(Expr.ilike(param, (String) value));
                            } else {
                                expressionList.add(Expr.like(param, (String) value));
                            }
                        }
                        break;
                    case STARTS_WITH:
                        if (isString) {
                            if (ignoreCase) {
                                expressionList.add(Expr.istartsWith(param, (String) value));
                            } else {
                                expressionList.add(Expr.startsWith(param, (String) value));
                            }
                        }
                        break;
                    case ENDS_WITH:
                        if (isString) {
                            if (ignoreCase) {
                                expressionList.add(Expr.iendsWith(param, (String) value));
                            } else {
                                expressionList.add(Expr.endsWith(param, (String) value));
                            }
                        }
                        break;
                    case CONTAINS:
                        if (isString) {
                            if (ignoreCase) {
                                expressionList.add(Expr.icontains(param, (String) value));
                            } else {
                                expressionList.add(Expr.contains(param, (String) value));
                            }
                        }
                        break;
                    case IN:
                        if (isArray) {
                            expressionList.add(Expr.in(param, (Object[]) value));
                        }
                    default:
                        if (isString) {
                            if (ignoreCase) {
                                expressionList.add(Expr.icontains(param, (String) value));
                            } else {
                                expressionList.add(Expr.contains(param, (String) value));
                            }
                        } else {
                            expressionList.add(Expr.eq(param, value));
                        }
                        break;
                }

            }
        }
        return expressionList;
    }
1052291
public <T> List<T> search(org.beangle.commons.dao.query.Query<T> query) {
    if (query instanceof LimitQuery) {
      org.beangle.commons.dao.query.LimitQuery<T> limitQuery = (org.beangle.commons.dao.query.LimitQuery<T>) query;
      if (null == limitQuery.getLimit()) {
        return QuerySupport.find(limitQuery, getSession());
      } else {
        return new SinglePage<T>(limitQuery.getLimit().getPageIndex(), limitQuery.getLimit().getPageSize(),
            QuerySupport.count(limitQuery, getSession()), QuerySupport.find(query, getSession()));
      }
    } else {
      return QuerySupport.find(query, getSession());
    }
  }
519051
public List<T> handle(List<QueryParameters> outputList) throws MjdbcException {
        List<T> result = new ArrayList<T>();
        String parameterName = null;
        Object parameterValue = null;

        for (int i = 1; i < outputList.size(); i++) {
            if (this.columnName == null) {
                parameterName = outputList.get(i).getNameByPosition(this.columnIndex);
                parameterValue = outputList.get(i).getValue(parameterName);

                result.add((T) parameterValue);
            } else {
                parameterValue = outputList.get(i).getValue(this.columnName);

                result.add((T) parameterValue);
            }

        }

        return result;
    }
1030842
@SuppressWarnings({ "unchecked" })
    private Predicate convertParametersToPredicate(Root<?> from, CriteriaQuery<?> query) {
        List<Predicate> predicates = new ArrayList<>();
        for (Map.Entry<String, Set<Object>> value : request.getParameters().entrySet()) {
            Subquery<JPAEntry> subquery = buildJPAEntrySubquery(value.getKey(), value.getValue(), from, query);
            predicates.add(builder.exists(subquery));
        }
        if (request.isAndJoined()) {
            return builder.and(Iterables.toArray(predicates, Predicate.class));
        } else {
            return builder.or(Iterables.toArray(predicates, Predicate.class));
        }
    }