num2)
- return -1;
- if (num1 < num2)
- return 1;
- return 0;
- }
- protected void swap(int i, int j) {
- IndexReader temp = sortedSubReaders[i];
- sortedSubReaders[i] = sortedSubReaders[j];
- sortedSubReaders[j] = temp;
-
- int tempInt = sortedStarts[i];
- sortedStarts[i] = sortedStarts[j];
- sortedStarts[j] = tempInt;
- }
- };
- sorter.quickSort(0, length - 1);
- }
- }
-
/** Return the {@link IndexReader} this searches. */
public IndexReader getIndexReader() {
return reader;
@@ -177,7 +134,8 @@
if (nDocs <= 0) // null might be returned from hq.top() below.
throw new IllegalArgumentException("nDocs must be > 0");
- TopScoreDocCollector collector = new TopScoreDocCollector(nDocs);
+ TopScoreDocCollector collector = TopScoreDocCollector.create(nDocs, weight
+ .getQuery().scoresDocInOrder());
search(weight, filter, collector);
return collector.topDocs();
}
@@ -236,7 +194,8 @@
// TODO: by default we should create a TopFieldCollector which does not
// track document scores and maxScore. Currently the default is set to true,
// however it will change in 3.0.
- TopFieldCollector collector = TopFieldCollector.create(sort, nDocs, fillFields, true, true);
+ TopFieldCollector collector = TopFieldCollector.create(sort, nDocs,
+ fillFields, true, true, weight.getQuery().scoresDocInOrder());
search(weight, filter, collector);
return (TopFieldDocs) collector.topDocs();
}
@@ -252,9 +211,9 @@
public void search(Weight weight, Filter filter, Collector collector)
throws IOException {
- for (int i = 0; i < sortedSubReaders.length; i++) { // search each subreader
- collector.setNextReader(sortedSubReaders[i], sortedStarts[i]);
- doSearch(sortedSubReaders[i], weight, filter, collector);
+ for (int i = 0; i < subReaders.length; i++) { // search each subreader
+ collector.setNextReader(subReaders[i], sortedStarts[i]);
+ doSearch(subReaders[i], weight, filter, collector);
}
}
Index: src/java/org/apache/lucene/search/MatchAllDocsQuery.java
===================================================================
--- src/java/org/apache/lucene/search/MatchAllDocsQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/MatchAllDocsQuery.java (working copy)
@@ -155,4 +155,8 @@
public int hashCode() {
return Float.floatToIntBits(getBoost()) ^ 0x1AA71190;
}
+
+ public boolean scoresDocInOrder() {
+ return true;
+ }
}
Index: src/java/org/apache/lucene/search/MultiPhraseQuery.java
===================================================================
--- src/java/org/apache/lucene/search/MultiPhraseQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/MultiPhraseQuery.java (working copy)
@@ -366,4 +366,9 @@
}
return true;
}
+
+ public boolean scoresDocInOrder() {
+ return true;
+ }
+
}
Index: src/java/org/apache/lucene/search/MultiSearcher.java
===================================================================
--- src/java/org/apache/lucene/search/MultiSearcher.java (revision 770123)
+++ src/java/org/apache/lucene/search/MultiSearcher.java (working copy)
@@ -203,7 +203,7 @@
public TopDocs search(Weight weight, Filter filter, int nDocs)
throws IOException {
- HitQueue hq = new HitQueue(nDocs);
+ HitQueue hq = new HitQueue(nDocs, false);
int totalHits = 0;
for (int i = 0; i < searchables.length; i++) { // search each searcher
@@ -218,7 +218,8 @@
}
}
- ScoreDoc[] scoreDocs = new ScoreDoc[hq.size()];
+ // We cannot rely on HitQueue.size() since it pre-populates
+ ScoreDoc[] scoreDocs = new ScoreDoc[totalHits];
for (int i = hq.size()-1; i >= 0; i--) // put docs in array
scoreDocs[i] = (ScoreDoc)hq.pop();
@@ -236,7 +237,19 @@
for (int i = 0; i < searchables.length; i++) { // search each searcher
TopFieldDocs docs = searchables[i].search (weight, filter, n, sort);
-
+ // If one of the Sort fields is FIELD_DOC, need to fix its values, so that
+ // it will break ties by doc Id properly. Otherwise, it will compare to
+ // 'relative' doc Ids, that belong to two different searchers.
+ for (int j = 0; j < docs.fields.length; j++) {
+ if (docs.fields[j].getType() == SortField.DOC) {
+ // iterate over the score docs and change their fields value
+ for (int j2 = 0; j2 < docs.scoreDocs.length; j2++) {
+ FieldDoc fd = (FieldDoc) docs.scoreDocs[j2];
+ fd.fields[j] = new Integer(((Integer) fd.fields[j]).intValue() + starts[i]);
+ }
+ break;
+ }
+ }
if (hq == null) hq = new FieldDocSortedHitQueue (docs.fields, n);
totalHits += docs.totalHits; // update totalHits
maxScore = Math.max(maxScore, docs.getMaxScore());
Index: src/java/org/apache/lucene/search/MultiTermQuery.java
===================================================================
--- src/java/org/apache/lucene/search/MultiTermQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/MultiTermQuery.java (working copy)
@@ -171,5 +171,9 @@
}
return term.hashCode() + Float.floatToRawIntBits(getBoost());
}
+
+ public boolean scoresDocInOrder() {
+ return true;
+ }
}
Index: src/java/org/apache/lucene/search/ParallelMultiSearcher.java
===================================================================
--- src/java/org/apache/lucene/search/ParallelMultiSearcher.java (revision 770123)
+++ src/java/org/apache/lucene/search/ParallelMultiSearcher.java (working copy)
@@ -54,7 +54,7 @@
*/
public TopDocs search(Weight weight, Filter filter, int nDocs)
throws IOException {
- HitQueue hq = new HitQueue(nDocs);
+ HitQueue hq = new HitQueue(nDocs, false);
int totalHits = 0;
MultiSearcherThread[] msta =
new MultiSearcherThread[searchables.length];
@@ -295,7 +295,22 @@
// the actual type of fields, in case the original list contained AUTO.
// if the searchable returns null for fields, we'll have problems.
if (sort != null) {
- ((FieldDocSortedHitQueue)hq).setFields (((TopFieldDocs)docs).fields);
+ TopFieldDocs docsFields = (TopFieldDocs) docs;
+ // If one of the Sort fields is FIELD_DOC, need to fix its values, so that
+ // it will break ties by doc Id properly. Otherwise, it will compare to
+ // 'relative' doc Ids, that belong to two different searchers.
+ for (int j = 0; j < docsFields.fields.length; j++) {
+ if (docsFields.fields[j].getType() == SortField.DOC) {
+ // iterate over the score docs and change their fields value
+ for (int j2 = 0; j2 < docs.scoreDocs.length; j2++) {
+ FieldDoc fd = (FieldDoc) docs.scoreDocs[j2];
+ fd.fields[j] = new Integer(((Integer) fd.fields[j]).intValue() + starts[i]);
+ }
+ break;
+ }
+ }
+
+ ((FieldDocSortedHitQueue) hq).setFields(docsFields.fields);
}
ScoreDoc[] scoreDocs = docs.scoreDocs;
for (int j = 0;
Index: src/java/org/apache/lucene/search/PhraseQuery.java
===================================================================
--- src/java/org/apache/lucene/search/PhraseQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/PhraseQuery.java (working copy)
@@ -316,4 +316,8 @@
^ positions.hashCode();
}
+ public boolean scoresDocInOrder() {
+ return true;
+ }
+
}
Index: src/java/org/apache/lucene/search/Query.java
===================================================================
--- src/java/org/apache/lucene/search/Query.java (revision 770123)
+++ src/java/org/apache/lucene/search/Query.java (working copy)
@@ -196,6 +196,16 @@
return searcher.getSimilarity();
}
+ /**
+ * Expert: returns true if documents are scored in doc Id order or not by this
+ * query. The default implemntation returns false for backward-compatibility
+ * and may be changed to true in 3.0.
+ */
+ // TODO (3.0): should this change to true by default in 3.0?
+ public boolean scoresDocInOrder() {
+ return false;
+ }
+
/** Returns a clone of this query. */
public Object clone() {
try {
Index: src/java/org/apache/lucene/search/ScoreDoc.java
===================================================================
--- src/java/org/apache/lucene/search/ScoreDoc.java (revision 770123)
+++ src/java/org/apache/lucene/search/ScoreDoc.java (working copy)
@@ -33,4 +33,10 @@
this.doc = doc;
this.score = score;
}
+
+ // A convenience method for debugging.
+ public String toString() {
+ return "doc=" + doc + " score=" + score;
+ }
+
}
Index: src/java/org/apache/lucene/search/Sort.java
===================================================================
--- src/java/org/apache/lucene/search/Sort.java (revision 770123)
+++ src/java/org/apache/lucene/search/Sort.java (working copy)
@@ -121,7 +121,7 @@
* only with slightly more overhead.
*/
public Sort() {
- this(new SortField[] { SortField.FIELD_SCORE, SortField.FIELD_DOC });
+ this(SortField.FIELD_SCORE);
}
/**
@@ -179,9 +179,7 @@
* then by index order (document number).
*/
public void setSort(String field, boolean reverse) {
- SortField[] nfields = new SortField[] {
- new SortField(field, SortField.AUTO, reverse), SortField.FIELD_DOC };
- fields = nfields;
+ fields = new SortField[] { new SortField(field, SortField.AUTO, reverse) };
}
/** Sets the sort to the terms in each field in succession. */
Index: src/java/org/apache/lucene/search/TermQuery.java
===================================================================
--- src/java/org/apache/lucene/search/TermQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/TermQuery.java (working copy)
@@ -176,4 +176,8 @@
return Float.floatToIntBits(getBoost()) ^ term.hashCode();
}
+ public boolean scoresDocInOrder() {
+ return true;
+ }
+
}
Index: src/java/org/apache/lucene/search/TopDocCollector.java
===================================================================
--- src/java/org/apache/lucene/search/TopDocCollector.java (revision 770123)
+++ src/java/org/apache/lucene/search/TopDocCollector.java (working copy)
@@ -44,7 +44,7 @@
* @param numHits the maximum number of hits to collect
*/
public TopDocCollector(int numHits) {
- this(new HitQueue(numHits));
+ this(new HitQueue(numHits, false));
}
/** @deprecated use TopDocCollector(hq) instead. numHits is not used by this
Index: src/java/org/apache/lucene/search/TopDocsCollector.java
===================================================================
--- src/java/org/apache/lucene/search/TopDocsCollector.java (revision 770123)
+++ src/java/org/apache/lucene/search/TopDocsCollector.java (working copy)
@@ -75,7 +75,10 @@
/** Returns the top docs that were collected by this collector. */
public final TopDocs topDocs() {
- return topDocs(0, pq.size());
+ // In case pq was populated with sentinel values, there might be less
+ // results than pq.size(). Therefore return all results until either
+ // pq.size() or totalHits.
+ return topDocs(0, totalHits < pq.size() ? totalHits : pq.size());
}
/**
@@ -91,7 +94,10 @@
* results this search execution collected.
*/
public final TopDocs topDocs(int start) {
- return topDocs(start, pq.size());
+ // In case pq was populated with sentinel values, there might be less
+ // results than pq.size(). Therefore return all results until either
+ // pq.size() or totalHits.
+ return topDocs(start, totalHits < pq.size() ? totalHits : pq.size());
}
/**
@@ -108,18 +114,21 @@
* returned {@link TopDocs} object, which will contain all the results this
* search execution collected.
*/
- public TopDocs topDocs(int start, int howMany) {
+ public final TopDocs topDocs(int start, int howMany) {
- int pqsize = pq.size();
+ // In case pq was populated with sentinel values, there might be less
+ // results than pq.size(). Therefore return all results until either
+ // pq.size() or totalHits.
+ int size = totalHits < pq.size() ? totalHits : pq.size();
// Don't bother to throw an exception, just return an empty TopDocs in case
// the parameters are invalid or out of range.
- if (start < 0 || start >= pqsize || howMany <= 0) {
+ if (start < 0 || start >= size || howMany <= 0) {
return newTopDocs(null, start);
}
// We know that start < pqsize, so just fix howMany.
- howMany = Math.min(pqsize - start, howMany);
+ howMany = Math.min(size - start, howMany);
ScoreDoc[] results = new ScoreDoc[howMany];
// pq's pop() returns the 'least' element in the queue, therefore need
@@ -127,7 +136,7 @@
// Note that this loop will usually not be executed, since the common usage
// should be that the caller asks for the last howMany results. However it's
// needed here for completeness.
- for (int i = pqsize - start - howMany; i > 0; i--) { pq.pop(); }
+ for (int i = pq.size() - start - howMany; i > 0; i--) { pq.pop(); }
// Get the requested results from pq.
populateResults(results, howMany);
Index: src/java/org/apache/lucene/search/TopFieldCollector.java
===================================================================
--- src/java/org/apache/lucene/search/TopFieldCollector.java (revision 770123)
+++ src/java/org/apache/lucene/search/TopFieldCollector.java (working copy)
@@ -41,7 +41,7 @@
* Implements a TopFieldCollector over one SortField criteria, without
* tracking document scores and maxScore.
*/
- private static class OneComparatorNonScoringCollector extends
+ private static class OneComparatorNonScoringCollector extends
TopFieldCollector {
final FieldComparator comparator;
@@ -54,19 +54,19 @@
reverseMul = queue.getReverseMul()[0];
}
- private final void updateBottom(int doc) {
+ final void updateBottom(int doc) {
// bottom.score is already set to Float.NaN in add().
bottom.docID = docBase + doc;
- pq.adjustTop();
- bottom = (FieldValueHitQueue.Entry) pq.top();
+ bottom = (Entry) pq.updateTop();
}
public void collect(int doc) throws IOException {
++totalHits;
if (queueFull) {
- // Fastmatch: return if this hit is not competitive
- final int cmp = reverseMul * comparator.compareBottom(doc);
- if (cmp < 0 || (cmp == 0 && doc + docBase > bottom.docID)) {
+ if ((reverseMul * comparator.compareBottom(doc)) <= 0) {
+ // since docs are visited in doc Id order, if compare is 0, it means
+ // this document is largest than anything else in the queue, and
+ // therefore not competitive.
return;
}
@@ -99,32 +99,71 @@
}
/*
+ * Implements a TopFieldCollector over one SortField criteria, without
+ * tracking document scores and maxScore, and assumes out of orderness in doc
+ * Ids collection.
+ */
+ private static class OutOfOrderOneComparatorNonScoringCollector extends
+ OneComparatorNonScoringCollector {
+
+ public OutOfOrderOneComparatorNonScoringCollector(FieldValueHitQueue queue,
+ int numHits, boolean fillFields) throws IOException {
+ super(queue, numHits, fillFields);
+ }
+
+ public void collect(int doc) throws IOException {
+ ++totalHits;
+ if (queueFull) {
+ // Fastmatch: return if this hit is not competitive
+ final int cmp = reverseMul * comparator.compareBottom(doc);
+ if (cmp < 0 || (cmp == 0 && doc + docBase > bottom.docID)) {
+ return;
+ }
+
+ // This hit is competitive - replace bottom element in queue & adjustTop
+ comparator.copy(bottom.slot, doc);
+ updateBottom(doc);
+ comparator.setBottom(bottom.slot);
+ } else {
+ // Startup transient: queue hasn't gathered numHits yet
+ final int slot = totalHits - 1;
+ // Copy hit into queue
+ comparator.copy(slot, doc);
+ add(slot, doc, Float.NaN);
+ if (queueFull) {
+ comparator.setBottom(bottom.slot);
+ }
+ }
+ }
+ }
+
+ /*
* Implements a TopFieldCollector over one SortField criteria, while tracking
* document scores but no maxScore.
*/
private static class OneComparatorScoringNoMaxScoreCollector extends
OneComparatorNonScoringCollector {
- private Scorer scorer;
+ Scorer scorer;
public OneComparatorScoringNoMaxScoreCollector(FieldValueHitQueue queue,
int numHits, boolean fillFields) throws IOException {
super(queue, numHits, fillFields);
}
- private final void updateBottom(int doc, float score) {
+ final void updateBottom(int doc, float score) {
bottom.docID = docBase + doc;
bottom.score = score;
- pq.adjustTop();
- bottom = (FieldValueHitQueue.Entry) pq.top();
+ bottom = (Entry) pq.updateTop();
}
public void collect(int doc) throws IOException {
++totalHits;
if (queueFull) {
- // Fastmatch: return if this hit is not competitive
- final int cmp = reverseMul * comparator.compareBottom(doc);
- if (cmp < 0 || (cmp == 0 && doc + docBase > bottom.docID)) {
+ if ((reverseMul * comparator.compareBottom(doc)) <= 0) {
+ // since docs are visited in doc Id order, if compare is 0, it means
+ // this document is largest than anything else in the queue, and
+ // therefore not competitive.
return;
}
@@ -150,12 +189,6 @@
}
}
- public void setNextReader(IndexReader reader, int docBase) throws IOException {
- final int numSlotsFull = queueFull ? numHits : totalHits;
- this.docBase = docBase;
- comparator.setNextReader(reader, docBase, numSlotsFull);
- }
-
public void setScorer(Scorer scorer) throws IOException {
this.scorer = scorer;
comparator.setScorer(scorer);
@@ -164,13 +197,59 @@
}
/*
+ * Implements a TopFieldCollector over one SortField criteria, while tracking
+ * document scores but no maxScore, and assumes out of orderness in doc Ids
+ * collection.
+ */
+ private static class OutOfOrderOneComparatorScoringNoMaxScoreCollector extends
+ OneComparatorScoringNoMaxScoreCollector {
+
+ public OutOfOrderOneComparatorScoringNoMaxScoreCollector(
+ FieldValueHitQueue queue, int numHits, boolean fillFields)
+ throws IOException {
+ super(queue, numHits, fillFields);
+ }
+
+ public void collect(int doc) throws IOException {
+ ++totalHits;
+ if (queueFull) {
+ // Fastmatch: return if this hit is not competitive
+ final int cmp = reverseMul * comparator.compareBottom(doc);
+ if (cmp < 0 || (cmp == 0 && doc + docBase > bottom.docID)) {
+ return;
+ }
+
+ // Compute the score only if the hit is competitive.
+ final float score = scorer.score();
+
+ // This hit is competitive - replace bottom element in queue & adjustTop
+ comparator.copy(bottom.slot, doc);
+ updateBottom(doc, score);
+ comparator.setBottom(bottom.slot);
+ } else {
+ // Compute the score only if the hit is competitive.
+ final float score = scorer.score();
+
+ // Startup transient: queue hasn't gathered numHits yet
+ final int slot = totalHits - 1;
+ // Copy hit into queue
+ comparator.copy(slot, doc);
+ add(slot, doc, score);
+ if (queueFull) {
+ comparator.setBottom(bottom.slot);
+ }
+ }
+ }
+ }
+
+ /*
* Implements a TopFieldCollector over one SortField criteria, with tracking
* document scores and maxScore.
*/
- private final static class OneComparatorScoringMaxScoreCollector extends
+ private static class OneComparatorScoringMaxScoreCollector extends
OneComparatorNonScoringCollector {
- private Scorer scorer;
+ Scorer scorer;
public OneComparatorScoringMaxScoreCollector(FieldValueHitQueue queue,
int numHits, boolean fillFields) throws IOException {
@@ -179,11 +258,10 @@
maxScore = Float.NEGATIVE_INFINITY;
}
- private final void updateBottom(int doc, float score) {
+ final void updateBottom(int doc, float score) {
bottom.docID = docBase + doc;
bottom.score = score;
- pq.adjustTop();
- bottom = (FieldValueHitQueue.Entry) pq.top();
+ bottom = (Entry) pq.updateTop();
}
public void collect(int doc) throws IOException {
@@ -193,9 +271,10 @@
}
++totalHits;
if (queueFull) {
- // Fastmatch: return if this hit is not competitive
- final int cmp = reverseMul * comparator.compareBottom(doc);
- if (cmp < 0 || (cmp == 0 && doc + docBase > bottom.docID)) {
+ if ((reverseMul * comparator.compareBottom(doc)) <= 0) {
+ // since docs are visited in doc Id order, if compare is 0, it means
+ // this document is largest than anything else in the queue, and
+ // therefore not competitive.
return;
}
@@ -223,6 +302,50 @@
}
/*
+ * Implements a TopFieldCollector over one SortField criteria, with tracking
+ * document scores and maxScore, and assumes out of orderness in doc Ids
+ * collection.
+ */
+ private static class OutOfOrderOneComparatorScoringMaxScoreCollector extends
+ OneComparatorScoringMaxScoreCollector {
+
+ public OutOfOrderOneComparatorScoringMaxScoreCollector(FieldValueHitQueue queue,
+ int numHits, boolean fillFields) throws IOException {
+ super(queue, numHits, fillFields);
+ }
+
+ public void collect(int doc) throws IOException {
+ final float score = scorer.score();
+ if (score > maxScore) {
+ maxScore = score;
+ }
+ ++totalHits;
+ if (queueFull) {
+ // Fastmatch: return if this hit is not competitive
+ final int cmp = reverseMul * comparator.compareBottom(doc);
+ if (cmp < 0 || (cmp == 0 && doc + docBase > bottom.docID)) {
+ return;
+ }
+
+ // This hit is competitive - replace bottom element in queue & adjustTop
+ comparator.copy(bottom.slot, doc);
+ updateBottom(doc, score);
+ comparator.setBottom(bottom.slot);
+ } else {
+ // Startup transient: queue hasn't gathered numHits yet
+ final int slot = totalHits - 1;
+ // Copy hit into queue
+ comparator.copy(slot, doc);
+ add(slot, doc, score);
+ if (queueFull) {
+ comparator.setBottom(bottom.slot);
+ }
+ }
+
+ }
+ }
+
+ /*
* Implements a TopFieldCollector over multiple SortField criteria, without
* tracking document scores and maxScore.
*/
@@ -238,11 +361,10 @@
reverseMul = queue.getReverseMul();
}
- private final void updateBottom(int doc) {
+ final void updateBottom(int doc) {
// bottom.score is already set to Float.NaN in add().
bottom.docID = docBase + doc;
- pq.adjustTop();
- bottom = (FieldValueHitQueue.Entry) pq.top();
+ bottom = (Entry) pq.updateTop();
}
public void collect(int doc) throws IOException {
@@ -252,18 +374,16 @@
for (int i = 0;; i++) {
final int c = reverseMul[i] * comparators[i].compareBottom(doc);
if (c < 0) {
- // Definitely not competitive
+ // Definitely not competitive.
return;
} else if (c > 0) {
- // Definitely competitive
+ // Definitely competitive.
break;
} else if (i == comparators.length - 1) {
- // This is the equals case.
- if (doc + docBase > bottom.docID) {
- // Definitely not competitive
- return;
- }
- break;
+ // Here c=0. If we're at the last comparator, this doc is not
+ // competitive, since docs are visited in doc Id order, which means
+ // this doc cannot compete with any other document in the queue.
+ return;
}
}
@@ -310,12 +430,74 @@
}
/*
+ * Implements a TopFieldCollector over multiple SortField criteria, without
+ * tracking document scores and maxScore, and assumes out of orderness in doc
+ * Ids collection.
+ */
+ private static class OutOfOrderMultiComparatorNonScoringCollector extends
+ MultiComparatorNonScoringCollector {
+
+ public OutOfOrderMultiComparatorNonScoringCollector(FieldValueHitQueue queue,
+ int numHits, boolean fillFields) throws IOException {
+ super(queue, numHits, fillFields);
+ }
+
+ public void collect(int doc) throws IOException {
+ ++totalHits;
+ if (queueFull) {
+ // Fastmatch: return if this hit is not competitive
+ for (int i = 0;; i++) {
+ final int c = reverseMul[i] * comparators[i].compareBottom(doc);
+ if (c < 0) {
+ // Definitely not competitive.
+ return;
+ } else if (c > 0) {
+ // Definitely competitive.
+ break;
+ } else if (i == comparators.length - 1) {
+ // This is the equals case.
+ if (doc + docBase > bottom.docID) {
+ // Definitely not competitive
+ return;
+ }
+ break;
+ }
+ }
+
+ // This hit is competitive - replace bottom element in queue & adjustTop
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].copy(bottom.slot, doc);
+ }
+
+ updateBottom(doc);
+
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].setBottom(bottom.slot);
+ }
+ } else {
+ // Startup transient: queue hasn't gathered numHits yet
+ final int slot = totalHits - 1;
+ // Copy hit into queue
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].copy(slot, doc);
+ }
+ add(slot, doc, Float.NaN);
+ if (queueFull) {
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].setBottom(bottom.slot);
+ }
+ }
+ }
+ }
+ }
+
+ /*
* Implements a TopFieldCollector over multiple SortField criteria, with
* tracking document scores and maxScore.
*/
- private final static class MultiComparatorScoringMaxScoreCollector extends MultiComparatorNonScoringCollector {
+ private static class MultiComparatorScoringMaxScoreCollector extends MultiComparatorNonScoringCollector {
- private Scorer scorer;
+ Scorer scorer;
public MultiComparatorScoringMaxScoreCollector(FieldValueHitQueue queue,
int numHits, boolean fillFields) throws IOException {
@@ -324,11 +506,10 @@
maxScore = Float.NEGATIVE_INFINITY;
}
- private final void updateBottom(int doc, float score) {
+ final void updateBottom(int doc, float score) {
bottom.docID = docBase + doc;
bottom.score = score;
- pq.adjustTop();
- bottom = (FieldValueHitQueue.Entry) pq.top();
+ bottom = (Entry) pq.updateTop();
}
public void collect(int doc) throws IOException {
@@ -342,12 +523,81 @@
for (int i = 0;; i++) {
final int c = reverseMul[i] * comparators[i].compareBottom(doc);
if (c < 0) {
- // Definitely not competitive
+ // Definitely not competitive.
return;
} else if (c > 0) {
- // Definitely competitive
+ // Definitely competitive.
break;
} else if (i == comparators.length - 1) {
+ // Here c=0. If we're at the last comparator, this doc is not
+ // competitive, since docs are visited in doc Id order, which means
+ // this doc cannot compete with any other document in the queue.
+ return;
+ }
+ }
+
+ // This hit is competitive - replace bottom element in queue & adjustTop
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].copy(bottom.slot, doc);
+ }
+
+ updateBottom(doc, score);
+
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].setBottom(bottom.slot);
+ }
+ } else {
+ // Startup transient: queue hasn't gathered numHits yet
+ final int slot = totalHits - 1;
+ // Copy hit into queue
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].copy(slot, doc);
+ }
+ add(slot, doc, score);
+ if (queueFull) {
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].setBottom(bottom.slot);
+ }
+ }
+ }
+ }
+
+ public void setScorer(Scorer scorer) throws IOException {
+ this.scorer = scorer;
+ super.setScorer(scorer);
+ }
+ }
+
+ /*
+ * Implements a TopFieldCollector over multiple SortField criteria, with
+ * tracking document scores and maxScore, and assumes out of orderness in doc
+ * Ids collection.
+ */
+ private final static class OutOfOrderMultiComparatorScoringMaxScoreCollector
+ extends MultiComparatorScoringMaxScoreCollector {
+
+ public OutOfOrderMultiComparatorScoringMaxScoreCollector(FieldValueHitQueue queue,
+ int numHits, boolean fillFields) throws IOException {
+ super(queue, numHits, fillFields);
+ }
+
+ public void collect(int doc) throws IOException {
+ final float score = scorer.score();
+ if (score > maxScore) {
+ maxScore = score;
+ }
+ ++totalHits;
+ if (queueFull) {
+ // Fastmatch: return if this hit is not competitive
+ for (int i = 0;; i++) {
+ final int c = reverseMul[i] * comparators[i].compareBottom(doc);
+ if (c < 0) {
+ // Definitely not competitive.
+ return;
+ } else if (c > 0) {
+ // Definitely competitive.
+ break;
+ } else if (i == comparators.length - 1) {
// This is the equals case.
if (doc + docBase > bottom.docID) {
// Definitely not competitive
@@ -382,31 +632,25 @@
}
}
}
-
- public void setScorer(Scorer scorer) throws IOException {
- this.scorer = scorer;
- super.setScorer(scorer);
- }
}
/*
* Implements a TopFieldCollector over multiple SortField criteria, with
* tracking document scores and maxScore.
*/
- private final static class MultiComparatorScoringNoMaxScoreCollector extends MultiComparatorNonScoringCollector {
+ private static class MultiComparatorScoringNoMaxScoreCollector extends MultiComparatorNonScoringCollector {
- private Scorer scorer;
+ Scorer scorer;
public MultiComparatorScoringNoMaxScoreCollector(FieldValueHitQueue queue,
int numHits, boolean fillFields) throws IOException {
super(queue, numHits, fillFields);
}
- private final void updateBottom(int doc, float score) {
+ final void updateBottom(int doc, float score) {
bottom.docID = docBase + doc;
bottom.score = score;
- pq.adjustTop();
- bottom = (FieldValueHitQueue.Entry) pq.top();
+ bottom = (Entry) pq.updateTop();
}
public void collect(int doc) throws IOException {
@@ -416,12 +660,83 @@
for (int i = 0;; i++) {
final int c = reverseMul[i] * comparators[i].compareBottom(doc);
if (c < 0) {
- // Definitely not competitive
+ // Definitely not competitive.
return;
} else if (c > 0) {
- // Definitely competitive
+ // Definitely competitive.
break;
} else if (i == comparators.length - 1) {
+ // Here c=0. If we're at the last comparator, this doc is not
+ // competitive, since docs are visited in doc Id order, which means
+ // this doc cannot compete with any other document in the queue.
+ return;
+ }
+ }
+
+ // This hit is competitive - replace bottom element in queue & adjustTop
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].copy(bottom.slot, doc);
+ }
+
+ // Compute score only if it is competitive.
+ final float score = scorer.score();
+ updateBottom(doc, score);
+
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].setBottom(bottom.slot);
+ }
+ } else {
+ // Startup transient: queue hasn't gathered numHits yet
+ final int slot = totalHits - 1;
+ // Copy hit into queue
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].copy(slot, doc);
+ }
+
+ // Compute score only if it is competitive.
+ final float score = scorer.score();
+ add(slot, doc, score);
+ if (queueFull) {
+ for (int i = 0; i < comparators.length; i++) {
+ comparators[i].setBottom(bottom.slot);
+ }
+ }
+ }
+ }
+
+ public void setScorer(Scorer scorer) throws IOException {
+ this.scorer = scorer;
+ super.setScorer(scorer);
+ }
+ }
+
+ /*
+ * Implements a TopFieldCollector over multiple SortField criteria, with
+ * tracking document scores and maxScore, and assumes out of orderness in doc
+ * Ids collection.
+ */
+ private final static class OutOfOrderMultiComparatorScoringNoMaxScoreCollector
+ extends MultiComparatorScoringNoMaxScoreCollector {
+
+ public OutOfOrderMultiComparatorScoringNoMaxScoreCollector(
+ FieldValueHitQueue queue, int numHits, boolean fillFields)
+ throws IOException {
+ super(queue, numHits, fillFields);
+ }
+
+ public void collect(int doc) throws IOException {
+ ++totalHits;
+ if (queueFull) {
+ // Fastmatch: return if this hit is not competitive
+ for (int i = 0;; i++) {
+ final int c = reverseMul[i] * comparators[i].compareBottom(doc);
+ if (c < 0) {
+ // Definitely not competitive.
+ return;
+ } else if (c > 0) {
+ // Definitely competitive.
+ break;
+ } else if (i == comparators.length - 1) {
// This is the equals case.
if (doc + docBase > bottom.docID) {
// Definitely not competitive
@@ -451,7 +766,7 @@
comparators[i].copy(slot, doc);
}
- // Compute score only if it competitive.
+ // Compute score only if it is competitive.
final float score = scorer.score();
add(slot, doc, score);
if (queueFull) {
@@ -518,12 +833,17 @@
* true affects performance as it incurs the score computation on
* each result. Also, setting this true automatically sets
* trackDocScores to true as well.
+ * @param docsScoredInOrder
+ * specifies whether documents are scored in doc Id order or not by
+ * the given {@link Scorer} in {@link #setScorer(Scorer)}.
* @return a {@link TopFieldCollector} instance which will sort the results by
* the sort criteria.
+ * @see Query#scoresDocInOrder()
* @throws IOException
*/
public static TopFieldCollector create(Sort sort, int numHits,
- boolean fillFields, boolean trackDocScores, boolean trackMaxScore)
+ boolean fillFields, boolean trackDocScores, boolean trackMaxScore,
+ boolean docsScoredInOrder)
throws IOException {
if (sort.fields.length == 0) {
throw new IllegalArgumentException("Sort must contain at least one field");
@@ -531,28 +851,47 @@
FieldValueHitQueue queue = FieldValueHitQueue.create(sort.fields, numHits);
if (queue.getComparators().length == 1) {
- if (trackMaxScore) {
- return new OneComparatorScoringMaxScoreCollector(queue, numHits, fillFields);
- } else if (trackDocScores) {
- return new OneComparatorScoringNoMaxScoreCollector(queue, numHits, fillFields);
+ if (docsScoredInOrder) {
+ if (trackMaxScore) {
+ return new OneComparatorScoringMaxScoreCollector(queue, numHits, fillFields);
+ } else if (trackDocScores) {
+ return new OneComparatorScoringNoMaxScoreCollector(queue, numHits, fillFields);
+ } else {
+ return new OneComparatorNonScoringCollector(queue, numHits, fillFields);
+ }
} else {
- return new OneComparatorNonScoringCollector(queue, numHits, fillFields);
+ if (trackMaxScore) {
+ return new OutOfOrderOneComparatorScoringMaxScoreCollector(queue, numHits, fillFields);
+ } else if (trackDocScores) {
+ return new OutOfOrderOneComparatorScoringNoMaxScoreCollector(queue, numHits, fillFields);
+ } else {
+ return new OutOfOrderOneComparatorNonScoringCollector(queue, numHits, fillFields);
+ }
}
}
// multiple comparators.
- if (trackMaxScore) {
- return new MultiComparatorScoringMaxScoreCollector(queue, numHits, fillFields);
- } else if (trackDocScores) {
- return new MultiComparatorScoringNoMaxScoreCollector(queue, numHits, fillFields);
+ if (docsScoredInOrder) {
+ if (trackMaxScore) {
+ return new MultiComparatorScoringMaxScoreCollector(queue, numHits, fillFields);
+ } else if (trackDocScores) {
+ return new MultiComparatorScoringNoMaxScoreCollector(queue, numHits, fillFields);
+ } else {
+ return new MultiComparatorNonScoringCollector(queue, numHits, fillFields);
+ }
} else {
- return new MultiComparatorNonScoringCollector(queue, numHits, fillFields);
+ if (trackMaxScore) {
+ return new OutOfOrderMultiComparatorScoringMaxScoreCollector(queue, numHits, fillFields);
+ } else if (trackDocScores) {
+ return new OutOfOrderMultiComparatorScoringNoMaxScoreCollector(queue, numHits, fillFields);
+ } else {
+ return new OutOfOrderMultiComparatorNonScoringCollector(queue, numHits, fillFields);
+ }
}
}
final void add(int slot, int doc, float score) {
- pq.put(new FieldValueHitQueue.Entry(slot, docBase + doc, score));
- bottom = (FieldValueHitQueue.Entry) pq.top();
+ bottom = (Entry) pq.add(new Entry(slot, docBase + doc, score));
queueFull = totalHits == numHits;
}
@@ -562,14 +901,15 @@
*/
protected void populateResults(ScoreDoc[] results, int howMany) {
- FieldValueHitQueue queue = (FieldValueHitQueue) pq;
if (fillFields) {
- for (int i = queue.size() - 1; i >= 0; i--) {
- results[i] = queue.fillFields((FieldValueHitQueue.Entry) queue.pop());
+ // avoid casting if unnecessary.
+ FieldValueHitQueue queue = (FieldValueHitQueue) pq;
+ for (int i = howMany - 1; i >= 0; i--) {
+ results[i] = queue.fillFields((Entry) queue.pop());
}
} else {
- for (int i = queue.size() - 1; i >= 0; i--) {
- Entry entry = (FieldValueHitQueue.Entry) queue.pop();
+ for (int i = howMany - 1; i >= 0; i--) {
+ Entry entry = (Entry) pq.pop();
results[i] = new FieldDoc(entry.docID, entry.score);
}
}
Index: src/java/org/apache/lucene/search/TopScoreDocCollector.java
===================================================================
--- src/java/org/apache/lucene/search/TopScoreDocCollector.java (revision 770123)
+++ src/java/org/apache/lucene/search/TopScoreDocCollector.java (working copy)
@@ -22,25 +22,89 @@
import org.apache.lucene.index.IndexReader;
/**
- * A {@link Collector} implementation that collects the
- * top-scoring hits, returning them as a {@link
- * TopDocs}. This is used by {@link IndexSearcher} to
- * implement {@link TopDocs}-based search. Hits are sorted
- * by score descending and then (when the scores are tied)
- * docID ascending.
+ * A {@link Collector} implementation that collects the top-scoring hits,
+ * returning them as a {@link TopDocs}. This is used by {@link IndexSearcher} to
+ * implement {@link TopDocs}-based search. Hits are sorted by score descending
+ * and then (when the scores are tied) docID ascending. When you create an
+ * instance of this collector you should know in advance whether documents are
+ * going to be collected in doc Id order or not. That information is available
+ * on the {@link Query} instance and can be obtained by calling
+ * {@link Query#scoresDocInOrder()}.
+ *
+ * @see Query#scoresDocInOrder()
*/
-public final class TopScoreDocCollector extends TopDocsCollector {
+public abstract class TopScoreDocCollector extends TopDocsCollector {
- private ScoreDoc reusableSD;
- private int docBase = 0;
- private Scorer scorer;
+ // TODO: add a test case that tests out of orderness collection.
+
+ // Assumes docs are scored in order.
+ private static class InOrderTopScoreDocCollector extends TopScoreDocCollector {
+ private InOrderTopScoreDocCollector(int numHits) {
+ super(numHits);
+ }
- /** Construct to collect a given number of hits.
- * @param numHits the maximum number of hits to collect
+ public void collect(int doc) throws IOException {
+ float score = scorer.score();
+ totalHits++;
+ if (score <= pqTop.score) {
+ // Since docs are returned in-order (i.e., increasing doc Id), a document
+ // with equal score to pqTop.score cannot compete since HitQueue favors
+ // documents with lower doc Ids. Therefore reject those docs too.
+ return;
+ }
+ pqTop.doc = doc + docBase;
+ pqTop.score = score;
+ pqTop = (ScoreDoc) pq.updateTop();
+ }
+ }
+
+ // Assumes docs are scored out of order.
+ private static class OutOfOrderTopScoreDocCollector extends TopScoreDocCollector {
+ private OutOfOrderTopScoreDocCollector(int numHits) {
+ super(numHits);
+ }
+
+ public void collect(int doc) throws IOException {
+ float score = scorer.score();
+ totalHits++;
+ doc += docBase;
+ if (score < pqTop.score || (score == pqTop.score && doc > pqTop.doc)) {
+ return;
+ }
+ pqTop.doc = doc;
+ pqTop.score = score;
+ pqTop = (ScoreDoc) pq.updateTop();
+ }
+ }
+
+ /**
+ * Creates a new {@link TopScoreDocCollector} given the number of hits to
+ * collect and whether documents are scored in order by the input
+ * {@link Scorer} to {@link #setScorer(Scorer)}.
+ *
+ * @see Query#scoresDocInOrder()
*/
- public TopScoreDocCollector(int numHits) {
- super(new HitQueue(numHits));
+ public static TopScoreDocCollector create(int numHits, boolean docsScoredInOrder) {
+
+ if (docsScoredInOrder) {
+ return new InOrderTopScoreDocCollector(numHits);
+ } else {
+ return new OutOfOrderTopScoreDocCollector(numHits);
+ }
+
}
+
+ ScoreDoc pqTop;
+ int docBase = 0;
+ Scorer scorer;
+
+ // prevents instantiation
+ private TopScoreDocCollector(int numHits) {
+ super(new HitQueue(numHits, true));
+ // HitQueue implements getSentinelObject to return a ScoreDoc, so we know
+ // that at this point top() is already initialized.
+ pqTop = (ScoreDoc) pq.top();
+ }
protected TopDocs newTopDocs(ScoreDoc[] results, int start) {
if (results == null) {
@@ -62,24 +126,6 @@
return new TopDocs(totalHits, results, maxScore);
}
- // javadoc inherited
- public void collect(int doc) throws IOException {
- float score = scorer.score();
- totalHits++;
- if (reusableSD == null) {
- reusableSD = new ScoreDoc(doc + docBase, score);
- } else if (score >= reusableSD.score) {
- // reusableSD holds the last "rejected" entry, so, if
- // this new score is not better than that, there's no
- // need to try inserting it
- reusableSD.doc = doc + docBase;
- reusableSD.score = score;
- } else {
- return;
- }
- reusableSD = (ScoreDoc) pq.insertWithOverflow(reusableSD);
- }
-
public void setNextReader(IndexReader reader, int base) {
docBase = base;
}
Index: src/java/org/apache/lucene/search/function/CustomScoreQuery.java
===================================================================
--- src/java/org/apache/lucene/search/function/CustomScoreQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/function/CustomScoreQuery.java (working copy)
@@ -457,4 +457,17 @@
return "custom";
}
+ public boolean scoresDocInOrder() {
+ // Return true only if all queries score docs in order
+ if (!subQuery.scoresDocInOrder()) {
+ return false;
+ }
+ for (int i = 0; i < valSrcQueries.length; i++) {
+ if (!valSrcQueries[i].scoresDocInOrder()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
}
Index: src/java/org/apache/lucene/search/function/ValueSourceQuery.java
===================================================================
--- src/java/org/apache/lucene/search/function/ValueSourceQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/function/ValueSourceQuery.java (working copy)
@@ -186,4 +186,8 @@
return (getClass().hashCode() + valSrc.hashCode()) ^ Float.floatToIntBits(getBoost());
}
+ public boolean scoresDocInOrder() {
+ return true;
+ }
+
}
Index: src/java/org/apache/lucene/search/spans/SpanNearQuery.java
===================================================================
--- src/java/org/apache/lucene/search/spans/SpanNearQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/spans/SpanNearQuery.java (working copy)
@@ -178,4 +178,16 @@
result ^= (inOrder ? 0x99AFD3BD : 0);
return result;
}
+
+ public boolean scoresDocInOrder() {
+ // Only if all clauses score docs in order return true.
+ for (Iterator iter = clauses.iterator(); iter.hasNext();) {
+ SpanQuery q = (SpanQuery) iter.next();
+ if (!q.scoresDocInOrder()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
}
Index: src/java/org/apache/lucene/search/spans/SpanNotQuery.java
===================================================================
--- src/java/org/apache/lucene/search/spans/SpanNotQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/spans/SpanNotQuery.java (working copy)
@@ -197,4 +197,8 @@
return h;
}
+ public boolean scoresDocInOrder() {
+ return include.scoresDocInOrder() && exclude.scoresDocInOrder();
+ }
+
}
Index: src/java/org/apache/lucene/search/spans/SpanOrQuery.java
===================================================================
--- src/java/org/apache/lucene/search/spans/SpanOrQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/spans/SpanOrQuery.java (working copy)
@@ -243,4 +243,15 @@
};
}
+ public boolean scoresDocInOrder() {
+ // return true only if all clauses score docs in order.
+ for (Iterator iter = clauses.iterator(); iter.hasNext();) {
+ SpanQuery q = (SpanQuery) iter.next();
+ if (!q.scoresDocInOrder()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
}
Index: src/java/org/apache/lucene/search/spans/SpanQuery.java
===================================================================
--- src/java/org/apache/lucene/search/spans/SpanQuery.java (revision 770123)
+++ src/java/org/apache/lucene/search/spans/SpanQuery.java (working copy)
@@ -17,15 +17,14 @@
* limitations under the License.
*/
+import java.io.IOException;
+import java.util.Collection;
+
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.search.Weight;
-import java.io.IOException;
-import java.util.Collection;
-import java.util.Set;
-
/** Base class for span-based queries. */
public abstract class SpanQuery extends Query {
/** Expert: Returns the matches for this query in an index. Used internally
@@ -46,7 +45,7 @@
*/
public PayloadSpans getPayloadSpans(IndexReader reader) throws IOException{
return null;
- };
+ }
/** Returns the name of the field matched by this query.*/
public abstract String getField();
@@ -61,5 +60,8 @@
return new SpanWeight(this, searcher);
}
+ public boolean scoresDocInOrder() {
+ return true;
+ }
+
}
-
Index: src/java/org/apache/lucene/util/PriorityQueue.java
===================================================================
--- src/java/org/apache/lucene/util/PriorityQueue.java (revision 770123)
+++ src/java/org/apache/lucene/util/PriorityQueue.java (working copy)
@@ -29,6 +29,49 @@
must define this one method. */
protected abstract boolean lessThan(Object a, Object b);
+ /**
+ * This method can be overridden by extending classes to return a sentinel
+ * object which will be used by {@link #initialize(int)} to fill the queue, so
+ * that the code which uses that queue can always assume it's full and only
+ * change the top without attempting to insert any new object.
+ *
+ * Those sentinel values should always compare worse than any non-sentinel
+ * value (i.e., {@link #lessThan(Object, Object)} should always favor the
+ * non-sentinel values).
+ *
+ * By default, this method returns false, which means the queue will not be
+ * filled with sentinel values. Otherwise, the value returned will be used to
+ * pre-populate the queue. Adds sentinel values to the queue.
+ *
+ * If this method is extended to return a non-null value, then the following
+ * usage pattern is recommended:
+ *
+ *
+ * // extends getSentinelObject() to return a non-null value.
+ * PriorityQueue pq = new MyQueue(numHits);
+ * // save the 'top' element, which is guaranteed to not be null.
+ * MyObject pqTop = (MyObject) pq.top();
+ * <...>
+ * // now in order to add a new element, which is 'better' than top (after
+ * // you've verified it is better), it is as simple as:
+ * pqTop.change().
+ * pqTop = pq.updateTop();
+ *
+ *
+ * NOTE: if this method returns a non-null value, it will be called by
+ * {@link #initialize(int)} {@link #size()} times, relying on a new object to
+ * be returned and will not check if it's null again. Therefore you should
+ * ensure any call to this method creates a new instance and behaves
+ * consistently, e.g., it cannot return null if it previously returned
+ * non-null.
+ *
+ * @return the sentinel object to use to pre-populate the queue, or null if
+ * sentinel objects are not supported.
+ */
+ protected Object getSentinelObject() {
+ return null;
+ }
+
/** Subclass constructors must call this. */
protected final void initialize(int maxSize) {
size = 0;
@@ -40,12 +83,25 @@
heapSize = maxSize + 1;
heap = new Object[heapSize];
this.maxSize = maxSize;
+
+ // If sentinel objects are supported, populate the queue with them
+ Object sentinel = getSentinelObject();
+ if (sentinel != null) {
+ heap[1] = sentinel;
+ for (int i = 2; i < heap.length; i++) {
+ heap[i] = getSentinelObject();
+ }
+ size = maxSize;
+ }
}
/**
- * Adds an Object to a PriorityQueue in log(size) time.
- * If one tries to add more objects than maxSize from initialize
- * a RuntimeException (ArrayIndexOutOfBound) is thrown.
+ * Adds an Object to a PriorityQueue in log(size) time. If one tries to add
+ * more objects than maxSize from initialize a RuntimeException
+ * (ArrayIndexOutOfBound) is thrown.
+ *
+ * @deprecated use {@link #add(Object)} which returns the new top object,
+ * saving an additional call to {@link #top()}.
*/
public final void put(Object element) {
size++;
@@ -54,10 +110,27 @@
}
/**
- * Adds element to the PriorityQueue in log(size) time if either
- * the PriorityQueue is not full, or not lessThan(element, top()).
+ * Adds an Object to a PriorityQueue in log(size) time. If one tries to add
+ * more objects than maxSize from initialize an
+ * {@link ArrayIndexOutOfBoundsException} is thrown.
+ *
+ * @return the new 'top' element in the queue.
+ */
+ public final Object add(Object element) {
+ size++;
+ heap[size] = element;
+ upHeap();
+ return heap[1];
+ }
+
+ /**
+ * Adds element to the PriorityQueue in log(size) time if either the
+ * PriorityQueue is not full, or not lessThan(element, top()).
+ *
* @param element
* @return true if element is added, false otherwise.
+ * @deprecated use {@link #insertWithOverflow(Object)} instead, which
+ * encourages objects reuse.
*/
public boolean insert(Object element) {
return insertWithOverflow(element) != element;
@@ -109,16 +182,53 @@
return null;
}
- /** Should be called when the Object at top changes values. Still log(n)
- * worst case, but it's at least twice as fast to
- * { pq.top().change(); pq.adjustTop(); }
- * instead of
- * { o = pq.pop(); o.change(); pq.push(o); }
+ /**
+ * Should be called when the Object at top changes values. Still log(n) worst
+ * case, but it's at least twice as fast to
+ *
+ *
+ * pq.top().change();
+ * pq.adjustTop();
*
+ *
+ * instead of
+ *
+ *
+ * o = pq.pop();
+ * o.change();
+ * pq.push(o);
+ *
+ *
+ * @deprecated use {@link #updateTop()} which returns the new top element and
+ * saves an additional call to {@link #top()}.
*/
public final void adjustTop() {
downHeap();
}
+
+ /**
+ * Should be called when the Object at top changes values. Still log(n) worst
+ * case, but it's at least twice as fast to
+ *
+ *
+ * pq.top().change();
+ * pq.updateTop();
+ *
+ *
+ * instead of
+ *
+ *
+ * o = pq.pop();
+ * o.change();
+ * pq.push(o);
+ *
+ *
+ * @return the new 'top' element.
+ */
+ public final Object updateTop() {
+ downHeap();
+ return heap[1];
+ }
/** Returns the number of elements currently stored in the PriorityQueue. */
public final int size() {
@@ -127,8 +237,9 @@
/** Removes all entries from the PriorityQueue. */
public final void clear() {
- for (int i = 0; i <= size; i++)
+ for (int i = 0; i <= size; i++) {
heap[i] = null;
+ }
size = 0;
}
Index: src/test/org/apache/lucene/index/TestIndexReader.java
===================================================================
--- src/test/org/apache/lucene/index/TestIndexReader.java (revision 770123)
+++ src/test/org/apache/lucene/index/TestIndexReader.java (working copy)
@@ -39,20 +39,17 @@
import org.apache.lucene.document.Fieldable;
import org.apache.lucene.document.SetBasedFieldSelector;
import org.apache.lucene.index.IndexReader.FieldOption;
-import org.apache.lucene.search.Collector;
+import org.apache.lucene.search.FieldCache;
import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
-import org.apache.lucene.search.Scorer;
import org.apache.lucene.search.TermQuery;
-import org.apache.lucene.search.FieldCache;
import org.apache.lucene.store.AlreadyClosedException;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.MockRAMDirectory;
-import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.store.NoSuchDirectoryException;
+import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util._TestUtil;
@@ -1644,59 +1641,6 @@
dir.close();
}
- // LUCENE-1483
- public void testDocsInOrderSearch() throws Throwable {
- Directory dir = new MockRAMDirectory();
-
- IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(),
- IndexWriter.MaxFieldLength.LIMITED);
- writer.addDocument(createDocument("a"));
- writer.commit();
- writer.addDocument(createDocument("a"));
- writer.addDocument(createDocument("a"));
- writer.close();
-
- Query q = new TermQuery(new Term("id", "a"));
-
- IndexSearcher s = new IndexSearcher(dir);
- s.search(q, new Collector() {
- int lastDocBase = -1;
- public void setNextReader(IndexReader reader, int docBase) {
- if (lastDocBase == -1) {
- assertEquals(1, docBase);
- } else if (lastDocBase == 1) {
- assertEquals(0, docBase);
- } else {
- fail();
- }
- lastDocBase = docBase;
- }
- public void collect(int doc) {}
- public void setScorer(Scorer scorer) {}
- });
- s.close();
-
- IndexReader r = IndexReader.open(dir);
- s = new IndexSearcher(r, true);
- s.search(q, new Collector() {
- int lastDocBase = -1;
- public void setNextReader(IndexReader reader, int docBase) {
- if (lastDocBase == -1) {
- assertEquals(0, docBase);
- } else if (lastDocBase == 0) {
- assertEquals(1, docBase);
- } else {
- fail();
- }
- lastDocBase = docBase;
- }
- public void collect(int doc) {}
- public void setScorer(Scorer scorer) {}
- });
- s.close();
- r.close();
- }
-
// LUCENE-1579: Ensure that on a cloned reader, segments
// reuse the doc values arrays in FieldCache
public void testFieldCacheReuseAfterClone() throws Exception {
Index: src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java
===================================================================
--- src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java (revision 770123)
+++ src/test/org/apache/lucene/search/TestPositiveScoresOnlyCollector.java (working copy)
@@ -68,7 +68,7 @@
}
Scorer s = new SimpleScorer();
- TopDocsCollector tdc = new TopScoreDocCollector(scores.length);
+ TopDocsCollector tdc = TopScoreDocCollector.create(scores.length, true);
Collector c = new PositiveScoresOnlyCollector(tdc);
c.setScorer(s);
while (!s.next()) {
Index: src/test/org/apache/lucene/search/TestSort.java
===================================================================
--- src/test/org/apache/lucene/search/TestSort.java (revision 770123)
+++ src/test/org/apache/lucene/search/TestSort.java (working copy)
@@ -17,9 +17,20 @@
* limitations under the License.
*/
+import java.io.IOException;
+import java.io.Serializable;
+import java.rmi.Naming;
+import java.rmi.registry.LocateRegistry;
+import java.util.BitSet;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Random;
+
import junit.framework.Test;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
+
import org.apache.lucene.analysis.SimpleAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
@@ -28,22 +39,12 @@
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.ParseException;
+import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.DocIdBitSet;
import org.apache.lucene.util.LuceneTestCase;
-import java.io.IOException;
-import java.io.Serializable;
-import java.rmi.Naming;
-import java.rmi.registry.LocateRegistry;
-import java.util.BitSet;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Locale;
-import java.util.Random;
-import java.util.regex.Pattern;
-
/**
* Unit tests for sorting code.
*
@@ -53,9 +54,7 @@
* @version $Id$
*/
-public class TestSort
-extends LuceneTestCase
-implements Serializable {
+public class TestSort extends LuceneTestCase implements Serializable {
private static final int NUM_STRINGS = 6000;
private Searcher full;
@@ -118,7 +117,7 @@
{ "Y", "g", "1", "0.2", null, null, null, null, null, null, null, null},
{ "Z", "f g", null, null, null, null, null, null, null, null, null, null}
};
-
+
// create an index of all the documents, or just the x, or just the y documents
private Searcher getIndex (boolean even, boolean odd)
throws IOException {
@@ -343,28 +342,28 @@
public void testCustomFieldParserSort() throws Exception {
sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.IntParser(){
public final int parseInt(final String val) {
- return (int) (val.charAt(0)-'A') * 123456;
+ return (val.charAt(0)-'A') * 123456;
}
}), SortField.FIELD_DOC });
assertMatches (full, queryA, sort, "JIHGFEDCBA");
sort.setSort (new SortField[] { new SortField ("parser", new FieldCache.FloatParser(){
public final float parseFloat(final String val) {
- return (float) Math.sqrt( (double) val.charAt(0) );
+ return (float) Math.sqrt( val.charAt(0) );
}
}), SortField.FIELD_DOC });
assertMatches (full, queryA, sort, "JIHGFEDCBA");
sort.setSort (new SortField[] { new SortField ("parser", new ExtendedFieldCache.LongParser(){
public final long parseLong(final String val) {
- return (long) (val.charAt(0)-'A') * 1234567890L;
+ return (val.charAt(0)-'A') * 1234567890L;
}
}), SortField.FIELD_DOC });
assertMatches (full, queryA, sort, "JIHGFEDCBA");
sort.setSort (new SortField[] { new SortField ("parser", new ExtendedFieldCache.DoubleParser(){
public final double parseDouble(final String val) {
- return Math.pow( (double) val.charAt(0), (double) (val.charAt(0)-'A') );
+ return Math.pow( val.charAt(0), (val.charAt(0)-'A') );
}
}), SortField.FIELD_DOC });
assertMatches (full, queryA, sort, "JIHGFEDCBA");
@@ -432,7 +431,7 @@
public void setNextReader(IndexReader reader, int docBase, int numSlotsFull) throws IOException {
docValues = FieldCache.DEFAULT.getInts(reader, "parser", new FieldCache.IntParser() {
public final int parseInt(final String val) {
- return (int) (val.charAt(0)-'A') * 123456;
+ return (val.charAt(0)-'A') * 123456;
}
});
}
@@ -642,20 +641,20 @@
// test a variety of sorts using more than one searcher
public void testMultiSort() throws Exception {
MultiSearcher searcher = new MultiSearcher (new Searchable[] { searchX, searchY });
- runMultiSorts (searcher);
+ runMultiSorts(searcher, false);
}
// test a variety of sorts using a parallel multisearcher
public void testParallelMultiSort() throws Exception {
Searcher searcher = new ParallelMultiSearcher (new Searchable[] { searchX, searchY });
- runMultiSorts (searcher);
+ runMultiSorts(searcher, false);
}
// test a variety of sorts using a remote searcher
public void testRemoteSort() throws Exception {
Searchable searcher = getRemote();
MultiSearcher multi = new MultiSearcher (new Searchable[] { searcher });
- runMultiSorts (multi);
+ runMultiSorts(multi, true); // this runs on the full index
}
// test custom search when remote
@@ -813,9 +812,11 @@
// fillFields to true.
Sort[] sort = new Sort[] { new Sort(SortField.FIELD_DOC), new Sort() };
for (int i = 0; i < sort.length; i++) {
- TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, false, false, false);
+ Query q = new MatchAllDocsQuery();
+ TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, false,
+ false, false, q.scoresDocInOrder());
- full.search(new MatchAllDocsQuery(), tdc);
+ full.search(q, tdc);
ScoreDoc[] sd = tdc.topDocs().scoreDocs;
for (int j = 1; j < sd.length; j++) {
@@ -830,9 +831,11 @@
// Two Sort criteria to instantiate the multi/single comparators.
Sort[] sort = new Sort[] {new Sort(SortField.FIELD_DOC), new Sort() };
for (int i = 0; i < sort.length; i++) {
- TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, false, false);
+ Query q = new MatchAllDocsQuery();
+ TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, false,
+ false, q.scoresDocInOrder());
- full.search(new MatchAllDocsQuery(), tdc);
+ full.search(q, tdc);
TopDocs td = tdc.topDocs();
ScoreDoc[] sd = td.scoreDocs;
@@ -848,9 +851,11 @@
// Two Sort criteria to instantiate the multi/single comparators.
Sort[] sort = new Sort[] {new Sort(SortField.FIELD_DOC), new Sort() };
for (int i = 0; i < sort.length; i++) {
- TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, true, false);
+ Query q = new MatchAllDocsQuery();
+ TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, true,
+ false, q.scoresDocInOrder());
- full.search(new MatchAllDocsQuery(), tdc);
+ full.search(q, tdc);
TopDocs td = tdc.topDocs();
ScoreDoc[] sd = td.scoreDocs;
@@ -866,9 +871,11 @@
// Two Sort criteria to instantiate the multi/single comparators.
Sort[] sort = new Sort[] {new Sort(SortField.FIELD_DOC), new Sort() };
for (int i = 0; i < sort.length; i++) {
- TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, true, true);
+ Query q = new MatchAllDocsQuery();
+ TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, true,
+ true, q.scoresDocInOrder());
- full.search(new MatchAllDocsQuery(), tdc);
+ full.search(q, tdc);
TopDocs td = tdc.topDocs();
ScoreDoc[] sd = td.scoreDocs;
@@ -879,12 +886,74 @@
}
}
+ public void testOutOfOrderDocsScoringSort() throws Exception {
+
+ // Two Sort criteria to instantiate the multi/single comparators.
+ Sort[] sort = new Sort[] {new Sort(SortField.FIELD_DOC), new Sort() };
+ boolean[][] tfcOptions = new boolean[][] {
+ new boolean[] { false, false, false },
+ new boolean[] { false, false, true },
+ new boolean[] { false, true, false },
+ new boolean[] { false, true, true },
+ new boolean[] { true, false, false },
+ new boolean[] { true, false, true },
+ new boolean[] { true, true, false },
+ new boolean[] { true, true, true },
+ };
+ String[] actualTFCClasses = new String[] {
+ "OutOfOrderOneComparatorNonScoringCollector",
+ "OutOfOrderOneComparatorScoringMaxScoreCollector",
+ "OutOfOrderOneComparatorScoringNoMaxScoreCollector",
+ "OutOfOrderOneComparatorScoringMaxScoreCollector",
+ "OutOfOrderOneComparatorNonScoringCollector",
+ "OutOfOrderOneComparatorScoringMaxScoreCollector",
+ "OutOfOrderOneComparatorScoringNoMaxScoreCollector",
+ "OutOfOrderOneComparatorScoringMaxScoreCollector"
+ };
+
+ // Save the original value to set later.
+ boolean origVal = BooleanQuery.getAllowDocsOutOfOrder();
+
+ BooleanQuery.setAllowDocsOutOfOrder(true);
+
+ BooleanQuery bq = new BooleanQuery();
+ // Add a Query with SHOULD, since bw.scorer() returns BooleanScorer2
+ // which delegates to BS if there are no mandatory clauses.
+ bq.add(new MatchAllDocsQuery(), Occur.SHOULD);
+ // Set minNrShouldMatch to 1 so that BQ will not optimize rewrite to return
+ // the clause instead of BQ.
+ bq.setMinimumNumberShouldMatch(1);
+ try {
+ for (int i = 0; i < sort.length; i++) {
+ for (int j = 0; j < tfcOptions.length; j++) {
+ TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10,
+ tfcOptions[j][0], tfcOptions[j][1], tfcOptions[j][2], bq
+ .scoresDocInOrder());
+
+ assertEquals(actualTFCClasses[j], tdc.getClass().getSimpleName());
+
+ full.search(bq, tdc);
+
+ TopDocs td = tdc.topDocs();
+ ScoreDoc[] sd = td.scoreDocs;
+ assertEquals(10, sd.length);
+ }
+ }
+ } finally {
+ // Whatever happens, reset BooleanQuery.allowDocsOutOfOrder to the
+ // original value. Don't set it to false in case the implementation in BQ
+ // will change some day.
+ BooleanQuery.setAllowDocsOutOfOrder(origVal);
+ }
+
+ }
+
public void testSortWithScoreAndMaxScoreTrackingNoResults() throws Exception {
// Two Sort criteria to instantiate the multi/single comparators.
Sort[] sort = new Sort[] {new Sort(SortField.FIELD_DOC), new Sort() };
for (int i = 0; i < sort.length; i++) {
- TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, true, true);
+ TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, true, true, true);
TopDocs td = tdc.topDocs();
assertEquals(0, td.totalHits);
assertTrue(Float.isNaN(td.getMaxScore()));
@@ -892,68 +961,73 @@
}
// runs a variety of sorts useful for multisearchers
- private void runMultiSorts (Searcher multi) throws Exception {
- sort.setSort (SortField.FIELD_DOC);
- assertMatchesPattern (multi, queryA, sort, "[AB]{2}[CD]{2}[EF]{2}[GH]{2}[IJ]{2}");
+ private void runMultiSorts(Searcher multi, boolean isFull) throws Exception {
+ sort.setSort(SortField.FIELD_DOC);
+ String expected = isFull ? "ABCDEFGHIJ" : "ACEGIBDFHJ";
+ assertMatches(multi, queryA, sort, expected);
- sort.setSort (new SortField ("int", SortField.INT));
- assertMatchesPattern (multi, queryA, sort, "IDHFGJ[ABE]{3}C");
+ sort.setSort(new SortField ("int", SortField.INT));
+ expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC";
+ assertMatches(multi, queryA, sort, expected);
- sort.setSort (new SortField[] {new SortField ("int", SortField.INT), SortField.FIELD_DOC});
- assertMatchesPattern (multi, queryA, sort, "IDHFGJ[AB]{2}EC");
+ sort.setSort(new SortField[] {new SortField ("int", SortField.INT), SortField.FIELD_DOC});
+ expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC";
+ assertMatches(multi, queryA, sort, expected);
- sort.setSort ("int");
- assertMatchesPattern (multi, queryA, sort, "IDHFGJ[AB]{2}EC");
+ sort.setSort("int");
+ expected = isFull ? "IDHFGJABEC" : "IDHFGJAEBC";
+ assertMatches(multi, queryA, sort, expected);
- sort.setSort (new SortField[] {new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC});
- assertMatchesPattern (multi, queryA, sort, "GDHJ[CI]{2}EFAB");
+ sort.setSort(new SortField[] {new SortField ("float", SortField.FLOAT), SortField.FIELD_DOC});
+ assertMatches(multi, queryA, sort, "GDHJCIEFAB");
- sort.setSort ("float");
- assertMatchesPattern (multi, queryA, sort, "GDHJ[CI]{2}EFAB");
+ sort.setSort("float");
+ assertMatches(multi, queryA, sort, "GDHJCIEFAB");
- sort.setSort ("string");
- assertMatches (multi, queryA, sort, "DJAIHGFEBC");
+ sort.setSort("string");
+ assertMatches(multi, queryA, sort, "DJAIHGFEBC");
- sort.setSort ("int", true);
- assertMatchesPattern (multi, queryA, sort, "C[AB]{2}EJGFHDI");
+ sort.setSort("int", true);
+ expected = isFull ? "CABEJGFHDI" : "CAEBJGFHDI";
+ assertMatches(multi, queryA, sort, expected);
- sort.setSort ("float", true);
- assertMatchesPattern (multi, queryA, sort, "BAFE[IC]{2}JHDG");
+ sort.setSort("float", true);
+ assertMatches(multi, queryA, sort, "BAFECIJHDG");
- sort.setSort ("string", true);
- assertMatches (multi, queryA, sort, "CBEFGHIAJD");
+ sort.setSort("string", true);
+ assertMatches(multi, queryA, sort, "CBEFGHIAJD");
- sort.setSort (new SortField[] { new SortField ("string", Locale.US) });
- assertMatches (multi, queryA, sort, "DJAIHGFEBC");
+ sort.setSort(new SortField[] { new SortField ("string", Locale.US) });
+ assertMatches(multi, queryA, sort, "DJAIHGFEBC");
- sort.setSort (new SortField[] { new SortField ("string", Locale.US, true) });
- assertMatches (multi, queryA, sort, "CBEFGHIAJD");
+ sort.setSort(new SortField[] { new SortField ("string", Locale.US, true) });
+ assertMatches(multi, queryA, sort, "CBEFGHIAJD");
- sort.setSort (new String[] {"int","float"});
- assertMatches (multi, queryA, sort, "IDHFGJEABC");
+ sort.setSort(new String[] {"int","float"});
+ assertMatches(multi, queryA, sort, "IDHFGJEABC");
- sort.setSort (new String[] {"float","string"});
- assertMatches (multi, queryA, sort, "GDHJICEFAB");
+ sort.setSort(new String[] {"float","string"});
+ assertMatches(multi, queryA, sort, "GDHJICEFAB");
- sort.setSort ("int");
- assertMatches (multi, queryF, sort, "IZJ");
+ sort.setSort("int");
+ assertMatches(multi, queryF, sort, "IZJ");
- sort.setSort ("int", true);
- assertMatches (multi, queryF, sort, "JZI");
+ sort.setSort("int", true);
+ assertMatches(multi, queryF, sort, "JZI");
- sort.setSort ("float");
- assertMatches (multi, queryF, sort, "ZJI");
+ sort.setSort("float");
+ assertMatches(multi, queryF, sort, "ZJI");
- sort.setSort ("string");
- assertMatches (multi, queryF, sort, "ZJI");
+ sort.setSort("string");
+ assertMatches(multi, queryF, sort, "ZJI");
- sort.setSort ("string", true);
- assertMatches (multi, queryF, sort, "IJZ");
+ sort.setSort("string", true);
+ assertMatches(multi, queryF, sort, "IJZ");
}
// make sure the documents returned by the search match the expected list
- private void assertMatches (Searcher searcher, Query query, Sort sort, String expectedResult)
- throws IOException {
+ private void assertMatches(Searcher searcher, Query query, Sort sort,
+ String expectedResult) throws IOException {
//ScoreDoc[] result = searcher.search (query, null, 1000, sort).scoreDocs;
TopDocs hits = searcher.search (query, null, expectedResult.length(), sort);
ScoreDoc[] result = hits.scoreDocs;
@@ -970,23 +1044,6 @@
assertEquals (expectedResult, buff.toString());
}
- // make sure the documents returned by the search match the expected list pattern
- private void assertMatchesPattern (Searcher searcher, Query query, Sort sort, String pattern)
- throws IOException {
- ScoreDoc[] result = searcher.search (query, null, 1000, sort).scoreDocs;
- StringBuffer buff = new StringBuffer(10);
- int n = result.length;
- for (int i=0; i