This is an automated email from the ASF dual-hosted git repository. andy pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/jena.git
commit 3ec73bc78cf3490f94bc2b51d617ed15e68c5c09 Author: Andy Seaborne <[email protected]> AuthorDate: Mon Feb 16 14:16:50 2026 +0000 Reformat QueryIterators --- .../jena/sparql/engine/iterator/QueryIter2.java | 121 ++++++++-------- .../sparql/engine/iterator/QueryIterAbortable.java | 27 ++-- .../engine/iterator/QueryIterAddTripleTerm.java | 1 - .../engine/iterator/QueryIterCommonParent.java | 70 +++++---- .../sparql/engine/iterator/QueryIterConcat.java | 131 ++++++++--------- .../sparql/engine/iterator/QueryIterConvert.java | 65 ++++----- .../engine/iterator/QueryIterDefaulting.java | 113 ++++++++------- .../sparql/engine/iterator/QueryIterDistinct.java | 156 ++++++++++----------- .../engine/iterator/QueryIterDistinctMem.java | 38 +++-- .../engine/iterator/QueryIterDistinctReduced.java | 62 ++++---- .../iterator/QueryIterDistinguishedVars.java | 17 +-- .../sparql/engine/iterator/QueryIterGroup.java | 38 ++--- .../engine/iterator/QueryIterNullIterator.java | 23 ++- .../jena/sparql/engine/iterator/QueryIterPath.java | 57 ++++---- .../jena/sparql/engine/iterator/QueryIterPeek.java | 80 ++++++----- .../engine/iterator/QueryIterProcessBinding.java | 50 +++---- .../sparql/engine/iterator/QueryIterReduced.java | 42 +++--- .../sparql/engine/iterator/QueryIterSingleton.java | 50 +++---- .../sparql/engine/iterator/QueryIterSlice.java | 71 +++++----- .../jena/sparql/engine/iterator/QueryIterSub.java | 44 +++--- .../jena/sparql/engine/iterator/QueryIterTopN.java | 123 ++++++++-------- .../sparql/engine/iterator/QueryIterTracked.java | 52 ++++--- .../sparql/engine/iterator/QueryIterYieldN.java | 83 +++++------ .../sparql/engine/iterator/QueryIteratorCheck.java | 26 ++-- .../engine/iterator/QueryIteratorCloseable.java | 18 ++- .../engine/iterator/QueryIteratorLogging.java | 48 +++---- .../engine/iterator/QueryIteratorResultSet.java | 24 ++-- .../engine/iterator/QueryIteratorTiming.java | 90 ++++++------ 28 files changed, 818 insertions(+), 902 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIter2.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIter2.java index 68fa3ff967..dcfdcc2edb 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIter2.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIter2.java @@ -21,77 +21,74 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.atlas.io.IndentedWriter ; -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.Plan ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.serializer.SerializationContext ; +import org.apache.jena.atlas.io.IndentedWriter; +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.Plan; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.serializer.SerializationContext; /** - * This class marks a QueryIter that takes two QueryIterators as input. */ -public abstract class QueryIter2 extends QueryIter -{ - private QueryIterator leftInput ; - private QueryIterator rightInput ; - - public QueryIter2(QueryIterator left, QueryIterator right, ExecutionContext execCxt) - { - super(execCxt) ; - this.leftInput = left ; - this.rightInput = right ; + * This class marks a QueryIter that takes two QueryIterators as input. + */ +public abstract class QueryIter2 extends QueryIter { + private QueryIterator leftInput; + private QueryIterator rightInput; + + public QueryIter2(QueryIterator left, QueryIterator right, ExecutionContext execCxt) { + super(execCxt); + this.leftInput = left; + this.rightInput = right; } - - protected QueryIterator getLeft() { return leftInput ; } - protected QueryIterator getRight() { return rightInput ; } - + + protected QueryIterator getLeft() { return leftInput ; } + protected QueryIterator getRight() { return rightInput ; } + @Override - protected final - void closeIterator() - { - closeSubIterator() ; - performClose(leftInput) ; - performClose(rightInput) ; - leftInput = null ; - rightInput = null ; + protected final void closeIterator() { + closeSubIterator(); + performClose(leftInput); + performClose(rightInput); + leftInput = null; + rightInput = null; } - + @Override - protected final - void requestCancel() - { - requestSubCancel() ; - performRequestCancel(leftInput) ; - performRequestCancel(rightInput) ; + protected final void requestCancel() { + requestSubCancel(); + performRequestCancel(leftInput); + performRequestCancel(rightInput); } - + /** Cancellation of the query execution is happening */ - protected abstract void requestSubCancel() ; - - /** Pass on the close method - no need to close the left or right QueryIterators passed to the QueryIter2 constructor */ - protected abstract void closeSubIterator() ; - + protected abstract void requestSubCancel(); + + /** + * Pass on the close method - no need to close the left or right QueryIterators + * passed to the QueryIter2 constructor + */ + protected abstract void closeSubIterator(); + // Do better @Override - public void output(IndentedWriter out, SerializationContext sCxt) - { - out.println(Lib.className(this)) ; - out.incIndent() ; - - out.print(Plan.startMarker) ; - out.incIndent() ; - getLeft().output(out, sCxt) ; - out.decIndent() ; - //out.ensureStartOfLine() ; - out.println(Plan.finishMarker) ; - - out.print(Plan.startMarker) ; - out.incIndent() ; - getRight().output(out, sCxt) ; - out.decIndent() ; - //out.ensureStartOfLine() ; - out.println(Plan.finishMarker) ; - - out.decIndent() ; + public void output(IndentedWriter out, SerializationContext sCxt) { + out.println(Lib.className(this)); + out.incIndent(); + + out.print(Plan.startMarker); + out.incIndent(); + getLeft().output(out, sCxt); + out.decIndent(); + // out.ensureStartOfLine() ; + out.println(Plan.finishMarker); + + out.print(Plan.startMarker); + out.incIndent(); + getRight().output(out, sCxt); + out.decIndent(); + // out.ensureStartOfLine() ; + out.println(Plan.finishMarker); + + out.decIndent(); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAbortable.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAbortable.java index 6a527715ac..e00fbdf50e 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAbortable.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAbortable.java @@ -29,33 +29,30 @@ import org.apache.jena.sparql.engine.QueryIterator; import org.apache.jena.sparql.engine.binding.Binding; /** QueryIterator that calls a list of abort actions when a cancel happens. */ -public class QueryIterAbortable extends QueryIterPlainWrapper -{ - final private QueryIterator originalInput ; - private List<Abortable> killList ; +public class QueryIterAbortable extends QueryIterPlainWrapper { + final private QueryIterator originalInput; + private List<Abortable> killList; // The original input needs closing as well. - public QueryIterAbortable(Iterator<Binding> iterBinding, List<Abortable> killList, QueryIterator originalInput, ExecutionContext execCxt) - { - super(iterBinding, execCxt) ; - this.originalInput = originalInput ; - this.killList = killList ; + public QueryIterAbortable(Iterator<Binding> iterBinding, List<Abortable> killList, QueryIterator originalInput, + ExecutionContext execCxt) { + super(iterBinding, execCxt); + this.originalInput = originalInput; + this.killList = killList; } @Override - protected void closeIterator() - { + protected void closeIterator() { if ( originalInput != null ) originalInput.close(); - super.closeIterator() ; + super.closeIterator(); } @Override - protected void requestCancel() - { + protected void requestCancel() { if ( killList != null ) for ( Abortable it : killList ) - it.abort() ; + it.abort(); if ( originalInput != null ) originalInput.cancel(); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAddTripleTerm.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAddTripleTerm.java index cbb25ca5e7..809b3b9c31 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAddTripleTerm.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterAddTripleTerm.java @@ -77,5 +77,4 @@ public class QueryIterAddTripleTerm extends QueryIterProcessBinding { protected void details(IndentedWriter out, SerializationContext sCxt) { out.print(this.getClass().getSimpleName()+": ["+var+"] " + triple); } - } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterCommonParent.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterCommonParent.java index a7c2546452..86c7a2df22 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterCommonParent.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterCommonParent.java @@ -21,63 +21,59 @@ package org.apache.jena.sparql.engine.iterator; -import java.util.Iterator ; +import java.util.Iterator; -import org.apache.jena.atlas.logging.Log ; -import org.apache.jena.graph.Node ; -import org.apache.jena.sparql.ARQInternalErrorException ; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; +import org.apache.jena.atlas.logging.Log; +import org.apache.jena.graph.Node; +import org.apache.jena.sparql.ARQInternalErrorException; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.engine.binding.BindingBuilder; /** - * Yield new bindings, with a fixed parent, with values from an iterator. - * Parent must not have variables in common with the iterator stream. + * Yield new bindings, with a fixed parent, with values from an iterator. Parent must + * not have variables in common with the iterator stream. */ -public class QueryIterCommonParent extends QueryIterConvert -{ - public QueryIterCommonParent(QueryIterator input, Binding binding, ExecutionContext execCxt) - { - super(input, new ConverterExtend(binding) , execCxt) ; +public class QueryIterCommonParent extends QueryIterConvert { + public QueryIterCommonParent(QueryIterator input, Binding binding, ExecutionContext execCxt) { + super(input, new ConverterExtend(binding), execCxt); } // Extend (with checking) an iterator stream of binding to have a common parent. - static class ConverterExtend implements QueryIterConvert.Converter - { - private Binding parentBinding ; + static class ConverterExtend implements QueryIterConvert.Converter { + private Binding parentBinding; - ConverterExtend(Binding parent) { parentBinding = parent ; } + ConverterExtend(Binding parent) { + parentBinding = parent; + } @Override - public Binding convert(Binding b) - { + public Binding convert(Binding b) { if ( parentBinding == null || parentBinding.isEmpty() ) - return b ; + return b; // This is the result. - BindingBuilder b2 = Binding.builder(parentBinding) ; + BindingBuilder b2 = Binding.builder(parentBinding); - // Copy the resultSet bindings to the combined result binding with checking. - for ( Iterator<Var> iter = b.vars() ; iter.hasNext(); ) - { + // Copy the resultSet bindings to the combined result binding with + // checking. + for ( Iterator<Var> iter = b.vars() ; iter.hasNext() ; ) { Var v = iter.next(); - Node n = b.get(v) ; - if ( b2.contains(v) ) - { - Node n2 = b2.get(v) ; + Node n = b.get(v); + if ( b2.contains(v) ) { + Node n2 = b2.get(v); if ( n2.equals(n) ) - Log.warn(this, "Binding already for "+v+" (same value)" ) ; - else - { - Log.error(this, "Binding already for "+v+" (different values)" ) ; - throw new ARQInternalErrorException("Incompatible bindings for "+v) ; + Log.warn(this, "Binding already for " + v + " (same value)"); + else { + Log.error(this, "Binding already for " + v + " (different values)"); + throw new ARQInternalErrorException("Incompatible bindings for " + v); } } - b2.add(v, n) ; + b2.add(v, n); } - return b2.build() ; + return b2.build(); } } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConcat.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConcat.java index 57705f8d67..c8e2e8a3aa 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConcat.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConcat.java @@ -33,114 +33,97 @@ import org.apache.jena.sparql.engine.QueryIterator ; import org.apache.jena.sparql.engine.binding.Binding ; import org.apache.jena.sparql.serializer.SerializationContext ; - /** - * A query iterator that joins two or more iterators into a single iterator. */ + * A query iterator that joins two or more iterators into a single iterator. + */ -public class QueryIterConcat extends QueryIter -{ - boolean initialized = false ; - List<QueryIterator> iteratorList = new ArrayList<>() ; - Iterator<QueryIterator> iterator ; - QueryIterator currentQIter = null ; +public class QueryIterConcat extends QueryIter { + boolean initialized = false; + List<QueryIterator> iteratorList = new ArrayList<>(); + Iterator<QueryIterator> iterator; + QueryIterator currentQIter = null; - Binding binding ; - boolean doneFirst = false ; + Binding binding; + boolean doneFirst = false; - public QueryIterConcat(ExecutionContext context) - { - super(context) ; + public QueryIterConcat(ExecutionContext context) { + super(context); } - private void init() - { - if ( ! initialized ) - { - currentQIter = null ; + private void init() { + if ( !initialized ) { + currentQIter = null; if ( iterator == null ) - iterator = iteratorList.listIterator() ; + iterator = iteratorList.listIterator(); if ( iterator.hasNext() ) - currentQIter = iterator.next() ; - initialized = true ; + currentQIter = iterator.next(); + initialized = true; } } - - public void add(QueryIterator qIter) - { + + public void add(QueryIterator qIter) { if ( qIter != null ) - iteratorList.add(qIter) ; + iteratorList.add(qIter); } - - + @Override - protected boolean hasNextBinding() - { + protected boolean hasNextBinding() { if ( isFinished() ) - return false ; + return false; - init() ; + init(); if ( currentQIter == null ) - return false ; - - while ( ! currentQIter.hasNext() ) - { + return false; + + while (!currentQIter.hasNext()) { // End sub iterator - //currentQIter.close() ; - currentQIter = null ; + // currentQIter.close() ; + currentQIter = null; if ( iterator.hasNext() ) - currentQIter = iterator.next() ; - if ( currentQIter == null ) - { + currentQIter = iterator.next(); + if ( currentQIter == null ) { // No more. - //close() ; - return false ; + // close() ; + return false; } } - - return true ; + + return true; } @Override - protected Binding moveToNextBinding() - { - if ( ! hasNextBinding() ) - throw new NoSuchElementException(Lib.className(this)) ; + protected Binding moveToNextBinding() { + if ( !hasNextBinding() ) + throw new NoSuchElementException(Lib.className(this)); if ( currentQIter == null ) - throw new NoSuchElementException(Lib.className(this)) ; - - Binding binding = currentQIter.nextBinding() ; - return binding ; + throw new NoSuchElementException(Lib.className(this)); + + Binding binding = currentQIter.nextBinding(); + return binding; } - @Override - protected void closeIterator() - { - for ( QueryIterator qIter : iteratorList ) - { - performClose( qIter ); + protected void closeIterator() { + for ( QueryIterator qIter : iteratorList ) { + performClose(qIter); } } - + @Override - protected void requestCancel() - { - for ( QueryIterator qIter : iteratorList ) - { - performRequestCancel( qIter ); + protected void requestCancel() { + for ( QueryIterator qIter : iteratorList ) { + performRequestCancel(qIter); } } - + @Override - public void output(IndentedWriter out, SerializationContext sCxt) - { - out.println(Lib.className(this)) ; - out.incIndent() ; - for ( QueryIterator qIter : iteratorList ) - { - qIter.output( out, sCxt ); + public void output(IndentedWriter out, SerializationContext sCxt) { + out.println(Lib.className(this)); + out.incIndent(); + for ( QueryIterator qIter : iteratorList ) { + qIter.output(out, sCxt); } - out.decIndent() ; - out.ensureStartOfLine() ; + out.decIndent(); + out.ensureStartOfLine(); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConvert.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConvert.java index 2b97398cf3..6e46ab830a 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConvert.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterConvert.java @@ -21,55 +21,48 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.atlas.io.IndentedWriter ; -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.serializer.SerializationContext ; +import org.apache.jena.atlas.io.IndentedWriter; +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.serializer.SerializationContext; +/** + * Iterator over another QueryIterator, applying a converter function to each object + * that is returned by .next() + */ -/** Iterator over another QueryIterator, applying a converter function - * to each object that is returned by .next() */ - -public class QueryIterConvert extends QueryIter1 -{ - public interface Converter - { - public Binding convert(Binding obj) ; +public class QueryIterConvert extends QueryIter1 { + public interface Converter { + public Binding convert(Binding obj); } - - Converter converter ; - - public QueryIterConvert(QueryIterator iter, Converter c, ExecutionContext context) - { - super(iter, context) ; - converter = c ; + + private Converter converter; + + public QueryIterConvert(QueryIterator iter, Converter c, ExecutionContext context) { + super(iter, context); + converter = c; } - + @Override - protected void - closeSubIterator() {} - + protected void closeSubIterator() {} + @Override - protected void - requestSubCancel() {} + protected void requestSubCancel() {} @Override - public boolean hasNextBinding() - { - return getInput().hasNext() ; + public boolean hasNextBinding() { + return getInput().hasNext(); } @Override - public Binding moveToNextBinding() - { - return converter.convert(getInput().nextBinding()) ; + public Binding moveToNextBinding() { + return converter.convert(getInput().nextBinding()); } @Override - protected void details(IndentedWriter out, SerializationContext cxt) - { - out.println(Lib.className(this)) ; + protected void details(IndentedWriter out, SerializationContext cxt) { + out.println(Lib.className(this)); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDefaulting.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDefaulting.java index 047e4cb824..f56723ab99 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDefaulting.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDefaulting.java @@ -21,82 +21,81 @@ package org.apache.jena.sparql.engine.iterator; -import java.util.NoSuchElementException ; - -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; - -/** An iterator that returns at least one element from another iterator - * or a default value (once) if the wrapped iterator returns nothing. */ - -public class QueryIterDefaulting extends QueryIterSub -{ - Binding defaultObject ; - - boolean returnDefaultObject = false ; - boolean haveReturnedSomeObject = false ; - - public QueryIterDefaulting(QueryIterator cIter, Binding _defaultObject, ExecutionContext qCxt) - { - super(cIter, qCxt) ; - defaultObject = _defaultObject ; +import java.util.NoSuchElementException; + +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; + +/** + * An iterator that returns at least one element from another iterator or a default + * value (once) if the wrapped iterator returns nothing. + */ + +public class QueryIterDefaulting extends QueryIterSub { + Binding defaultObject; + + boolean returnDefaultObject = false; + boolean haveReturnedSomeObject = false; + + public QueryIterDefaulting(QueryIterator cIter, Binding _defaultObject, ExecutionContext qCxt) { + super(cIter, qCxt); + defaultObject = _defaultObject; + } + + /** + * Returns true if the returned binding was the default object. Undef if before + * the iterator's first .hasNext() + */ + public boolean wasDefaultObject() { + return returnDefaultObject; } - /** Returns true if the returned binding was the default object. Undef if before the iterator's first .hasNext() */ - public boolean wasDefaultObject() - { return returnDefaultObject ; } - @Override - protected boolean hasNextBinding() - { + protected boolean hasNextBinding() { if ( isFinished() ) - return false ; + return false; if ( iter != null && iter.hasNext() ) - return true ; - - // Wrapped iterator has ended (or does not exist). Have we returned anything yet? - + return true; + + // Wrapped iterator has ended (or does not exist). Have we returned anything + // yet? + if ( haveReturnedSomeObject ) - return false ; - - returnDefaultObject = true ; - return true ; + return false; + + returnDefaultObject = true; + return true; } @Override - protected Binding moveToNextBinding() - { + protected Binding moveToNextBinding() { if ( isFinished() ) - throw new NoSuchElementException(Lib.className(this)) ; - - if ( returnDefaultObject ) - { - haveReturnedSomeObject = true ; - return defaultObject ; + throw new NoSuchElementException(Lib.className(this)); + + if ( returnDefaultObject ) { + haveReturnedSomeObject = true; + return defaultObject; } - Binding binding = null ; + Binding binding = null; if ( iter != null && iter.hasNext() ) - binding = iter.next() ; - else - { + binding = iter.next(); + else { if ( haveReturnedSomeObject ) - throw new NoSuchElementException("DefaultingIterator - without hasNext call first") ; - binding = defaultObject ; + throw new NoSuchElementException("DefaultingIterator - without hasNext call first"); + binding = defaultObject; } - - haveReturnedSomeObject = true ; - return binding ; + + haveReturnedSomeObject = true; + return binding; } @Override - protected void requestSubCancel() - {} + protected void requestSubCancel() {} @Override - protected void closeSubIterator() - {} + protected void closeSubIterator() {} } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinct.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinct.java index 35a8a6b262..b6ef1cbaa8 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinct.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinct.java @@ -19,145 +19,145 @@ * SPDX-License-Identifier: Apache-2.0 */ -package org.apache.jena.sparql.engine.iterator ; +package org.apache.jena.sparql.engine.iterator; -import java.util.* ; +import java.util.*; -import org.apache.jena.atlas.data.* ; -import org.apache.jena.atlas.lib.InternalErrorException ; -import org.apache.jena.query.ARQ ; -import org.apache.jena.query.SortCondition ; -import org.apache.jena.sparql.ARQException ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.engine.binding.BindingComparator ; -import org.apache.jena.sparql.engine.binding.BindingProjectNamed ; +import org.apache.jena.atlas.data.*; +import org.apache.jena.atlas.lib.InternalErrorException; +import org.apache.jena.query.ARQ; +import org.apache.jena.query.SortCondition; +import org.apache.jena.sparql.ARQException; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.engine.binding.BindingComparator; +import org.apache.jena.sparql.engine.binding.BindingProjectNamed; import org.apache.jena.sparql.system.SerializationFactoryFinder; /** - * A QueryIterator that suppresses items already seen. This will stream results - * until a threshold is passed. At that point, it will fill a disk-backed - * {@link DistinctDataNet}, then yield - * not return any results until the input iterator has been exhausted. - * + * A QueryIterator that suppresses items already seen. This will stream results until + * a threshold is passed. At that point, it will fill a disk-backed + * {@link DistinctDataNet}, then yield, not return any results until the input + * iterator has been exhausted. + * * @see DistinctDataBag */ -public class QueryIterDistinct extends QueryIter1 -{ - private long memThreshold = Long.MAX_VALUE ; // Default "off" value. - /*package*/ DistinctDataBag<Binding> db = null ; - private Iterator<Binding> iterator = null ; - private Set<Binding> seen = new HashSet<>() ; - private Binding slot = null ; - private final List<SortCondition> preserveOrder; +public class QueryIterDistinct extends QueryIter1 { + private long memThreshold = Long.MAX_VALUE; + // Default "off" value. + /* package */ DistinctDataBag<Binding> db = null; + private Iterator<Binding> iterator = null; + private Set<Binding> seen = new HashSet<>(); + private Binding slot = null; + private final List<SortCondition> preserveOrder; public QueryIterDistinct(QueryIterator qIter, List<SortCondition> preserveOrder, ExecutionContext execCxt) { - super(qIter, execCxt) ; - this.preserveOrder = (preserveOrder!=null) ? preserveOrder : Collections.emptyList(); + super(qIter, execCxt); + this.preserveOrder = (preserveOrder != null) ? preserveOrder : Collections.emptyList(); if ( execCxt != null ) { - memThreshold = execCxt.getContext().getLong(ARQ.spillToDiskThreshold, memThreshold) ; + memThreshold = execCxt.getContext().getLong(ARQ.spillToDiskThreshold, memThreshold); if ( memThreshold < 0 ) - throw new ARQException("Bad spillToDiskThreshold: "+memThreshold) ; + throw new ARQException("Bad spillToDiskThreshold: " + memThreshold); } } - + @Override protected boolean hasNextBinding() { if ( slot != null ) - return true ; + return true; if ( iterator != null ) // Databag active. - return iterator.hasNext() ; - + return iterator.hasNext(); + // At this point, we are currently in the initial pre-threshold mode. if ( seen.size() < memThreshold ) { - Binding b = getInputNextUnseen() ; + Binding b = getInputNextUnseen(); if ( b == null ) - return false ; - seen.add(b) ; - slot = b ; - return true ; + return false; + seen.add(b); + slot = b; + return true; } - + // Hit the threshold. - loadDataBag() ; - // Switch to iterating from the data bag. - iterator = db.iterator() ; + loadDataBag(); + // Switch to iterating from the data bag. + iterator = db.iterator(); // Leave slot null. - return iterator.hasNext() ; + return iterator.hasNext(); } - + /** - * Load the data bag with. Filter incoming by the already seen in-memory elements. - * + * Load the data bag with. Filter incoming by the already seen in-memory + * elements. + * <p> * For DISTINCT-ORDER, and if DISTINCT spills then we need to take * account of the ORDER. The normal (non-spill case) already preserves the input * order, passing through the first occurence. It is only if a spill happens that * we need to ensure the spill buckets respect sort order. - */ + */ private void loadDataBag() { - ThresholdPolicy<Binding> policy = ThresholdPolicyFactory.policyFromContext(super.getExecContext().getContext()) ; - Comparator<Binding> comparator = new BindingComparator(preserveOrder, super.getExecContext()) ; - this.db = BagFactory.newDistinctBag(policy, SerializationFactoryFinder.bindingSerializationFactory(), comparator) ; - for(;;) { - Binding b = getInputNextUnseen() ; + ThresholdPolicy<Binding> policy = ThresholdPolicyFactory.policyFromContext(super.getExecContext().getContext()); + Comparator<Binding> comparator = new BindingComparator(preserveOrder, super.getExecContext()); + this.db = BagFactory.newDistinctBag(policy, SerializationFactoryFinder.bindingSerializationFactory(), comparator); + for ( ;; ) { + Binding b = getInputNextUnseen(); if ( b == null ) - break ; - db.add(b) ; + break; + db.add(b); } } - - /** Return the next binding from the input filtered by seen. - * This does not update seen. - * Returns null on end of input. - */ + + /** + * Return the next binding from the input filtered by seen. This does not update + * seen. Returns null on end of input. + */ private Binding getInputNextUnseen() { - while( getInput().hasNext() ) { - Binding b = getInputNext() ; + while (getInput().hasNext()) { + Binding b = getInputNext(); if ( seen.contains(b) ) - continue ; - return b ; + continue; + return b; } - return null ; + return null; } /** Return the binding from the input, hiding any variables to be ignored. */ private Binding getInputNext() { - Binding b = getInput().next() ; + Binding b = getInput().next(); // Hide unnamed and internal variables. - b = new BindingProjectNamed(b) ; - return b ; + b = new BindingProjectNamed(b); + return b; } @Override protected Binding moveToNextBinding() { if ( slot != null ) { - Binding b = slot ; - slot = null ; - return b ; + Binding b = slot; + slot = null; + return b; } if ( iterator != null ) { - Binding b = iterator.next() ; - return b ; + Binding b = iterator.next(); + return b; } - throw new InternalErrorException() ; + throw new InternalErrorException(); } @Override protected void closeSubIterator() { if ( db != null ) { - iterator = null ; - db.close() ; + iterator = null; + db.close(); } - db = null ; + db = null; } // We don't need to do anything. We're a QueryIter1 // and that handles the cancellation of the wrapped // iterator. @Override - protected void requestSubCancel() - { } + protected void requestSubCancel() {} } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctMem.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctMem.java index 84c72cbad5..b1f9745eca 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctMem.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctMem.java @@ -19,38 +19,34 @@ * SPDX-License-Identifier: Apache-2.0 */ -package org.apache.jena.sparql.engine.iterator ; +package org.apache.jena.sparql.engine.iterator; -import java.util.HashSet ; -import java.util.Set ; +import java.util.HashSet; +import java.util.Set; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; /** Memory limited QueryIterDistinct */ -public class QueryIterDistinctMem extends QueryIterDistinctReduced -{ - private Set<Binding> seen = new HashSet<>() ; +public class QueryIterDistinctMem extends QueryIterDistinctReduced { + private Set<Binding> seen = new HashSet<>(); - public QueryIterDistinctMem(QueryIterator iter, ExecutionContext context) - { - super(iter, context) ; + public QueryIterDistinctMem(QueryIterator iter, ExecutionContext context) { + super(iter, context); } @Override - protected void closeSubIterator() - { - seen = null ; - super.closeSubIterator() ; + protected void closeSubIterator() { + seen = null; + super.closeSubIterator(); } @Override - protected boolean isFreshSighting(Binding binding) - { + protected boolean isFreshSighting(Binding binding) { if ( seen.contains(binding) ) - return false ; - seen.add(binding) ; - return true ; + return false; + seen.add(binding); + return true; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctReduced.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctReduced.java index 75f24aee3a..2c38d28ebf 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctReduced.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinctReduced.java @@ -21,62 +21,56 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.engine.binding.BindingProjectNamed ; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.engine.binding.BindingProjectNamed; /** Implementation skeleton for DISTINCT and REDUCED. */ public abstract class QueryIterDistinctReduced extends QueryIter1 { - private Binding slot = null ; // ready to go. - + private Binding slot = null; // ready to go. + public QueryIterDistinctReduced(QueryIterator iter, ExecutionContext context) - { super(iter, context) ; } + { super(iter, context) ; } - // Subclasses will want to implement this as well. + // Subclasses will want to implement this as well. @Override protected void closeSubIterator() - { slot = null ; } + { slot = null; } @Override protected void requestSubCancel() { } - + @Override - final - protected boolean hasNextBinding() - { + final protected boolean hasNextBinding() { // Already waiting to go. if ( slot != null ) - return true ; - + return true; + // Always moves. - for ( ; getInput().hasNext() ; ) - { - Binding b = getInput().nextBinding() ; + for ( ; getInput().hasNext() ; ) { + Binding b = getInput().nextBinding(); // Hide unnamed and internal variables. - // Don't need to worry about rename scope vars - // (they are projected away in sub-SELECT ?var { ... }) - b = new BindingProjectNamed(b) ; - if ( isFreshSighting(b) ) - { - slot = b ; - return true ; + // Don't need to worry about rename scope vars + // (they are projected away in sub-SELECT ?var { ... }) + b = new BindingProjectNamed(b); + if ( isFreshSighting(b) ) { + slot = b; + return true; } } - return false ; + return false; } @Override - final - protected Binding moveToNextBinding() - { - Binding r = slot ; - slot = null ; - return r ; + final protected Binding moveToNextBinding() { + Binding r = slot; + slot = null; + return r; } - - protected abstract boolean isFreshSighting(Binding binding) ; + + protected abstract boolean isFreshSighting(Binding binding); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinguishedVars.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinguishedVars.java index bf7c826a6b..156311dadb 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinguishedVars.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterDistinguishedVars.java @@ -26,25 +26,22 @@ import org.apache.jena.sparql.engine.QueryIterator ; import org.apache.jena.sparql.engine.binding.Binding ; import org.apache.jena.sparql.engine.binding.BindingProjectNamed ; -/** Filter bindings for distinguished variables only +/** Filter bindings for distinguished variables only * Currently unused. */ public class QueryIterDistinguishedVars extends QueryIterConvert { - public QueryIterDistinguishedVars(QueryIterator iter, ExecutionContext context) - { - super(iter, conv, context) ; + public QueryIterDistinguishedVars(QueryIterator iter, ExecutionContext context) { + super(iter, conv, context); } - static Converter conv = new ProjectWrap() ; + static Converter conv = new ProjectWrap(); - static class ProjectWrap implements Converter - { + static class ProjectWrap implements Converter { @Override - public Binding convert(Binding binding) - { - return new BindingProjectNamed(binding) ; + public Binding convert(Binding binding) { + return new BindingProjectNamed(binding); } } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterGroup.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterGroup.java index c8c2deb774..9584354946 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterGroup.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterGroup.java @@ -21,27 +21,27 @@ package org.apache.jena.sparql.engine.iterator; -import java.util.ArrayList ; -import java.util.Collection ; -import java.util.Iterator ; -import java.util.List ; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; import org.apache.commons.collections4.MultiMapUtils; import org.apache.commons.collections4.MultiValuedMap; -import org.apache.jena.atlas.iterator.Iter ; -import org.apache.jena.atlas.iterator.IteratorDelayedInitialization ; -import org.apache.jena.atlas.lib.Pair ; -import org.apache.jena.graph.Node ; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.core.VarExprList ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; +import org.apache.jena.atlas.iterator.Iter; +import org.apache.jena.atlas.iterator.IteratorDelayedInitialization; +import org.apache.jena.atlas.lib.Pair; +import org.apache.jena.graph.Node; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.core.VarExprList; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; import org.apache.jena.sparql.engine.binding.BindingBuilder; -import org.apache.jena.sparql.engine.binding.BindingFactory ; -import org.apache.jena.sparql.expr.ExprAggregator ; -import org.apache.jena.sparql.expr.NodeValue ; -import org.apache.jena.sparql.expr.aggregate.Accumulator ; +import org.apache.jena.sparql.engine.binding.BindingFactory; +import org.apache.jena.sparql.expr.ExprAggregator; +import org.apache.jena.sparql.expr.NodeValue; +import org.apache.jena.sparql.expr.aggregate.Accumulator; public class QueryIterGroup extends QueryIterPlainWrapper { @@ -70,7 +70,7 @@ public class QueryIterGroup extends QueryIterPlainWrapper super.closeIterator(); } - private static Pair<Var, Accumulator> placeholder = Pair.create((Var)null, (Accumulator)null) ; + private static Pair<Var, Accumulator> placeholder = Pair.create((Var)null, (Accumulator)null); private static Iterator<Binding> calc(final QueryIterator iter, final VarExprList groupVarExpr, @@ -90,7 +90,7 @@ public class QueryIterGroup extends QueryIterPlainWrapper if ( noInput ) { if ( hasGroupBy ) // GROUP - return Iter.nullIterator() ; + return Iter.nullIterator(); if ( ! hasAggregators ) { // No GROUP BY, no aggregators. One result row of no columns. return Iter.singletonIterator(BindingFactory.binding()); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterNullIterator.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterNullIterator.java index ffe4d997e0..11e8faa445 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterNullIterator.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterNullIterator.java @@ -34,28 +34,27 @@ import org.apache.jena.sparql.serializer.SerializationContext ; public class QueryIterNullIterator extends QueryIter { - public static QueryIterator create(ExecutionContext qCxt) { return new QueryIterNullIterator(qCxt) ; } - - // Or QueryIterYieldN with N = 0 ; - // but sometimes it clearer just to w-r-i-t-e the code. - + public static QueryIterator create(ExecutionContext qCxt) { return new QueryIterNullIterator(qCxt); } + public QueryIterNullIterator(ExecutionContext qCxt) { super(qCxt) ; } @Override - protected boolean hasNextBinding() - { return false ; } + protected boolean hasNextBinding() { + return false; + } @Override protected Binding moveToNextBinding() - { throw new NoSuchElementException(Lib.className(this)) ; } + { throw new NoSuchElementException(Lib.className(this)); } @Override protected void closeIterator() {} - + @Override - protected void requestCancel() { } + protected void requestCancel() {} @Override - public void output(IndentedWriter out, SerializationContext sCxt) - { out.println(Lib.className(this)) ; } + public void output(IndentedWriter out, SerializationContext sCxt) { + out.println(Lib.className(this)); + } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPath.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPath.java index 1b88e9cda9..37c2d15b2b 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPath.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPath.java @@ -21,43 +21,38 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.atlas.io.IndentedWriter ; -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.sparql.core.TriplePath ; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.path.PathLib ; -import org.apache.jena.sparql.serializer.SerializationContext ; +import org.apache.jena.atlas.io.IndentedWriter; +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.sparql.core.TriplePath; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.path.PathLib; +import org.apache.jena.sparql.serializer.SerializationContext; -public class QueryIterPath extends QueryIterRepeatApply -{ - private TriplePath triplePath ; - private Var varSubject = null ; - private Var varObject = null ; - +public class QueryIterPath extends QueryIterRepeatApply { + private TriplePath triplePath; + private Var varSubject = null; + private Var varObject = null; - public QueryIterPath(TriplePath triplePath, QueryIterator input, ExecutionContext context) - { - super(input, context) ; - this.triplePath = triplePath ; + public QueryIterPath(TriplePath triplePath, QueryIterator input, ExecutionContext context) { + super(input, context); + this.triplePath = triplePath; } @Override - protected QueryIterator nextStage(Binding binding) - { - QueryIterator qIter = PathLib.execTriplePath(binding, triplePath, getExecContext()) ; - return qIter ; + protected QueryIterator nextStage(Binding binding) { + QueryIterator qIter = PathLib.execTriplePath(binding, triplePath, getExecContext()); + return qIter; } - + @Override - protected void details(IndentedWriter out, SerializationContext sCxt) - { - out.print(Lib.className(this)) ; - out.println() ; - out.incIndent() ; - out.print(triplePath.toString()) ; - out.decIndent() ; + protected void details(IndentedWriter out, SerializationContext sCxt) { + out.print(Lib.className(this)); + out.println(); + out.incIndent(); + out.print(triplePath.toString()); + out.decIndent(); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPeek.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPeek.java index ddb4ce5c9a..99fb7c57ea 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPeek.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterPeek.java @@ -21,63 +21,61 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.sparql.ARQInternalErrorException ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; +import org.apache.jena.sparql.ARQInternalErrorException; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; -public class QueryIterPeek extends QueryIter1 -{ - private Binding binding = null ; - private boolean closed = false ; +public class QueryIterPeek extends QueryIter1 { + private Binding binding = null; + private boolean closed = false; - public static QueryIterPeek create(QueryIterator iterator, ExecutionContext cxt) - { - if ( iterator instanceof QueryIterPeek) - return (QueryIterPeek)iterator ; - return new QueryIterPeek(iterator, cxt) ; + public static QueryIterPeek create(QueryIterator iterator, ExecutionContext cxt) { + if ( iterator instanceof QueryIterPeek ) + return (QueryIterPeek)iterator; + return new QueryIterPeek(iterator, cxt); } - private QueryIterPeek(QueryIterator iterator, ExecutionContext cxt) - { - super(iterator, cxt) ; + private QueryIterPeek(QueryIterator iterator, ExecutionContext cxt) { + super(iterator, cxt); } - /** Returns the next binding without moving on. Returns "null" for no such element. */ - public Binding peek() - { - if ( closed ) return null ; - if ( ! hasNextBinding() ) - return null ; - return binding ; + /** + * Returns the next binding without moving on. Returns "null" for no such + * element. + */ + public Binding peek() { + if ( closed ) + return null; + if ( !hasNextBinding() ) + return null; + return binding; } @Override - protected boolean hasNextBinding() - { + protected boolean hasNextBinding() { if ( binding != null ) - return true ; - if ( ! getInput().hasNext() ) - return false ; - binding = getInput().nextBinding() ; - return true ; + return true; + if ( !getInput().hasNext() ) + return false; + binding = getInput().nextBinding(); + return true; } @Override - protected Binding moveToNextBinding() - { - if ( ! hasNextBinding() ) - throw new ARQInternalErrorException("No next binding") ; - Binding b = binding ; - binding = null ; - return b ; + protected Binding moveToNextBinding() { + if ( !hasNextBinding() ) + throw new ARQInternalErrorException("No next binding"); + Binding b = binding; + binding = null; + return b; } @Override - protected void closeSubIterator() - { closed = true ; } + protected void closeSubIterator() { + closed = true; + } @Override - protected void requestSubCancel() - { } + protected void requestSubCancel() {} } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterProcessBinding.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterProcessBinding.java index 6fd8487af7..162ada058e 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterProcessBinding.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterProcessBinding.java @@ -19,17 +19,17 @@ * SPDX-License-Identifier: Apache-2.0 */ -package org.apache.jena.sparql.engine.iterator ; +package org.apache.jena.sparql.engine.iterator; -import java.util.NoSuchElementException ; +import java.util.NoSuchElementException; import java.util.concurrent.atomic.AtomicBoolean; -import org.apache.jena.atlas.lib.Lib ; +import org.apache.jena.atlas.lib.Lib; import org.apache.jena.query.QueryCancelledException; -import org.apache.jena.sparql.ARQInternalErrorException ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; +import org.apache.jena.sparql.ARQInternalErrorException; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; /** * An iterator that applies a condition. The condition may return a different @@ -41,14 +41,14 @@ public abstract class QueryIterProcessBinding extends QueryIter1 { * Process the binding - return null for "not accept". Subclasses may return a * different Binding to the argument and the result is the returned Binding. */ - abstract public Binding accept(Binding binding) ; + abstract public Binding accept(Binding binding); - private Binding nextBinding ; - private final AtomicBoolean signalCancel ; + private Binding nextBinding; + private final AtomicBoolean signalCancel; public QueryIterProcessBinding(QueryIterator qIter, ExecutionContext context) { - super(qIter, context) ; - nextBinding = null ; + super(qIter, context); + nextBinding = null; AtomicBoolean signal; try { signal = context.getCancelSignal(); @@ -67,27 +67,27 @@ public abstract class QueryIterProcessBinding extends QueryIter1 { protected boolean hasNextBinding() { // Needs to be idempotent.? if ( isFinished() ) - return false ; + return false; if ( nextBinding != null ) - return true ; + return true; // Null iterator. if ( getInput() == null ) - throw new ARQInternalErrorException(Lib.className(this) + ": Null iterator") ; + throw new ARQInternalErrorException(Lib.className(this) + ": Null iterator"); while (getInput().hasNext()) { checkCancelled(); // Skip forward until a binding to return is found. - Binding input = getInput().nextBinding() ; - Binding output = accept(input) ; + Binding input = getInput().nextBinding(); + Binding output = accept(input); if ( output != null ) { - nextBinding = output ; - return true ; + nextBinding = output; + return true; } } - nextBinding = null ; - return false ; + nextBinding = null; + return false; } private final void checkCancelled() { @@ -105,11 +105,11 @@ public abstract class QueryIterProcessBinding extends QueryIter1 { @Override public Binding moveToNextBinding() { if ( hasNext() ) { - Binding r = nextBinding ; - nextBinding = null ; - return r ; + Binding r = nextBinding; + nextBinding = null; + return r; } - throw new NoSuchElementException() ; + throw new NoSuchElementException(); } @Override diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterReduced.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterReduced.java index 440f32fd51..afae8d6d88 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterReduced.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterReduced.java @@ -21,36 +21,34 @@ package org.apache.jena.sparql.engine.iterator; -import java.util.ArrayList ; -import java.util.List ; +import java.util.ArrayList; +import java.util.List; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; -public class QueryIterReduced extends QueryIterDistinctReduced -{ - List<Binding> window = new ArrayList<>() ; - int N = 1 ; - - public QueryIterReduced(QueryIterator iter, ExecutionContext context) - { super(iter, context) ; } +public class QueryIterReduced extends QueryIterDistinctReduced { + List<Binding> window = new ArrayList<>(); + int N = 1; + + public QueryIterReduced(QueryIterator iter, ExecutionContext context) { + super(iter, context); + } @Override - protected void closeSubIterator() - { - window = null ; - super.closeSubIterator() ; + protected void closeSubIterator() { + window = null; + super.closeSubIterator(); } @Override - protected boolean isFreshSighting(Binding b) - { + protected boolean isFreshSighting(Binding b) { if ( window.contains(b) ) - return false ; + return false; if ( window.size() >= N ) - window.remove(window.size()-1) ; - window.add(0, b) ; - return true ; + window.remove(window.size() - 1); + window.add(0, b); + return true; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSingleton.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSingleton.java index 351a13136b..b4d56de563 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSingleton.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSingleton.java @@ -21,46 +21,38 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.atlas.io.IndentedWriter ; -import org.apache.jena.graph.Node ; -import org.apache.jena.sparql.core.Var ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.engine.binding.BindingFactory ; -import org.apache.jena.sparql.serializer.SerializationContext ; +import org.apache.jena.atlas.io.IndentedWriter; +import org.apache.jena.graph.Node; +import org.apache.jena.sparql.core.Var; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.engine.binding.BindingFactory; +import org.apache.jena.sparql.serializer.SerializationContext; /** A singleton iterator */ -public class QueryIterSingleton extends QueryIterYieldN -{ +public class QueryIterSingleton extends QueryIterYieldN { // A common usage? - public static QueryIterSingleton create(Binding parent, Var var, Node value, ExecutionContext execCxt) - { - Binding b = BindingFactory.binding(parent, var, value) ; - return QueryIterSingleton.create(b, execCxt) ; + public static QueryIterSingleton create(Binding parent, Var var, Node value, ExecutionContext execCxt) { + Binding b = BindingFactory.binding(parent, var, value); + return QueryIterSingleton.create(b, execCxt); } - - public static QueryIterSingleton create(Binding binding, ExecutionContext execCxt) - { - return new QueryIterSingleton(binding, execCxt) ; + + public static QueryIterSingleton create(Binding binding, ExecutionContext execCxt) { + return new QueryIterSingleton(binding, execCxt); } private QueryIterSingleton(Binding binding) // Not needed { - this(binding, null) ; + this(binding, null); } - - protected QueryIterSingleton(Binding binding, ExecutionContext context) - { - super(1, binding, context) ; + + protected QueryIterSingleton(Binding binding, ExecutionContext context) { + super(1, binding, context); } - + @Override - public void output(IndentedWriter out, SerializationContext sCxt) - { - out.print("QueryIterSingleton "+binding); + public void output(IndentedWriter out, SerializationContext sCxt) { + out.print("QueryIterSingleton " + binding); } - -// @Override -// public void closeIterator() { super.closeIterator() ; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSlice.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSlice.java index 204f22c388..2d9d4895b0 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSlice.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSlice.java @@ -34,67 +34,66 @@ public class QueryIterSlice extends QueryIter1 long count = 0 ; long limit ; long offset ; - + /** Create an iterator that limits the number of returns of * another CloseableIterator. - * - * @param cIter The closable iterator to throttle + * + * @param cIter The closable iterator to throttle * @param startPosition Offset of start after - 0 is the no-op. - * @param numItems Maximum number of items to yield. + * @param numItems Maximum number of items to yield. */ - - public QueryIterSlice(QueryIterator cIter, long startPosition, long numItems, ExecutionContext context) - { - super(cIter, context) ; - - offset = startPosition ; + + public QueryIterSlice(QueryIterator cIter, long startPosition, long numItems, ExecutionContext context) { + super(cIter, context); + + offset = startPosition; if ( offset == Query.NOLIMIT ) - offset = 0 ; - - limit = numItems ; + offset = 0; + + limit = numItems; if ( limit == Query.NOLIMIT ) - limit = Long.MAX_VALUE ; + limit = Long.MAX_VALUE; if ( limit < 0 ) - throw new QueryExecException("Negative LIMIT: "+limit) ; + throw new QueryExecException("Negative LIMIT: " + limit); if ( offset < 0 ) - throw new QueryExecException("Negative OFFSET: "+offset) ; - - count = 0 ; + throw new QueryExecException("Negative OFFSET: " + offset); + + count = 0; // Offset counts from 0 (the no op). - for ( int i = 0 ; i < offset ; i++ ) - { + for ( int i = 0 ; i < offset ; i++ ) { // Not subtle - if ( !cIter.hasNext() ) { close() ; break ; } - cIter.next() ; + if ( !cIter.hasNext() ) { + close(); + break; + } + cIter.next(); } } - + @Override - protected boolean hasNextBinding() - { + protected boolean hasNextBinding() { if ( isFinished() ) return false; - - if ( ! getInput().hasNext() ) - return false ; - + + if ( !getInput().hasNext() ) + return false; + if ( count >= limit ) - return false ; + return false; - return true ; + return true; } @Override - protected Binding moveToNextBinding() - { - count ++ ; - return getInput().nextBinding() ; + protected Binding moveToNextBinding() { + count++; + return getInput().nextBinding(); } @Override protected void closeSubIterator() {} - + @Override protected void requestSubCancel() {} } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSub.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSub.java index d70423cdd4..11cf328619 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSub.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterSub.java @@ -30,34 +30,32 @@ import org.apache.jena.sparql.engine.QueryIterator ; */ public abstract class QueryIterSub extends QueryIter { - protected QueryIterator iter ; - - public QueryIterSub(QueryIterator input, ExecutionContext execCxt) - { - super(execCxt) ; - this.iter = input ; + protected QueryIterator iter ; + + public QueryIterSub(QueryIterator input, ExecutionContext execCxt) { + super(execCxt); + this.iter = input; } - + @Override - protected final - void closeIterator() - { - closeSubIterator() ; - performClose(iter) ; - iter = null ; + protected final void closeIterator() { + closeSubIterator(); + performClose(iter); + iter = null; } - + @Override - protected final - void requestCancel() - { - requestSubCancel() ; - performRequestCancel(iter) ; + protected final void requestCancel() { + requestSubCancel(); + performRequestCancel(iter); } - + /** Cancellation of the query execution is happening */ - protected abstract void requestSubCancel() ; - - /** Pass on the close method - no need to close the QueryIterator passed to the QueryIter1 constructor */ + protected abstract void requestSubCancel(); + + /** + * Pass on the close method - no need to close the QueryIterator passed to the + * QueryIter1 constructor + */ protected abstract void closeSubIterator() ; } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTopN.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTopN.java index c82f707f2d..95f5b7f82b 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTopN.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTopN.java @@ -23,68 +23,69 @@ package org.apache.jena.sparql.engine.iterator; import static java.util.Arrays.asList; -import java.util.Arrays ; -import java.util.Comparator ; -import java.util.Iterator ; -import java.util.List ; -import java.util.PriorityQueue ; - -import org.apache.jena.atlas.iterator.Iter ; -import org.apache.jena.atlas.iterator.IteratorDelayedInitialization ; -import org.apache.jena.query.Query ; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; +import java.util.PriorityQueue; + +import org.apache.jena.atlas.iterator.Iter; +import org.apache.jena.atlas.iterator.IteratorDelayedInitialization; +import org.apache.jena.query.Query; import org.apache.jena.query.QueryCancelledException; -import org.apache.jena.query.QueryExecException ; -import org.apache.jena.query.SortCondition ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.engine.binding.BindingComparator ; +import org.apache.jena.query.QueryExecException; +import org.apache.jena.query.SortCondition; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.engine.binding.BindingComparator; public class QueryIterTopN extends QueryIterPlainWrapper { - /* We want to keep the N least elements (overall return is an ascending sequence so limit+ascending = least). + /* + * We want to keep the N least elements (overall return is an ascending sequence so limit+ascending = least). * To do that we keep a priority heap of upto N elements, ordered descending. * To keep another element, it must be less than the max so far. * This leaves the least N in the heap. */ private final QueryIterator embeddedIterator; // Keep a record of the underlying source for .cancel. - private PriorityQueue<Binding> heap ; - private long limit ; - private final boolean distinct ; + private PriorityQueue<Binding> heap; + private long limit; + private final boolean distinct; public QueryIterTopN(QueryIterator qIter, List<SortCondition> conditions, long numItems, boolean distinct, ExecutionContext context) { - this(qIter, new BindingComparator(conditions, context), numItems, distinct, context) ; + this(qIter, new BindingComparator(conditions, context), numItems, distinct, context); } public QueryIterTopN(QueryIterator qIter, Comparator<Binding> comparator, long numItems, boolean distinct, ExecutionContext context) { - super(null, context) ; - this.embeddedIterator = qIter ; - this.distinct = distinct ; + super(null, context); + this.embeddedIterator = qIter; + this.distinct = distinct; - limit = numItems ; + limit = numItems; if ( limit == Query.NOLIMIT ) - limit = Long.MAX_VALUE ; + limit = Long.MAX_VALUE; if ( limit < 0 ) - throw new QueryExecException("Negative LIMIT: " + limit) ; + throw new QueryExecException("Negative LIMIT: " + limit); if ( limit == 0 ) { // Keep Java happy. - Iterator<Binding> iter0 = Iter.nullIterator() ; - setIterator(iter0) ; - qIter.close() ; - return ; + Iterator<Binding> iter0 = Iter.nullIterator(); + setIterator(iter0); + qIter.close(); + return; } // Keep heap with maximum accessible. - this.heap = new PriorityQueue<>((int)numItems, comparator.reversed()) ; - this.setIterator(sortTopN(qIter, comparator)) ; + this.heap = new PriorityQueue<>((int)numItems, comparator.reversed()); + this.setIterator(sortTopN(qIter, comparator)); } @Override public void requestCancel() { - this.embeddedIterator.cancel() ; - super.requestCancel() ; + this.embeddedIterator.cancel(); + super.requestCancel(); } @Override @@ -97,38 +98,38 @@ public class QueryIterTopN extends QueryIterPlainWrapper return new IteratorDelayedInitialization<Binding>() { @Override protected Iterator<Binding> initializeIterator() { - try { - while ( qIter.hasNext() ) { - Binding binding = qIter.next() ; - if ( heap.size() < limit ) - add(binding) ; - else { - Binding currentMaxLeastN = heap.peek() ; - if ( comparator.compare(binding, currentMaxLeastN) < 0 ) - add(binding) ; - } - } - qIter.close() ; - Binding[] y = heap.toArray(new Binding[]{}) ; - heap = null ; - Arrays.sort(y, comparator) ; - return asList(y).iterator() ; - } - catch (QueryCancelledException e) { - QueryIterTopN.this.close(); - this.close(); - throw e; - } - } - } ; + try { + while ( qIter.hasNext() ) { + Binding binding = qIter.next(); + if ( heap.size() < limit ) + add(binding); + else { + Binding currentMaxLeastN = heap.peek(); + if ( comparator.compare(binding, currentMaxLeastN) < 0 ) + add(binding); + } + } + qIter.close(); + Binding[] y = heap.toArray(new Binding[]{}); + heap = null; + Arrays.sort(y, comparator); + return asList(y).iterator(); + } + catch (QueryCancelledException e) { + QueryIterTopN.this.close(); + this.close(); + throw e; + } + } + }; } private void add(Binding binding) { if ( distinct && heap.contains(binding) ) - return ; + return; if ( heap.size() >= limit ) - heap.poll() ; // Remove front element. - heap.add(binding) ; + heap.poll(); // Remove front element. + heap.add(binding); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTracked.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTracked.java index f1ddff0536..79d2113137 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTracked.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterTracked.java @@ -21,46 +21,44 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.util.iterator.NiceIterator ; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.util.iterator.NiceIterator; /** Track a QueryIterator */ -public class QueryIterTracked extends QueryIter -{ - QueryIterator iterator = null ; - +public class QueryIterTracked extends QueryIter { + QueryIterator iterator = null; + /** Use QueryIter.makeTracked */ - QueryIterTracked(QueryIterator iter, ExecutionContext execCxt) - { - super(execCxt) ; - iterator = iter ; + QueryIterTracked(QueryIterator iter, ExecutionContext execCxt) { + super(execCxt); + iterator = iter; } @Override - protected boolean hasNextBinding() { return iterator.hasNext() ; } - + protected boolean hasNextBinding() { + return iterator.hasNext(); + } + @Override - protected Binding moveToNextBinding() { return iterator.next() ; } + protected Binding moveToNextBinding() { + return iterator.next(); + } @Override - protected void closeIterator() - { - if ( iterator != null ) - { - NiceIterator.close(iterator) ; - iterator = null ; + protected void closeIterator() { + if ( iterator != null ) { + NiceIterator.close(iterator); + iterator = null; } } - + @Override - protected void requestCancel() - { - if ( iterator != null ) - { - iterator.cancel(); + protected void requestCancel() { + if ( iterator != null ) { + iterator.cancel(); } } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterYieldN.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterYieldN.java index 19aa39f95f..526e2c5257 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterYieldN.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIterYieldN.java @@ -21,67 +21,60 @@ package org.apache.jena.sparql.engine.iterator; -import java.util.NoSuchElementException ; +import java.util.NoSuchElementException; -import org.apache.jena.atlas.io.IndentedWriter ; -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.serializer.SerializationContext ; +import org.apache.jena.atlas.io.IndentedWriter; +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.serializer.SerializationContext; /** A query iterator that yields the same thing N times. */ -public class QueryIterYieldN extends QueryIter -{ - protected int limitYielded ; - protected int countYielded = 0 ; - protected Binding binding ; - - public QueryIterYieldN(int num, Binding b) - { - this(num, b, null) ; +public class QueryIterYieldN extends QueryIter { + protected int limitYielded; + protected int countYielded = 0; + protected Binding binding; + + public QueryIterYieldN(int num, Binding b) { + this(num, b, null); } - - public QueryIterYieldN(int num, Binding b, ExecutionContext context) - { - super(context) ; - binding = b ; - limitYielded = num ; + + public QueryIterYieldN(int num, Binding b, ExecutionContext context) { + super(context); + binding = b; + limitYielded = num; } - - public Binding getBinding() { return binding ; } - + + public Binding getBinding() { + return binding; + } + @Override - protected boolean hasNextBinding() - { - return countYielded < limitYielded ; + protected boolean hasNextBinding() { + return countYielded < limitYielded; } - + @Override - protected Binding moveToNextBinding() - { - if ( ! hasNextBinding() ) + protected Binding moveToNextBinding() { + if ( !hasNextBinding() ) // Try to get the class name as specific as possible for subclasses - throw new NoSuchElementException(Lib.className(this)) ; - countYielded++ ; - return binding ; + throw new NoSuchElementException(Lib.className(this)); + countYielded++; + return binding; } @Override - protected void closeIterator() - { - //binding = null ; + protected void closeIterator() { + // binding = null ; } - + @Override - protected void requestCancel() - { - } - + protected void requestCancel() {} + @Override - public void output(IndentedWriter out, SerializationContext sCxt) - { - out.print("QueryIterYieldN: "+limitYielded+" of "+binding); + public void output(IndentedWriter out, SerializationContext sCxt) { + out.print("QueryIterYieldN: " + limitYielded + " of " + binding); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCheck.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCheck.java index ad3a8226f3..a1f56b347d 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCheck.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCheck.java @@ -21,22 +21,22 @@ package org.apache.jena.sparql.engine.iterator; -import java.util.Iterator ; +import java.util.Iterator; -import org.apache.jena.atlas.io.IndentedWriter ; -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.atlas.logging.Log ; +import org.apache.jena.atlas.io.IndentedWriter; +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.atlas.logging.Log; import org.apache.jena.query.QueryException; import org.apache.jena.sparql.SystemARQ; -import org.apache.jena.sparql.engine.ExecutionContext ; -import org.apache.jena.sparql.engine.QueryIterator ; -import org.apache.jena.sparql.serializer.SerializationContext ; +import org.apache.jena.sparql.engine.ExecutionContext; +import org.apache.jena.sparql.engine.QueryIterator; +import org.apache.jena.sparql.serializer.SerializationContext; import org.apache.jena.sparql.util.Symbol; /** Query iterator that checks everything was closed correctly */ public class QueryIteratorCheck extends QueryIteratorWrapper { - private ExecutionContext execCxt ; + private ExecutionContext execCxt; /** * Whether detection of open iterator should raise an {@link OpenIteratorException}. @@ -52,10 +52,10 @@ public class QueryIteratorCheck extends QueryIteratorWrapper */ public static class OpenIteratorException extends RuntimeException { private static final long serialVersionUID = 1L; - public OpenIteratorException() { super() ; } - public OpenIteratorException(Throwable cause) { super(cause) ; } - public OpenIteratorException(String msg) { super(msg) ; } - public OpenIteratorException(String msg, Throwable cause) { super(msg, cause) ; } + public OpenIteratorException() { super(); } + public OpenIteratorException(Throwable cause) { super(cause); } + public OpenIteratorException(String msg) { super(msg); } + public OpenIteratorException(String msg, Throwable cause) { super(msg, cause); } } private QueryIteratorCheck(QueryIterator qIter, ExecutionContext execCxt) { @@ -75,7 +75,7 @@ public class QueryIteratorCheck extends QueryIteratorWrapper // Be silent about ourselves. @Override public void output(IndentedWriter out, SerializationContext sCxt) - { iterator.output(out, sCxt) ; } + { iterator.output(out, sCxt); } public static void checkForOpenIterators(ExecutionContext execContext) { dump(execContext, false); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCloseable.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCloseable.java index ce65012a8b..b902a91a2a 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCloseable.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorCloseable.java @@ -26,18 +26,16 @@ import org.apache.jena.sparql.engine.QueryIterator ; public class QueryIteratorCloseable extends QueryIteratorWrapper { - private Closeable closeable ; + private Closeable closeable; - public QueryIteratorCloseable(QueryIterator qIter, Closeable closeable) - { - super(qIter) ; - this.closeable = closeable ; + public QueryIteratorCloseable(QueryIterator qIter, Closeable closeable) { + super(qIter); + this.closeable = closeable; } - + @Override - public void close() - { - closeable.close() ; - super.close() ; + public void close() { + closeable.close(); + super.close(); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorLogging.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorLogging.java index 34a403031a..a7b74ac0c8 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorLogging.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorLogging.java @@ -27,47 +27,41 @@ import org.slf4j.Logger ; import org.slf4j.LoggerFactory ; -/** Intercept and print iterator operations */ +/** Intercept and print iterator operations */ -public class QueryIteratorLogging extends QueryIteratorWrapper -{ - private Logger log = null ; - private boolean logging = true ; // Fine grain control of logging. +public class QueryIteratorLogging extends QueryIteratorWrapper { + private Logger log = null; + private boolean logging = true; // Fine grain control of logging. - public QueryIteratorLogging(QueryIterator input) - { - super(input) ; - log = LoggerFactory.getLogger(input.getClass()) ; + public QueryIteratorLogging(QueryIterator input) { + super(input); + log = LoggerFactory.getLogger(input.getClass()); } - + @Override - protected boolean hasNextBinding() - { - boolean b = super.hasNextBinding() ; + protected boolean hasNextBinding() { + boolean b = super.hasNextBinding(); if ( logging ) - log.info("hasNextBinding: "+b) ; - return b ; + log.info("hasNextBinding: " + b); + return b; } - - + @Override - protected Binding moveToNextBinding() - { - Binding binding = super.moveToNextBinding() ; + protected Binding moveToNextBinding() { + Binding binding = super.moveToNextBinding(); if ( logging ) - log.info("moveToNextBinding: "+binding) ; - return binding ; + log.info("moveToNextBinding: " + binding); + return binding; } @Override - protected void closeIterator() - { + protected void closeIterator() { if ( logging ) - log.info("closeIterator") ; + log.info("closeIterator"); super.closeIterator(); } - + public void loggingOn() { logging(true) ; } public void loggingOff() { logging(false) ; } - public void logging(boolean state) { logging = state ; } + public void logging(boolean state) { logging = state ; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorResultSet.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorResultSet.java index 5c1cab439a..3a5e1d206b 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorResultSet.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorResultSet.java @@ -21,29 +21,29 @@ package org.apache.jena.sparql.engine.iterator; -import org.apache.jena.atlas.io.IndentedWriter ; -import org.apache.jena.atlas.lib.Lib ; -import org.apache.jena.query.ResultSet ; -import org.apache.jena.sparql.engine.binding.Binding ; -import org.apache.jena.sparql.serializer.SerializationContext ; +import org.apache.jena.atlas.io.IndentedWriter; +import org.apache.jena.atlas.lib.Lib; +import org.apache.jena.query.ResultSet; +import org.apache.jena.sparql.engine.binding.Binding; +import org.apache.jena.sparql.serializer.SerializationContext; public class QueryIteratorResultSet extends QueryIteratorBase { - private ResultSet resultSet ; - public QueryIteratorResultSet(ResultSet rs) { resultSet = rs ; } - + private ResultSet resultSet; + public QueryIteratorResultSet(ResultSet rs) { resultSet = rs; } + @Override - protected void closeIterator() { resultSet = null ; } + protected void closeIterator() { resultSet = null; } @Override protected void requestCancel() { } @Override - protected boolean hasNextBinding() { return resultSet.hasNext() ; } + protected boolean hasNextBinding() { return resultSet.hasNext(); } @Override - protected Binding moveToNextBinding() { return resultSet.nextBinding() ; } + protected Binding moveToNextBinding() { return resultSet.nextBinding(); } @Override public void output(IndentedWriter out, SerializationContext cxt) { - out.print(Lib.className(this)) ; + out.print(Lib.className(this)); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorTiming.java b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorTiming.java index f1b82927f0..565e366ead 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorTiming.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/engine/iterator/QueryIteratorTiming.java @@ -30,60 +30,62 @@ import org.slf4j.LoggerFactory ; public class QueryIteratorTiming extends QueryIteratorWrapper { static private Logger log = LoggerFactory.getLogger(QueryIteratorTiming.class) ; - - static final public int NotStarted = -2 ; - static final public int NotFinished = -1 ; - - public static QueryIteratorTiming time(QueryIterator iter) { return new QueryIteratorTiming(iter) ; } - - private QueryIteratorTiming(QueryIterator iter) - { - super(iter) ; + + static final public int NotStarted = -2; + static final public int NotFinished = -1; + + public static QueryIteratorTiming time(QueryIterator iter) { + return new QueryIteratorTiming(iter); + } + + private QueryIteratorTiming(QueryIterator iter) { + super(iter); } - + @Override - protected boolean hasNextBinding() { start() ; return super.hasNextBinding() ; } - + protected boolean hasNextBinding() { + start(); + return super.hasNextBinding(); + } + @Override - protected Binding moveToNextBinding() { start() ; return super.moveToNextBinding() ; } - + protected Binding moveToNextBinding() { + start(); + return super.moveToNextBinding(); + } + @Override - protected void closeIterator() - { - super.closeIterator() ; - stop() ; + protected void closeIterator() { + super.closeIterator(); + stop(); } - private Timer timer = null ; - private long milliseconds = NotStarted ; - - private void start() - { - if ( timer == null ) - { - timer = new Timer() ; - timer.startTimer() ; - milliseconds = NotFinished ; + private Timer timer = null; + private long milliseconds = NotStarted; + + private void start() { + if ( timer == null ) { + timer = new Timer(); + timer.startTimer(); + milliseconds = NotFinished; } } - private void stop() - { - if ( timer == null ) - { - milliseconds = 0 ; - return ; + private void stop() { + if ( timer == null ) { + milliseconds = 0; + return; } - - milliseconds = timer.endTimer() ; - -// if ( log.isDebugEnabled() ) -// log.debug("Iterator: {} milliseconds", milliseconds) ; - log.info("Execution: {} milliseconds", milliseconds) ; + milliseconds = timer.endTimer(); + log.info("Execution: {} milliseconds", milliseconds); } - - /** Return the elapsed time, in milliseconds, between the first call to this iterator and the close call. - * Returns the time, or NotStarted (-2) or NotFinished (-1). + + /** + * Return the elapsed time, in milliseconds, between the first call to this + * iterator and the close call. Returns the time, or NotStarted (-2) or + * NotFinished (-1). */ - public long getMillis() { return milliseconds ; } + public long getMillis() { + return milliseconds; + } }
