/** * Constructs an instance of this class from an ordered list of elements. * @param parameters The ordered list of SingleElementSymbol */ public OrderBy( List<? extends Expression> parameters ) { for (Expression singleElementSymbol : parameters) { orderByItems.add(new OrderByItem(singleElementSymbol, ASC)); } }
@Override public void visit(OrderByItem obj) { obj.setSymbol(replaceSymbol(obj.getSymbol(), obj.getExpressionPosition() != -1)); }
static boolean supportsNullOrdering(QueryMetadataInterface metadata, CapabilitiesFinder capFinder, Object modelID, OrderByItem symbol) throws QueryMetadataException, TeiidComponentException { boolean supportsNullOrdering = CapabilitiesUtil.supports(Capability.QUERY_ORDERBY_NULL_ORDERING, modelID, metadata, capFinder); NullOrder defaultNullOrder = CapabilitiesUtil.getDefaultNullOrder(modelID, metadata, capFinder); if (symbol.getNullOrdering() != null && !supportsNullOrdering) { if (symbol.getNullOrdering() == NullOrdering.FIRST) { if (defaultNullOrder != NullOrder.FIRST && !(symbol.isAscending() && defaultNullOrder == NullOrder.LOW) && !(!symbol.isAscending() && defaultNullOrder == NullOrder.HIGH)) { return false; } } else if (defaultNullOrder != NullOrder.LAST && !(symbol.isAscending() && defaultNullOrder == NullOrder.HIGH) && !(!symbol.isAscending() && defaultNullOrder == NullOrder.LOW)) { return false; } } return true; } }
OrderByItem item = orderBy.getOrderByItems().get(i); if (!Boolean.TRUE.equals(table.matchesPkColumn(i, item.getSymbol())) || !table.supportsOrdering(i, item.getSymbol())) { return null; if (item.getNullOrdering() != null && ((item.isAscending() && item.getNullOrdering() == NullOrdering.LAST) || (!item.isAscending() && item.getNullOrdering() == NullOrdering.FIRST))) { if (item.isAscending()) { if (direction == null) { direction = OrderBy.ASC;
} else if (query.getOrderBy() != null) { for (OrderByItem item : query.getOrderBy().getOrderByItems()) { Integer index = uniqueSymbols.get(SymbolMap.getExpression(item.getSymbol())); if (index != null) { item.setExpressionPosition(index); item.setSymbol(select.getSymbols().get(index));
item.setExpressionPosition(exprs.indexOf(SymbolMap.getExpression(item.getSymbol()))); NullOrder defaultNullOrder = CapabilitiesUtil.getDefaultNullOrder(modelID, context.getMetadata(), capFinder); for (OrderByItem item : orderBy.getOrderByItems()) { if (item.getNullOrdering() != null) { if (!supportsNullOrdering) { item.setNullOrdering(null); if (item.isAscending()) { if (context.getOptions().getDefaultNullOrder() == NullOrder.FIRST || context.getOptions().getDefaultNullOrder() == NullOrder.LOW) { if (defaultNullOrder != NullOrder.FIRST && defaultNullOrder != NullOrder.LOW) { item.setNullOrdering(NullOrdering.FIRST); item.setNullOrdering(NullOrdering.LAST); if (context.getOptions().getDefaultNullOrder() == NullOrder.LAST || context.getOptions().getDefaultNullOrder() == NullOrder.LOW) { if (defaultNullOrder != NullOrder.LAST && defaultNullOrder != NullOrder.LOW) { item.setNullOrdering(NullOrdering.LAST); item.setNullOrdering(NullOrdering.FIRST);
public org.teiid.language.OrderBy translate(OrderBy orderBy, boolean set) { if(orderBy == null){ return null; } List<OrderByItem> items = orderBy.getOrderByItems(); List<SortSpecification> translatedItems = new ArrayList<SortSpecification>(); for (int i = 0; i < items.size(); i++) { Expression symbol = items.get(i).getSymbol(); Ordering direction = items.get(i).isAscending() ? Ordering.ASC: Ordering.DESC; SortSpecification orderByItem = null; if(!set && (items.get(i).isUnrelated() || symbol instanceof ElementSymbol)){ orderByItem = new SortSpecification(direction, translate(symbol)); } else { orderByItem = new SortSpecification(direction, new ColumnReference(null, Symbol.getShortName(((Symbol)symbol).getOutputName()), null, symbol.getType())); } orderByItem.setNullOrdering(items.get(i).getNullOrdering()); translatedItems.add(orderByItem); } return new org.teiid.language.OrderBy(translatedItems); }
Expression element = item.getSymbol(); visitNode(element); if (item.isUnrelated()) { item.setSymbol(expr); continue; int pos = item.getExpressionPosition(); if (pos < visitor.namingContext.currentSymbols.size()) { ArrayList<Map.Entry<Expression, String>> list = new ArrayList<Map.Entry<Expression,String>>(visitor.namingContext.currentSymbols.entrySet()); item.setSymbol(element); if (element instanceof Symbol) { ((Symbol)element).setShortName(name);
for (ListIterator<OrderByItem> iterator = aggSymbol.getOrderBy().getOrderByItems().listIterator(); iterator.hasNext();) { OrderByItem item = iterator.next(); argIndexes[args.length + iterator.previousIndex()] = getIndex(item.getSymbol(), expressionIndexes); ElementSymbol element = new ElementSymbol(String.valueOf(iterator.previousIndex())); element.setType(item.getSymbol().getType()); schema.add(element); OrderByItem newItem = item.clone(); newItem.setSymbol(element); orderByItems.add(newItem);
@Test public void testOrderByNullOrdering(){ OrderBy orderBy = new OrderBy(); OrderByItem item = new OrderByItem(new ElementSymbol("c"), true); item.setNullOrdering(NullOrdering.FIRST); orderBy.getOrderByItems().add(item); item = new OrderByItem(new ElementSymbol("d"), false); item.setNullOrdering(NullOrdering.LAST); orderBy.getOrderByItems().add(item); Query query = getOrderByQuery(orderBy); helpTest("SELECT a FROM db.g WHERE b = aString ORDER BY c NULLS FIRST,d desc nulls last", //$NON-NLS-1$ "SELECT a FROM db.g WHERE b = aString ORDER BY c NULLS FIRST, d DESC NULLS LAST", //$NON-NLS-1$ query); }
/** * Returns the ORDER BY element at the specified index. * @param index Index to get * @return The element at the index */ public Expression getVariable( int index ) { return orderByItems.get(index).getSymbol(); }
int pos1 = parentkeys.get(i).getExpressionPosition(); int pos2 = keys.get(i).getExpressionPosition(); if (pos1 == -1 || pos2 == -1 || pos1 != pos2) { continue outer; OrderByItem item = parentkeys.get(i).clone(); if (item.getExpressionPosition() == -1) { continue outer; Expression ex = cols.get(item.getExpressionPosition()); item.setSymbol((Expression) ex.clone()); newOrderBy.getOrderByItems().add(item);
exanded.addAll(select.getProjectedSymbols()); for (OrderByItem item : query.getOrderBy().getOrderByItems()) { if (item.isUnrelated()) { AggregateSymbolCollectorVisitor.getAggregates(item.getSymbol(), aggs, invalid, null, invalidWindowFunctions, exanded);
@Override public void visit(OrderByItem obj) { validateSortable(obj.getSymbol()); if (obj.getExpressionPosition() < 0) { for (SubqueryContainer subquery : ValueIteratorProviderCollectorVisitor.getValueIteratorProviders(obj)) { for (ElementSymbol es : ElementCollectorVisitor.getElements(obj, true, true)) { if (es.isExternalReference()) { handleValidationError(QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31156, subquery), obj); } } } } }
/** * special handling is needed since we are retaining the child aliases */ private static void correctOrderBy(PlanNode frame, PlanNode sort, List<Expression> selectSymbols, PlanNode parentProject) { if (sort == null || NodeEditor.findNodePreOrder(sort, NodeConstants.Types.PROJECT, NodeConstants.Types.SOURCE) != parentProject) { return; } List<Expression> childProject = (List<Expression>)NodeEditor.findNodePreOrder(frame, NodeConstants.Types.PROJECT).getProperty(NodeConstants.Info.PROJECT_COLS); OrderBy elements = (OrderBy)sort.getProperty(NodeConstants.Info.SORT_ORDER); for (OrderByItem item : elements.getOrderByItems()) { item.setSymbol(childProject.get(selectSymbols.indexOf(item.getSymbol()))); } sort.getGroups().clear(); sort.addGroups(GroupsUsedByElementsVisitor.getGroups(elements)); }
private void processOrderBy(PlanNode node, QueryCommand query, CommandContext context) throws QueryMetadataException, TeiidComponentException { OrderBy orderBy = (OrderBy)node.getProperty(NodeConstants.Info.SORT_ORDER); query.setOrderBy(orderBy); if (query instanceof Query) { List<Expression> cols = query.getProjectedSymbols(); List<Expression> exprs = new ArrayList<Expression>(cols.size()); for (Expression expr : cols) { exprs.add(SymbolMap.getExpression(expr)); } for (OrderByItem item : orderBy.getOrderByItems()) { item.setExpressionPosition(exprs.indexOf(SymbolMap.getExpression(item.getSymbol()))); } try { QueryRewriter.rewriteOrderBy(query, orderBy, query.getProjectedSymbols(), context, context.getMetadata()); } catch (TeiidProcessingException e) { throw new TeiidComponentException(e); } } }
/** * * @return true if the expression does not appear in the select clause */ public boolean isUnrelated() { return getExpressionPosition() == -1; }
/** * Returns the sort order at the specified index * @param index Index to get * @return The sort order at the index */ public Boolean getOrderType( int index ) { return orderByItems.get(index).isAscending(); }
public OrderByItem(Expression symbol, boolean ascending) { setSymbol(symbol); this.ascending = ascending; }
public boolean hasUnrelated() { for (OrderByItem item : orderByItems) { if (item.isUnrelated()) { return true; } } return false; }