<p>fetchRowCount.</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.
542906
public static FutureRowCount fetchRowCount(MultivaluedMap<String, String> queryParams, Query query) {
        String reqTotalCount = getSingleParam(queryParams.get(REQ_TOTAL_COUNT_PARAM_NAME));
        if (reqTotalCount != null && !"false".equalsIgnoreCase(reqTotalCount) && !"0".equals(reqTotalCount)) {
            return query.findFutureCount();
        }
        return null;
    }
882880
public QueryRequestBuilder<T,ID> query(QueryExpression query)
    {
        return new QueryRequestBuilder<T, ID>(version,type,entityName,query.build());
    }
951774
public EbeanQueryWrapper bind(EbeanQueryWrapper query) {

        Assert.notNull(query, "EbeanQueryWrapper must not be null!");

        int bindableParameterIndex = 0;
        int queryParameterPosition = 1;

        for (Parameter parameter : parameters) {

            if (canBindParameter(parameter)) {

                Object value = accessor.getBindableValue(bindableParameterIndex);
                bind(query, parameter, value, queryParameterPosition++);
                bindableParameterIndex++;
            }
        }

        return query;
    }
992952
@Nonnull
  public ApiFuture<QuerySnapshot> get(@Nonnull Query query) {
    Preconditions.checkState(isEmpty(), READ_BEFORE_WRITE_ERROR_MSG);

    return query.get(transactionId);
  }
586170
public Api getQueryResult(String query) throws Exception {
    Api result = this.getActionResult("query", query, null, null);
    return result;
  }
613010
@Override
    public EbeanQueryWrapper doCreateQuery(Object[] values) {
        ParameterAccessor accessor = new ParametersParameterAccessor(getQueryMethod().getParameters(), values);

        EbeanQueryWrapper query = createEbeanQuery(this.query.getQueryString());

        return createBinder(values).bindAndPrepare(query);
    }
254112
public static FutureRowCount applyUriQuery(MultivaluedMap<String, String> queryParams,
                                               SpiQuery query,
                                               InjectionManager manager) {
        return applyUriQuery(queryParams, query, manager, true);
    }
668790
@Override
    public synchronized List<Map<String, ResultColumn>> query(final String query) throws DatabaseEngineException {
        return processResultIterator(iterator(query));
    }
802758
public final function count(string $query = null, array $queryParams = null): ?int
    {
        $queryBuilder = new QueryBuilder($this->db->getLink());
        $queryBuilder->setTable($this->table);

        if ($query || $queryParams) {
            $queryBuilder->where($query, $queryParams);
        }

        return $queryBuilder->count();
    }
204539
public ResultSetFuture executeAsync(@NotNull String keyspace, @NotNull String query) {
        Timer time = getMetricsFactory().getTimer(MetricsType.CASSANDRA_EXECUTE_ASYNC.name());

        getMetricsFactory().getCounter(MetricsType.CASSANDRA_PROCESSING_QUERIES.name()).inc();

        ResultSetFuture resultSetFuture = getOrCreateSession(keyspace).executeAsync(query);

        Futures.addCallback(resultSetFuture, new StatementExecutionCallback(keyspace, query));

        monitorFuture(time, resultSetFuture);

        return resultSetFuture;
    }
301271
public static void applyOrderBy(MultivaluedMap<String, String> queryParams, Query query) {
        List<String> orders = queryParams.get(SORT_PARAM_NAME);
        if (orders != null && orders.size() > 0) {
            OrderBy orderBy = query.orderBy();
            for (String order : orders) {
                EbeanUtils.appendOrder(orderBy, order);
            }
        }
    }
983728
@Override
	public long dynamicQueryCount(
		com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
		com.liferay.portal.kernel.dao.orm.Projection projection) {
		return _commercePriceListLocalService.dynamicQueryCount(dynamicQuery,
			projection);
	}
1141654
public ApiResponse<QueryResponse> executeQueryPostWithHttpInfo(Query query) throws ApiException {
        com.squareup.okhttp.Call call = executeQueryPostValidateBeforeCall(query, null, null);
        Type localVarReturnType = new TypeToken<QueryResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
542430
public static String getParameterValueFromQuery(String query, String paramName) {
        String[] components = query.split("&");

        for (String keyValuePair : components) {
            String[] pairComponents = keyValuePair.split("=");

            if (pairComponents.length == 2) {
                try {
                    String key = URLDecoder.decode(pairComponents[0], "utf-8");
                    if (key.compareTo(paramName) == 0) {
                        return URLDecoder.decode(pairComponents[1], "utf-8");
                    }
                } catch (UnsupportedEncodingException e) {
                    logger.error("getParameterValueFromQuery failed with exception: " + e.getLocalizedMessage(), e);
                }

            }
        }

        return null;
    }
753292
@Override
    public Map<String, DbColumnType> getQueryMetadata(Expression query) throws DatabaseEngineException {
        final String queryString = translate(query);
        logger.trace(queryString);
        return getQueryMetadata(queryString);
    }
503216
function query (query, params) {
        let rows = [];
        let stmt = sql.prepare(query);
        params = normalizeParams(params);
        stmt.bind(params);
        while(stmt.step()) {
            rows.push(stmt.getAsObject());
        }
        stmt.free();
        return rows;
    }
57286
public BoundStatement getBoundStatement(Q query, boolean useCaching) {

		PreparedStatement pStatement = getPreparedStatement(query, useCaching);
		return bindValues(pStatement, query);
	}