<p>applyRowCountHeader.</p>

@param headerParams a {@link javax.ws.rs.core.MultivaluedMap} object.
@param query        a {@link io.ebean.Query} object.
@param rowCount     a {@link io.ebean.FutureRowCount} object.
768641
protected void applyRowCountHeader(MultivaluedMap<String, Object> headerParams, Query query, FutureRowCount rowCount) {
        ModelInterceptor.applyRowCountHeader(headerParams, query, rowCount);
    }
168058
protected function compileColumnQuery($query, $method, $parameters, $column, $keyword)
    {
        if (method_exists($query, $method) && count($parameters) <= with(new \ReflectionMethod($query, $method))->getNumberOfParameters()
        ) {
            if (Str::contains(Str::lower($method), 'raw') || Str::contains(Str::lower($method), 'exists')
            ) {
                call_user_func_array(
                        [$query, $method], $this->parameterize($parameters, $keyword)
                );
            } else {
                call_user_func_array(
                        [$query, $method], $this->parameterize($column, $parameters, $keyword)
                );
            }
        }
    }
137125
private void executeRow(Example valuesRow, Example headers, Fixture rowFixtureAdapter)
    {
        valuesRow.annotate( Annotations.right() );

        Statistics rowStats = new Statistics();

        for (int i = 0; i != valuesRow.remainings(); ++i)
        {
            Example cell = valuesRow.at( i );

            if (i < headers.remainings())
            {
                // We can do the cast because #parseColumn returns an ExpectedColumn
                ExpectedColumn column = (ExpectedColumn) columns[i];

                try
                {
                    chekOneCell(rowFixtureAdapter, rowStats, cell, column);
                }
                catch (Exception e)
                {
                    cell.annotate( exception( e ) );
                    stats.exception();
                }
            }
            else
            {
                cell.annotate( ignored( cell.getContent() ) );
            }
        }
        applyRowStatistic(rowStats);
    }
1324785
@Override
    protected V createRow(QueryParameters params) throws MjdbcException {
        return this.outputProcessor.toBean(params, type);
    }
842634
@Override
  public final <T> Integer evalRowCountWhere(
    final Map<String, Object> pAddParam,
      final Class<T> pEntityClass, final String pWhere) throws Exception {
    if (pWhere == null) {
      throw new ExceptionWithCode(ExceptionWithCode.WRONG_PARAMETER,
        "param_null_not_accepted");
    }
    String query = "select count(*) as TOTALROWS from " + pEntityClass
      .getSimpleName().toUpperCase() + " where " + pWhere + ";";
    return evalRowCountByQuery(pAddParam, pEntityClass, query);
  }
629015
protected FutureRowCount applyUriQuery(final Query<MODEL> query, boolean needPageList) {
        return ModelInterceptor.applyUriQuery(uriInfo.getQueryParameters(), (SpiQuery) query, manager, needPageList);
    }
73039
@Override
	public void updateRowId(final int columnIndex, final RowId x) throws SQLException {
		wrapped.updateRowId(columnIndex, x);
	}
635431
public function queryAndCount(string $query, array $params = []): int
	{
		$prepared = $this->prepare($query, $params);

		$this->execute($prepared);

		return $prepared['statement']->rowCount();
	}
1306674
public static Map<String, ValueType> rowSignatureFor(final GroupByQuery query)
  {
    final ImmutableMap.Builder<String, ValueType> types = ImmutableMap.builder();

    for (DimensionSpec dimensionSpec : query.getDimensions()) {
      types.put(dimensionSpec.getOutputName(), dimensionSpec.getOutputType());
    }

    for (AggregatorFactory aggregatorFactory : query.getAggregatorSpecs()) {
      final String typeName = aggregatorFactory.getTypeName();
      final ValueType valueType;
      if (typeName != null) {
        valueType = GuavaUtils.getEnumIfPresent(ValueType.class, StringUtils.toUpperCase(typeName));
      } else {
        valueType = null;
      }
      if (valueType != null) {
        types.put(aggregatorFactory.getName(), valueType);
      }
    }

    // Don't include post-aggregators since we don't know what types they are.
    return types.build();
  }
