use of org.eclipse.rdf4j.query.algebra.Group in project rdf4j by eclipse.
the class TupleExprBuilder method visit.
@Override
public TupleExpr visit(ASTConstructQuery node, Object data) throws VisitorException {
// Start with building the graph pattern
graphPattern = new GraphPattern();
node.getWhereClause().jjtAccept(this, null);
TupleExpr tupleExpr = graphPattern.buildTupleExpr();
// Apply grouping
ASTGroupClause groupNode = node.getGroupClause();
if (groupNode != null) {
tupleExpr = (TupleExpr) groupNode.jjtAccept(this, tupleExpr);
}
Group group = null;
if (tupleExpr instanceof Group) {
group = (Group) tupleExpr;
} else {
// create a new implicit group. Note that this group will only
// actually
// be used in the query model if the query has HAVING or ORDER BY
// clause
group = new Group(tupleExpr);
}
// Apply HAVING group filter condition
tupleExpr = processHavingClause(node.getHavingClause(), tupleExpr, group);
// process bindings clause
ASTBindingsClause bindingsClause = node.getBindingsClause();
if (bindingsClause != null) {
tupleExpr = new Join((BindingSetAssignment) bindingsClause.jjtAccept(this, null), tupleExpr);
}
// Apply result ordering
tupleExpr = processOrderClause(node.getOrderClause(), tupleExpr, null);
// Process construct clause
ASTConstruct constructNode = node.getConstruct();
if (!constructNode.isWildcard()) {
tupleExpr = (TupleExpr) constructNode.jjtAccept(this, tupleExpr);
} else {
// create construct clause from graph pattern.
ConstructorBuilder cb = new ConstructorBuilder();
// possible future use.
try {
tupleExpr = cb.buildConstructor(tupleExpr, false, false);
} catch (MalformedQueryException e) {
throw new VisitorException(e.getMessage());
}
}
// process limit and offset clauses
ASTLimit limitNode = node.getLimit();
long limit = -1L;
if (limitNode != null) {
limit = (Long) limitNode.jjtAccept(this, null);
}
ASTOffset offsetNode = node.getOffset();
long offset = -1;
if (offsetNode != null) {
offset = (Long) offsetNode.jjtAccept(this, null);
}
if (offset >= 1 || limit >= 0) {
tupleExpr = new Slice(tupleExpr, offset, limit);
}
return tupleExpr;
}
use of org.eclipse.rdf4j.query.algebra.Group in project rdf4j by eclipse.
the class TupleExprBuilder method processHavingClause.
private TupleExpr processHavingClause(ASTHavingClause havingNode, TupleExpr tupleExpr, Group group) throws VisitorException {
if (havingNode != null) {
// create an implicit group
if (group == null) {
group = new Group(tupleExpr);
}
ValueExpr expr = (ValueExpr) havingNode.jjtGetChild(0).jjtAccept(this, tupleExpr);
// retrieve any aggregate operators from the expression.
AggregateCollector collector = new AggregateCollector();
collector.meetOther(expr);
// replace operator occurrences with an anonymous var, and alias it
// to the group
Extension extension = new Extension();
for (AggregateOperator operator : collector.getOperators()) {
Var var = createAnonVar();
// replace occurrence of the operator in the filter expression
// with the variable.
AggregateOperatorReplacer replacer = new AggregateOperatorReplacer(operator, var);
replacer.meetOther(expr);
String alias = var.getName();
// create an extension linking the operator to the variable
// name.
ExtensionElem pe = new ExtensionElem(operator, alias);
extension.addElement(pe);
// add the aggregate operator to the group.
GroupElem ge = new GroupElem(alias, operator);
// FIXME quite often the aggregate in the HAVING clause will be
// a duplicate of an aggregate in the projection. We could
// perhaps
// optimize for that, to avoid having to evaluate twice.
group.addGroupElement(ge);
}
extension.setArg(group);
tupleExpr = new Filter(extension, expr);
}
return tupleExpr;
}
use of org.eclipse.rdf4j.query.algebra.Group in project rdf4j by eclipse.
the class TupleExprBuilder method visit.
@Override
public TupleExpr visit(ASTAskQuery node, Object data) throws VisitorException {
graphPattern = new GraphPattern();
super.visit(node, null);
TupleExpr tupleExpr = graphPattern.buildTupleExpr();
tupleExpr = new Slice(tupleExpr, 0, 1);
// Apply grouping
Group group = null;
ASTGroupClause groupNode = node.getGroupClause();
if (groupNode != null) {
tupleExpr = (TupleExpr) groupNode.jjtAccept(this, tupleExpr);
group = (Group) tupleExpr;
}
final ASTHavingClause havingClause = node.getHavingClause();
if (havingClause != null) {
if (group == null) {
// create implicit group
group = new Group(tupleExpr);
}
// Apply HAVING group filter condition
tupleExpr = processHavingClause(havingClause, tupleExpr, group);
}
// process bindings clause
final ASTBindingsClause bindingsClause = node.getBindingsClause();
if (bindingsClause != null) {
tupleExpr = new Join((BindingSetAssignment) bindingsClause.jjtAccept(this, null), tupleExpr);
}
final ASTOrderClause orderClause = node.getOrderClause();
if (orderClause != null) {
if (group == null) {
// create implicit group
group = new Group(tupleExpr);
}
// Apply result ordering
tupleExpr = processOrderClause(node.getOrderClause(), tupleExpr, group);
}
return tupleExpr;
}
Aggregations