@Override public boolean equals(Object other) { if (other instanceof OrderElem) { OrderElem o = (OrderElem)other; return ascending == o.isAscending() && expr.equals(o.getExpr()); } return false; }
/** * @inheritDoc */ @Override public QueryBuilder<T> orderByDesc(String... theNames) { // null safe if (theNames != null) { for (String aName : theNames) { mOrderByElems.add(new OrderElem(new Var(aName), false)); } } return this; }
@Override public <X extends Exception> void visitChildren(QueryModelVisitor<X> visitor) throws X { for (OrderElem elem : elements) { elem.visit(visitor); } super.visitChildren(visitor); }
public OrderElem(ValueExpr expr, boolean ascending) { setExpr(expr); setAscending(ascending); }
@Override public void meet(OrderElem node) throws RuntimeException { valueNeeded++; node.getExpr().visit(this); valueNeeded--; }
@Override public void replaceChildNode(QueryModelNode current, QueryModelNode replacement) { if (expr == current) { setExpr((ValueExpr)replacement); } else { super.replaceChildNode(current, replacement); } }
for(Iterator<OrderElem> it = orderby.iterator(); it.hasNext(); ) { OrderElem elem = it.next(); String expr = evaluateExpression(elem.getExpr(), ValueType.STRING); if (StringUtils.indexOfAny(expr, aggregateFuncs) != -1) { continue;
@Override public void meet(OrderElem node) { if (predicate.equals(SeRQO.ASC)) { Literal lit = (Literal) object; node.setAscending(lit.booleanValue()); } else if (predicate.equals(SeRQO.ARG)) { node.setExpr((ValueExpr) model.get(object)); } else { super.meet(node); } }
public OrderByModifier(final TupleExpr tupleExpr, final Order order) { _tupleExpr = tupleExpr; _order = order; _variables = new HashMap<Var, Boolean>(); List<OrderElem> elems = order.getElements(); Iterator<OrderElem> iter = elems.iterator(); while (iter.hasNext()) { OrderElem ele = iter.next(); boolean ascending = ele.isAscending(); ValueExpr ex = ele.getExpr(); if (ex instanceof Var) { _variables.put((Var) ex, new Boolean(ascending)); } } }
/** * @inheritDoc */ @Override public QueryBuilder<T> orderByAsc(String... theNames) { // null safe if (theNames != null) { for (String aName : theNames) { mOrderByElems.add(new OrderElem(new Var(aName), true)); } } return this; }
if(distinct) { for(OrderElem e : orderby) { projections.add(evaluateExpression(e.getExpr(), ValueType.STRING) + " AS _OB" + (++counter));
@Override public void meet(Order node) throws RDFHandlerException { Resource orderByList = valueFactory.createBNode(); handler.handleStatement( valueFactory.createStatement(subject, SP.ORDER_BY_PROPERTY, orderByList)); ListContext orderByCtx = newList(orderByList); for (OrderElem elem : node.getElements()) { elem.visit(this); } endList(orderByCtx); }
public OrderByModifier(final TupleExpr tupleExpr, final Order order) { _tupleExpr = tupleExpr; _order = order; _variables = new HashMap<Var, Boolean>(); List<OrderElem> elems = order.getElements(); Iterator<OrderElem> iter = elems.iterator(); while (iter.hasNext()) { OrderElem ele = iter.next(); boolean ascending = ele.isAscending(); ValueExpr ex = ele.getExpr(); if (ex instanceof Var) { _variables.put((Var) ex, new Boolean(ascending)); } } }
@Override public OrderElem visit(ASTOrderCondition node, Object data) throws VisitorException { ValueExpr valueExpr = (ValueExpr)node.jjtGetChild(0).jjtAccept(this, null); return new OrderElem(valueExpr, node.isAscending()); }
@Override public void meet(Order node) { for (OrderElem e : node.getElements()) { e.visit(this); } if (variablesProjected) { QueryModelNode parent = node.getParentNode(); if (projection == parent) { node.replaceWith(node.getArg().clone()); node.setArg(projection.clone()); Order replacement = node.clone(); projection.replaceWith(replacement); QueryModelNode distinct = replacement.getParentNode(); if (distinct instanceof Distinct) { distinct.replaceWith(new Reduced(replacement.clone())); } } } }
private StringBuilder buildOrderClause() { StringBuilder orderClause = new StringBuilder(); if(orderby.size() > 0) { for(Iterator<OrderElem> it = orderby.iterator(); it.hasNext(); ) { OrderElem elem = it.next(); orderClause.append(evaluateExpression(elem.getExpr(), ValueType.STRING)); if(elem.isAscending()) { orderClause.append(" ASC"); } else { orderClause.append(" DESC"); } if(it.hasNext()) { orderClause.append(", "); } } orderClause.append(" \n"); } return orderClause; }
private OrderElem visitOrderByCondition(Resource r) throws OpenRDFException { Value expr = Statements.singleValue(r, SP.EXPRESSION_PROPERTY, store); ValueExpr valueExpr = visitExpression(expr); Statement descStmt = Statements.single(r, RDF.TYPE, SP.DESC_CLASS, store); boolean asc = (descStmt == null); return new OrderElem(valueExpr, asc); }
@Override public void meet(OrderElem node) throws RDFHandlerException { IRI asc = node.isAscending() ? SP.ASC_CLASS : SP.DESC_CLASS; listEntry(); handler.handleStatement(valueFactory.createStatement(subject, RDF.TYPE, asc)); SpinVisitor.this.meet(node.getExpr()); }
@Override public OrderElem visit(ASTOrderExpr node, Object data) throws VisitorException { ValueExpr valueExpr = (ValueExpr)node.getValueExpr().jjtAccept(this, null); return new OrderElem(valueExpr, node.isAscending()); }