949590
protected void addFacetOptions(StringBuffer query) {

        // start
        appendFacetOption(query, "range.start", m_config.getStart());
        // end
        appendFacetOption(query, "range.end", m_config.getEnd());
        // gap
        appendFacetOption(query, "range.gap", m_config.getGap());
        // other
        for (I_CmsSearchConfigurationFacetRange.Other o : m_config.getOther()) {
            appendFacetOption(query, "range.other", o.toString());
        }
        // hardend
        appendFacetOption(query, "range.hardend", Boolean.toString(m_config.getHardEnd()));
        // mincount
        if (m_config.getMinCount() != null) {
            appendFacetOption(query, "mincount", m_config.getMinCount().toString());
        }
    }
501914
public FutureData<DataSiftResult> start(FutureData<PreparedHistoricsQuery> query) {
        if (query == null) {
            throw new IllegalArgumentException("A valid PreparedHistoricsQuery is required");
        }
        final FutureData<DataSiftResult> future = new FutureData<>();
        DataSiftResult h = new BaseDataSiftResult();

        FutureResponse<PreparedHistoricsQuery> r = new FutureResponse<PreparedHistoricsQuery>() {
            public void apply(PreparedHistoricsQuery data) {
                if (data.getId() == null || data.getId().isEmpty()) {
                    throw new IllegalArgumentException("A valid PreparedHistoricsQuery is required");
                }
                start(data.getId(), future);
            }
        };
        unwrapFuture(query, future, h, r);
        return future;
    }
978085
public FutureAPIResponse sendQueryAsFuture(Map<String, Object> query)
      throws ExecutionException, InterruptedException, IOException {
    RequestBuilder builder = new RequestBuilder("POST");
    builder.setUrl(apiUrl + "/queries.json");

    // handle DateTime separately
    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeAdapter(DateTime.class, new DateTimeAdapter());
    Gson gson = gsonBuilder.create();

    String requestJsonString = gson.toJson(query);
    builder.setBody(requestJsonString);
    builder.setHeader("Content-Type", "application/json");
    builder.setHeader("Content-Length", "" + requestJsonString.length());
    return new FutureAPIResponse(client.executeRequest(builder.build(), getHandler()));
  }
418370
@Override
    public void setRowId(String parameterName, RowId x) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
1073174
protected void prepareRow(final Request request, final int rowIndex) {
		WComponent row = getRepeatedComponent();
		row.preparePaint(request);
	}
1304723
public void setQuery( String query )
    {
        _parameters = null;

        if ( query == null || query.length() == 0 ) { return; }

        for ( StringTokenizer tok = new StringTokenizer( query, "&" ); tok.hasMoreElements(); )
        {
            String queryItem = tok.nextToken();

            if ( queryItem.startsWith( "amp;" ) )
            {
                queryItem = queryItem.substring( 4 );
            }

            int eq = queryItem.indexOf( '=' );
            if ( eq != -1 )
            {
                addParameter( queryItem.substring( 0, eq ) , queryItem.substring( eq + 1 ), true );
            }
            else
            {
                addParameter( queryItem, null, true );
            }
        }
    }
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();
            }
        });
    }
658822
protected void addFacetPart(CmsSolrQuery query) {

        StringBuffer value = new StringBuffer();
        value.append("{!key=").append(m_config.getName());
        addFacetOptions(value);
        if (m_config.getIgnoreAllFacetFilters()
            || (!m_state.getCheckedEntries().isEmpty() && !m_config.getIsAndFacet())) {
            value.append(" ex=").append(m_config.getIgnoreTags());
        }
        value.append("}");
        value.append(m_config.getRange());
        query.add("facet.range", value.toString());
    }