[feature] Implementation of count clause

Author: adamretter

exist-core/src/main/java/org/exist/xquery/BasicExpressionVisitor.java

@@ -180,6 +180,11 @@ public void visitOrderByClause(final OrderByClause orderBy) {
         // Nothing to do
     }
 
+    @Override
+    public void visitCountClause(final CountClause count) {
+        // Nothing to do
+    }
+
     @Override
     public void visitGroupByClause(final GroupByClause groupBy) {
         // Nothing to do

exist-core/src/main/java/org/exist/xquery/CountClause.java

@@ -23,8 +23,12 @@
 
 import org.exist.dom.QName;
 import org.exist.xquery.util.ExpressionDumper;
+import org.exist.xquery.value.IntegerValue;
 import org.exist.xquery.value.Item;
 import org.exist.xquery.value.Sequence;
+import org.exist.xquery.value.SequenceType;
+import org.exist.xquery.value.Type;
+import org.exist.xquery.value.ValueSequence;
 
 /**
  * Implements a count clause inside a FLWOR expressions.
@@ -34,8 +38,14 @@
  */
 public class CountClause extends AbstractFLWORClause {
 
+    private static final SequenceType countVarType = new SequenceType(Type.INTEGER, Cardinality.EXACTLY_ONE);
+
     final QName varName;
 
+    // the count itself
+    private long count = 0;
+    private int step = 1;
+
     public CountClause(final XQueryContext context, final QName varName) {
         super(context);
         this.varName = varName;
@@ -52,12 +62,131 @@ public QName getVarName() {
 
     @Override
     public void analyze(final AnalyzeContextInfo contextInfo) throws XPathException {
+        contextInfo.setParent(this);
+        unordered = (contextInfo.getFlags() & UNORDERED) > 0;
+
+        // Save the local variable stack
+        final LocalVariable mark = context.markLocalVariables(false);
+        try {
+            final AnalyzeContextInfo varContextInfo = new AnalyzeContextInfo(contextInfo);
+
+            // Declare the count variable
+            final LocalVariable countVar = new LocalVariable(varName);
+            countVar.setSequenceType(countVarType);
+            countVar.setStaticType(varContextInfo.getStaticReturnType());
+            context.declareVariableBinding(countVar);
+
+            // analyze the return expression
+            final AnalyzeContextInfo newContextInfo = new AnalyzeContextInfo(contextInfo);
+            returnExpr.analyze(newContextInfo);
+
+        } finally {
+            // restore the local variable stack
+            context.popLocalVariables(mark);
+        }
+    }
+
+    @Override
+    public Sequence preEval(final Sequence seq) throws XPathException {
+        // determine whether to count down or up
+        this.step = hasPreviousOrderByDescending() ? -1 : 1;
+
+        // get the count start position
+        if (this.step == 1) {
+            this.count = 0;
+        } else {
+            this.count = seq.getItemCountLong() + 1;
+        }
+
+        return super.preEval(seq);
+    }
 
+    private boolean hasPreviousOrderByDescending() {
+        FLWORClause prev = getPreviousClause();
+        while (prev != null) {
+            switch (prev.getType()) {
+                case LET:
+                case GROUPBY:
+                case FOR:
+                    return false;
+                case ORDERBY:
+                   return isDescending(((OrderByClause) prev).getOrderSpecs());
+            }
+            prev = prev.getPreviousClause();
+        }
+        return true;
+    }
+    private boolean isDescending(final OrderSpec[] orderSpecs) {
+        for (final OrderSpec orderSpec : orderSpecs) {
+            if ((orderSpec.getModifiers() & OrderSpec.DESCENDING_ORDER) == OrderSpec.DESCENDING_ORDER) {
+                return true;
+            }
+        }
+        return false;
     }
 
     @Override
     public Sequence eval(final Sequence contextSequence, final Item contextItem) throws XPathException {
-        return null;
+        if (context.getProfiler().isEnabled()) {
+            context.getProfiler().start(this);
+            context.getProfiler().message(this, Profiler.DEPENDENCIES,
+                    "DEPENDENCIES", Dependency.getDependenciesName(this.getDependencies()));
+            if (contextSequence != null) {
+                context.getProfiler().message(this, Profiler.START_SEQUENCES,
+                        "CONTEXT SEQUENCE", contextSequence);
+            }
+            if (contextItem != null) {
+                context.getProfiler().message(this, Profiler.START_SEQUENCES,
+                        "CONTEXT ITEM", contextItem.toSequence());
+            }
+        }
+
+        context.expressionStart(this);
+
+        final Sequence resultSequence = new ValueSequence(unordered);
+
+        // update the count
+        count = count + step;
+
+        // Save the local variable stack
+        final LocalVariable mark = context.markLocalVariables(false);
+        try {
+
+            // Declare the count variable
+            final LocalVariable countVar = createVariable(varName);
+            countVar.setSequenceType(countVarType);
+            context.declareVariableBinding(countVar);
+
+            // set the binding for the count
+            countVar.setValue(new IntegerValue(count));
+
+            // eval the return expression on the window binding
+            resultSequence.addAll(returnExpr.eval(null, null));
+
+            // free resources
+            countVar.destroy(context, resultSequence);
+
+        } finally {
+            // restore the local variable stack
+            context.popLocalVariables(mark, resultSequence);
+        }
+
+        setActualReturnType(resultSequence.getItemType());
+
+        context.expressionEnd(this);
+        if (context.getProfiler().isEnabled()) {
+            context.getProfiler().end(this, "", resultSequence);
+        }
+
+        return resultSequence;
+    }
+
+    @Override
+    public Sequence postEval(Sequence seq) throws XPathException {
+        if (returnExpr instanceof FLWORClause) {
+            seq = ((FLWORClause)returnExpr).postEval(seq);
+        }
+        return super.postEval(seq);
     }
 
     @Override
@@ -67,4 +196,9 @@ public void dump(final ExpressionDumper dumper) {
         dumper.display(this.varName);
         dumper.endIndent().nl();
     }
+
+    @Override
+    public void accept(final ExpressionVisitor visitor) {
+        visitor.visitCountClause(this);
+    }
 }

exist-core/src/main/java/org/exist/xquery/ExpressionVisitor.java

@@ -74,6 +74,8 @@ public interface ExpressionVisitor {
 
     void visitLetExpression(LetExpr letExpr);
 
+    void visitCountClause(CountClause count);
+
     void visitOrderByClause(OrderByClause orderBy);
 
     void visitGroupByClause(GroupByClause groupBy);