Java Query.getMaxRows方法代码示例

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包/类
private Supplier<Integer> createExpectedRowsRef() {
    // TODO: This only seems valid for source tables
    return new LazyRef<Integer>() {

        @Override
        protected Integer fetch() {
            int expectedRows = -1;
            {
                final Query originalQuery = getQuery();
                final Query countQuery = originalQuery.clone();
                countQuery.setMaxRows(null);
                countQuery.setFirstRow(null);
                countQuery.getSelectClause().removeItems();
                countQuery.getOrderByClause().removeItems();
                countQuery.selectCount();
                countQuery.getSelectClause().getItem(0).setFunctionApproximationAllowed(true);

                final Datastore datastore = _publisher.getStream().getAnalysisJob().getDatastore();
                try (DatastoreConnection connection = datastore.openConnection()) {
                    try (DataSet countDataSet = connection.getDataContext().executeQuery(countQuery)) {
                        if (countDataSet.next()) {
                            final Number count =
                                    ConvertToNumberTransformer.transformValue(countDataSet.getRow().getValue(0));
                            if (count != null) {
                                expectedRows = count.intValue();
                            }
                        }
                    }
                }

                final Integer maxRows = originalQuery.getMaxRows();
                if (maxRows != null) {
                    expectedRows = Math.min(expectedRows, maxRows.intValue());
                }
            }

            return expectedRows;
        }
    };
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
public void testSimpleOptimization() throws Exception {
    publisher = createPublisher();
    consumers.add(createConsumer(maxRowsBuilder, publisher));
    consumers.add(createConsumer(stringAnalyzerBuilder, publisher));

    final RowProcessingQueryOptimizer optimizer =
            new RowProcessingQueryOptimizerImpl(datastore, consumers, baseQuery);

    assertTrue(optimizer.isOptimizable());

    final Query optimizedQuery = optimizer.getOptimizedQuery();
    final Integer maxRows = optimizedQuery.getMaxRows();
    assertNotNull("No max rows specified!", maxRows);
    assertEquals(1000, maxRows.intValue());
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
public void testSimpleOptimization() throws Exception {
    RowProcessingQueryOptimizer optimizer = new RowProcessingQueryOptimizer(datastore, consumers, baseQuery);

    assertTrue(optimizer.isOptimizable());

    Query optimizedQuery = optimizer.getOptimizedQuery();
    Integer maxRows = optimizedQuery.getMaxRows();
    assertNotNull("No max rows specified!", maxRows);
    assertEquals(1000, maxRows.intValue());
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
private Ref<Integer> createExpectedRowsRef() {
    return new LazyRef<Integer>() {

        @Override
        protected Integer fetch() {
            int expectedRows = -1;
            {
                final Query originalQuery = getQuery();
                final Query countQuery = originalQuery.clone();
                countQuery.setMaxRows(null);
                countQuery.setFirstRow(null);
                countQuery.getSelectClause().removeItems();
                countQuery.getOrderByClause().removeItems();
                countQuery.selectCount();
                countQuery.getSelectClause().getItem(0).setFunctionApproximationAllowed(true);

                final Datastore datastore = _publishers.getDatastore();
                try (final DatastoreConnection connection = datastore.openConnection()) {
                    try (final DataSet countDataSet = connection.getDataContext().executeQuery(countQuery)) {
                        if (countDataSet.next()) {
                            final Number count = ConvertToNumberTransformer.transformValue(countDataSet.getRow()
                                    .getValue(0));
                            if (count != null) {
                                expectedRows = count.intValue();
                            }
                        }
                    }
                }

                final Integer maxRows = originalQuery.getMaxRows();
                if (maxRows != null) {
                    expectedRows = Math.min(expectedRows, maxRows.intValue());
                }
            }

            return expectedRows;
        }
    };
}
 

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

    Integer maxRows = query.getMaxRows();
    if (maxRows != null) {
        if (query.getSelectClause().isDistinct()) {
            result = "SELECT DISTINCT TOP " + maxRows + " " + result.substring("SELECT DISTINCT ".length());
        } else {
            result = "SELECT TOP " + maxRows + " " + result.substring("SELECT ".length());
        }
    }

    return result;
}
 

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包/类
/**
 * Gets the fetch size of a query
 * 
 * @param query
 *            the query to execute
 * @return an integer representing how many rows to eagerly fetch for the
 *         query
 */
public int getFetchSize(Query query) {
	if (isSingleRowQuery(query)) {
		return 1;
	}
	int bytesPerRow = getRowSize(query);
	int result = getFetchSize(bytesPerRow);
	final Integer maxRows = query.getMaxRows();
	if (maxRows != null && result > maxRows) {
		logger.debug("Result ({}) was below max rows ({}), adjusting.",
				result, maxRows);
		result = maxRows;
	}
	return result;
}
 

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);
    }
}