Java Query.getFirstRow方法代码示例

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * If the Max rows and/or First row property of the query is set, then we
 * will use the database's LIMIT and OFFSET functions.
 */
@Override
public String rewriteQuery(Query query) {
    String queryString = super.rewriteQuery(query);
    Integer maxRows = query.getMaxRows();
    Integer firstRow = query.getFirstRow();
    if (maxRows != null || firstRow != null) {
        if (maxRows == null) {
            maxRows = Integer.MAX_VALUE;
        }
        queryString = queryString + " LIMIT " + maxRows;

        if (firstRow != null && firstRow > 1) {
            // offset is 0-based
            int offset = firstRow - 1;
            queryString = queryString + " OFFSET " + offset;
        }
    }


    return queryString;
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
@Override
protected String rewriteSelectClause(Query query, SelectClause selectClause) {
    String result = super.rewriteSelectClause(query, selectClause);

    Integer firstRow = query.getFirstRow();
    Integer maxRows = query.getMaxRows();
    if (maxRows != null || firstRow != null) {
        if (maxRows == null) {
            maxRows = Integer.MAX_VALUE;
        }
        if (firstRow == null || firstRow <= 0) {
            result = "SELECT TOP " + maxRows + " " + result.substring(7);
        } else {
            final int offset = firstRow - 1;
            result = "SELECT LIMIT " + offset + " " + maxRows + " " + result.substring(7);
        }
    }

    return result;
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
@Override
public final ConsumeRowHandler createConsumeRowHandler() {
    final RowProcessingQueryOptimizer queryOptimizer = getQueryOptimizer();
    final Query finalQuery = queryOptimizer.getOptimizedQuery();

    final RowIdGenerator idGenerator;
    if (finalQuery.getFirstRow() == null) {
        idGenerator = new SimpleRowIdGenerator();
    } else {
        idGenerator = new SimpleRowIdGenerator(finalQuery.getFirstRow());
    }

    final RowProcessingPublishers publishers = getPublishers();
    final AnalysisListener analysisListener = publishers.getAnalysisListener();

    for (final RowProcessingConsumer consumer : getConsumers()) {
        final ComponentJob componentJob = consumer.getComponentJob();
        final ComponentMetrics metrics =
                new AnalysisJobMetricsImpl(consumer.getAnalysisJob(), publishers).getComponentMetrics(componentJob);
        analysisListener.componentBegin(getStream().getAnalysisJob(), componentJob, metrics);

        if (consumer instanceof TransformerConsumer) {
            ((TransformerConsumer) consumer).setRowIdGenerator(idGenerator);
        }
    }
    final List<RowProcessingConsumer> consumers = queryOptimizer.getOptimizedConsumers();
    final Collection<? extends FilterOutcome> availableOutcomes = queryOptimizer.getOptimizedAvailableOutcomes();
    return new ConsumeRowHandler(consumers, availableOutcomes);
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 *
 * If the Max rows and First row property of the query is set, then we
 * will use the database's "OFFSET i ROWS FETCH NEXT j ROWS ONLY" construct.
 */
@Override
public String rewriteQuery(final Query query) {
    final boolean hasOrderBy = !query.getOrderByClause().isEmpty();
    String queryString = super.rewriteQuery(query);

    if (isSupportedVersion(_databaseProductName, _databaseSupportedVersion) && (query.getMaxRows() != null
            || query.getFirstRow() != null)) {
        final Integer maxRows = query.getMaxRows();
        Integer firstRow = query.getFirstRow();

        if (!_fetchNeedsOffsetAndOrderBy || hasOrderBy) {
            if (firstRow != null) {
                queryString = queryString + " OFFSET " + (firstRow - 1) + " ROWS";
            } else if (_fetchNeedsOffsetAndOrderBy) {
                // TOP should do it.
                return queryString;
            }

            if (maxRows != null) {
                queryString = queryString.replaceAll(" TOP [0-9]+", "");
                queryString += " FETCH NEXT " + maxRows + " ROWS ONLY";
            }
        }
    }
    return queryString;
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
@Override
protected boolean processRowsInternal(final AnalysisListener analysisListener,
        final RowProcessingMetrics rowProcessingMetrics) {
    final RowProcessingQueryOptimizer queryOptimizer = getQueryOptimizer();
    final Query finalQuery = queryOptimizer.getOptimizedQuery();

    final RowIdGenerator idGenerator;
    if (finalQuery.getFirstRow() == null) {
        idGenerator = new SimpleRowIdGenerator();
    } else {
        idGenerator = new SimpleRowIdGenerator(finalQuery.getFirstRow());
    }

    analysisListener.rowProcessingBegin(getAnalysisJob(), rowProcessingMetrics);

    final ConsumeRowHandler consumeRowHandler = createConsumeRowHandler();

    final RowConsumerTaskListener taskListener =
            new RowConsumerTaskListener(getAnalysisJob(), analysisListener, getTaskRunner());

    final Datastore datastore = getAnalysisJob().getDatastore();

    try (DatastoreConnection con = datastore.openConnection()) {
        final DataContext dataContext = con.getDataContext();

        if (logger.isDebugEnabled()) {
            final String queryString;
            if (dataContext instanceof JdbcDataContext) {
                final JdbcDataContext jdbcDataContext = (JdbcDataContext) dataContext;
                queryString = jdbcDataContext.getQueryRewriter().rewriteQuery(finalQuery);
            } else {
                queryString = finalQuery.toSql();
            }
            logger.debug("Final query: {}", queryString);
            logger.debug("Final query firstRow={}, maxRows={}", finalQuery.getFirstRow(), finalQuery.getMaxRows());
        }

        // represents the distinct count of rows as well as the number of
        // tasks to execute
        int numTasks = 0;

        try (DataSet dataSet = dataContext.executeQuery(finalQuery)) {
            while (dataSet.next()) {
                if (taskListener.isErrornous()) {
                    break;
                }

                numTasks++;

                final Row metaModelRow = dataSet.getRow();
                final int rowId = idGenerator.nextPhysicalRowId();

                final MetaModelInputRow inputRow = new MetaModelInputRow(rowId, metaModelRow);

                final ConsumeRowTask task =
                        new ConsumeRowTask(consumeRowHandler, rowProcessingMetrics, inputRow, analysisListener,
                                numTasks);
                getTaskRunner().run(task, taskListener);

            }
        }
        taskListener.awaitTasks(numTasks);
    }

    return !taskListener.isErrornous();
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
@Override
public String rewriteQuery(Query query) {
    final Integer firstRow = query.getFirstRow();
    final Integer maxRows = query.getMaxRows();

    if (maxRows == null && (firstRow == null || firstRow.intValue() == 1)) {
        return super.rewriteQuery(query);
    }

    if ((firstRow == null || firstRow.intValue() == 1) && maxRows != null && maxRows > 0) {
        // We prefer to use the "FETCH FIRST [n] ROWS ONLY" approach, if
        // firstRow is not specified.
        return super.rewriteQuery(query) + " FETCH FIRST " + maxRows + " ROWS ONLY";

    } else {
        // build a ROW_NUMBER() query like this:

        // SELECT [original select clause]
        // FROM ([original select clause],
        // ROW_NUMBER() AS metamodel_row_number
        // FROM [remainder of regular query])
        // WHERE metamodel_row_number BETWEEN [firstRow] and [maxRows];

        final Query innerQuery = query.clone();
        innerQuery.setFirstRow(null);
        innerQuery.setMaxRows(null);

        final Query outerQuery = new Query();
        final FromItem subQuerySelectItem = new FromItem(innerQuery).setAlias("metamodel_subquery");
        outerQuery.from(subQuerySelectItem);

        final List<SelectItem> innerSelectItems = innerQuery.getSelectClause().getItems();
        for (SelectItem selectItem : innerSelectItems) {
            outerQuery.select(new SelectItem(selectItem, subQuerySelectItem));
        }

        final String rewrittenOrderByClause = rewriteOrderByClause(innerQuery, innerQuery.getOrderByClause());
        final String rowOver = "ROW_NUMBER() " + "OVER(" + rewrittenOrderByClause + ")";
        innerQuery.select(new SelectItem(rowOver, "metamodel_row_number"));
        innerQuery.getOrderByClause().removeItems();

        final String baseQueryString = rewriteQuery(outerQuery);

        if (maxRows == null) {
            return baseQueryString + " WHERE metamodel_row_number > " + (firstRow - 1);
        }

        return baseQueryString + " WHERE metamodel_row_number BETWEEN " + firstRow + " AND "
                + (firstRow - 1 + maxRows);
    }
}