@Override public Query optimizeQuery(final Query q, final Category category) { if (category == Category.VALID) { final Integer previousMaxRows = q.getMaxRows(); final Integer previousFirstRow = q.getFirstRow(); q.setFirstRow(firstRow); } else { final int newFirstRow = previousFirstRow.intValue() + firstRow; q.setFirstRow(newFirstRow); q.setMaxRows(maxRows); } else { int newMaxRows = Math.min(previousMaxRows.intValue(), maxRows); if (previousFirstRow != null) { final Integer newFirstRow = q.getFirstRow(); final int maxWindowSizeFrombefore = previousFirstRow.intValue() + previousMaxRows.intValue() - newFirstRow; q.setMaxRows(newMaxRows); q.orderBy(physicalColumn);
public String rewriteQuery(Query query) { query = beforeRewrite(query); final StringBuilder sb = new StringBuilder(); sb.append(rewriteSelectClause(query, query.getSelectClause())); sb.append(rewriteFromClause(query, query.getFromClause())); sb.append(rewriteWhereClause(query, query.getWhereClause())); sb.append(rewriteGroupByClause(query, query.getGroupByClause())); sb.append(rewriteHavingClause(query, query.getHavingClause())); sb.append(rewriteOrderByClause(query, query.getOrderByClause())); return sb.toString(); }
@Override protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int maxRows) { // find the appropriate datacontext to execute a simple // table materialization query final DataContext dc = _dataContextRetrievalFunction.apply(table); final Query q = new Query().select(columns).from(table); if (maxRows >= 0) { q.setMaxRows(maxRows); } return dc.executeQuery(q); }
/** * Select all available select items from all currently available FROM * items. Equivalent of the expression "SELECT * FROM ..." in SQL. * * @return */ public Query selectAll() { List<FromItem> items = getFromClause().getItems(); for (FromItem fromItem : items) { selectAll(fromItem); } return this; }
@Override public Query optimizeQuery(Query q, Category category) { if (category == Category.VALID) { q.setMaxRows(maxRows); if (firstRow > 1) { q.setFirstRow(firstRow); } if (orderColumn != null) { Column physicalColumn = orderColumn.getPhysicalColumn(); q.orderBy(physicalColumn); } } else { throw new IllegalStateException("Can only optimize the VALID max rows category"); } return q; }
List<FromItem> fromItems = query.getFromClause().getItems(); if (fromItems.size() == 1 && fromItems.get(0).getTable() != null && fromItems.get(0).getTable().getSchema() == _schema) { if (query.getGroupByClause().isEmpty() && query.getHavingClause().isEmpty() && query.getOrderByClause().isEmpty()) { final List<FilterItem> whereItems = query.getWhereClause().getItems(); List<SelectItem> selectItems = query.getSelectClause().getItems(); int firstRow = (query.getFirstRow() == null ? 1 : query.getFirstRow()); int maxRows = (query.getMaxRows() == null ? -1 : query.getMaxRows());
@Override public String rewriteQuery(Query query) { final Integer firstRow = query.getFirstRow(); final Integer maxRows = query.getMaxRows(); 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();
@Override public Query clone() { final Query q = new Query(); q.setMaxRows(_maxRows); q.setFirstRow(_firstRow); q.getSelectClause().setDistinct(_selectClause.isDistinct()); for (FromItem item : _fromClause.getItems()) { q.from(item.clone()); } for (SelectItem item : _selectClause.getItems()) { q.select(item.clone(q)); } for (FilterItem item : _whereClause.getItems()) { q.where(item.clone()); } for (GroupByItem item : _groupByClause.getItems()) { q.groupBy(item.clone()); } for (FilterItem item : _havingClause.getItems()) { q.having(item.clone()); } for (OrderByItem item : _orderByClause.getItems()) { q.orderBy(item.clone()); } return q; } }
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 Integer maxRows = originalQuery.getMaxRows(); if (maxRows != null) { expectedRows = Math.min(expectedRows, maxRows.intValue());
private long getRowCount(Query q) { q = q.clone(); SelectItem countAllItem = SelectItem.getCountAllItem(); if (q.getGroupByClause().getItemCount() > 0) { q = new Query().from(new FromItem(q).setAlias("sq")).select(countAllItem); } else { q.getSelectClause().removeItems(); q.select(countAllItem); } Row row = MetaModelHelper.executeSingleRowQuery(_dataContext, q); Number count = (Number) row.getValue(countAllItem); return count.longValue(); }
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();
/** * {@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; } }
@Override public SatisfiedQueryBuilder<GroupedQueryBuilder> maxRows(int maxRows) { _query.setMaxRows(maxRows); return this; }
public void initialize() { final Table table = _outputDataStreamJob.getOutputDataStream().getTable(); final Query query = new Query(); query.from(table).selectAll(); final List<SelectItem> selectItems = query.getSelectClause().getItems(); final ConsumeRowHandler consumeRowHandler = _publisher.createConsumeRowHandler(); _outputRowCollector = new OutputDataStreamRowCollector(_publisher, selectItems, consumeRowHandler); final OutputDataStream outputDataStream = _outputDataStreamJob.getOutputDataStream(); _component.initializeOutputDataStream(outputDataStream, query, _outputRowCollector); _publisher.getAnalysisListener() .rowProcessingBegin(_publisher.getAnalysisJob(), _publisher.getRowProcessingMetrics()); }
if (finalQuery.getFirstRow() == null) { idGenerator = new SimpleRowIdGenerator(); } else { idGenerator = new SimpleRowIdGenerator(finalQuery.getFirstRow()); queryString = jdbcDataContext.getQueryRewriter().rewriteQuery(finalQuery); } else { queryString = finalQuery.toSql(); logger.debug("Final query firstRow={}, maxRows={}", finalQuery.getFirstRow(), finalQuery.getMaxRows());
@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; }
private static List<SelectItem> getSelectItems(List<Query> splitQueries) { if (splitQueries.isEmpty()) { return new ArrayList<SelectItem>(0); } return splitQueries.get(0).getSelectClause().getItems(); }
private List<Query> splitQueryBasedOnSubQueries(int fromItemIndex) { Query subQuery = _query.getFromClause().getItem(fromItemIndex).getSubQuery(); QuerySplitter subQuerySplitter = new QuerySplitter(_dataContext, subQuery); subQuerySplitter.setMaxRows(_maxRows); List<Query> splitQueries = subQuerySplitter.splitQuery(); List<Query> result = new ArrayList<Query>(splitQueries.size()); for (Query splitQuery : splitQueries) { Query newQuery = _query.clone(); FromClause fromClause = newQuery.getFromClause(); String alias = fromClause.getItem(fromItemIndex).getAlias(); fromClause.removeItem(fromItemIndex); newQuery.from(new FromItem(splitQuery).setAlias(alias)); result.add(newQuery); } return result; }
/** * Gets whether a query is guaranteed to only yield a single row. Such * queries are queries that only consist of aggregation functions and no * group by clause. * * @param query * @return */ private boolean isSingleRowQuery(Query query) { if (!query.getGroupByClause().isEmpty()) { return false; } List<SelectItem> items = query.getSelectClause().getItems(); for (SelectItem item : items) { if (item.getAggregateFunction() == null) { return false; } } return true; }