diff --git a/src/main/java/org/elasticsearch/common/lucene/search/EmptyScorer.java b/src/main/java/org/elasticsearch/common/lucene/search/EmptyScorer.java index 8834c49ce17..4955c829653 100644 --- a/src/main/java/org/elasticsearch/common/lucene/search/EmptyScorer.java +++ b/src/main/java/org/elasticsearch/common/lucene/search/EmptyScorer.java @@ -20,7 +20,7 @@ package org.elasticsearch.common.lucene.search; import org.apache.lucene.search.Scorer; -import org.apache.lucene.search.Similarity; +import org.apache.lucene.search.Weight; import java.io.IOException; @@ -29,8 +29,8 @@ import java.io.IOException; */ public class EmptyScorer extends Scorer { - public EmptyScorer(Similarity similarity) { - super(similarity); + public EmptyScorer(Weight weight) { + super(weight); } @Override @@ -38,6 +38,11 @@ public class EmptyScorer extends Scorer { return 0; } + @Override + public float freq() throws IOException { + return 0; + } + @Override public int docID() { return NO_MORE_DOCS; diff --git a/src/main/java/org/elasticsearch/common/lucene/search/NoopCollector.java b/src/main/java/org/elasticsearch/common/lucene/search/NoopCollector.java index 15a4f5efcb1..60c52b4f2dd 100644 --- a/src/main/java/org/elasticsearch/common/lucene/search/NoopCollector.java +++ b/src/main/java/org/elasticsearch/common/lucene/search/NoopCollector.java @@ -19,6 +19,7 @@ package org.elasticsearch.common.lucene.search; +import org.apache.lucene.index.AtomicReaderContext; import org.apache.lucene.index.IndexReader; import org.apache.lucene.search.Collector; import org.apache.lucene.search.Scorer; @@ -41,7 +42,8 @@ public class NoopCollector extends Collector { } @Override - public void setNextReader(IndexReader reader, int docBase) throws IOException { + public void setNextReader(AtomicReaderContext context) throws IOException { + throw new UnsupportedOperationException(); } @Override diff --git a/src/main/java/org/elasticsearch/index/cache/id/IdCache.java b/src/main/java/org/elasticsearch/index/cache/id/IdCache.java index 33bd68bee55..25bebb45b53 100644 --- a/src/main/java/org/elasticsearch/index/cache/id/IdCache.java +++ b/src/main/java/org/elasticsearch/index/cache/id/IdCache.java @@ -19,6 +19,7 @@ package org.elasticsearch.index.cache.id; +import org.apache.lucene.index.AtomicReader; import org.apache.lucene.index.AtomicReaderContext; import org.apache.lucene.index.IndexReader; import org.elasticsearch.common.component.CloseableComponent; @@ -37,7 +38,7 @@ public interface IdCache extends IndexComponent, CloseableComponent, Iterable readers) throws Exception; - IdReaderCache reader(IndexReader reader); + IdReaderCache reader(AtomicReader reader); long sizeInBytes(); diff --git a/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdCache.java b/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdCache.java index 0d954f02c73..38aeef884f6 100644 --- a/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdCache.java +++ b/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdCache.java @@ -24,7 +24,6 @@ import org.apache.lucene.index.*; import org.apache.lucene.util.BytesRef; import org.elasticsearch.ElasticSearchException; import org.elasticsearch.ElasticSearchIllegalArgumentException; -import org.elasticsearch.common.bytes.BytesReference; import org.elasticsearch.common.bytes.HashedBytesArray; import org.elasticsearch.common.collect.MapBuilder; import org.elasticsearch.common.inject.Inject; @@ -35,7 +34,6 @@ import org.elasticsearch.index.AbstractIndexComponent; import org.elasticsearch.index.Index; import org.elasticsearch.index.cache.id.IdCache; import org.elasticsearch.index.cache.id.IdReaderCache; -import org.elasticsearch.index.mapper.Uid; import org.elasticsearch.index.mapper.internal.ParentFieldMapper; import org.elasticsearch.index.mapper.internal.UidFieldMapper; import org.elasticsearch.index.settings.IndexSettings; @@ -77,7 +75,7 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se } @Override - public IdReaderCache reader(IndexReader reader) { + public IdReaderCache reader(AtomicReader reader) { return idReaders.get(reader.getCoreCacheKey()); } @@ -98,7 +96,7 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se } // do the refresh - Map> builders = new HashMap>(); + Map> builders = new HashMap>(); // first, go over and load all the id->doc map for all types for (AtomicReaderContext context : atomicReaderContexts) { @@ -111,7 +109,7 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se if (reader instanceof SegmentReader) { ((SegmentReader) reader).addCoreClosedListener(this); } - Map readerBuilder = new HashMap(); + Map readerBuilder = new HashMap(); builders.put(reader.getCoreCacheKey(), readerBuilder); @@ -124,10 +122,10 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se DocsEnum docsEnum = null; for (BytesRef term = termsEnum.next(); term != null; term = termsEnum.term()) { HashedBytesArray[] typeAndId = splitUidIntoTypeAndId(term); - TypeBuilder typeBuilder = readerBuilder.get(typeAndId[0]); + TypeBuilder typeBuilder = readerBuilder.get(typeAndId[0].toUtf8()); if (typeBuilder == null) { typeBuilder = new TypeBuilder(reader); - readerBuilder.put(typeAndId[0], typeBuilder); + readerBuilder.put(typeAndId[0].toUtf8(), typeBuilder); } HashedBytesArray idAsBytes = checkIfCanReuse(builders, typeAndId[1]); @@ -148,7 +146,7 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se continue; } - Map readerBuilder = builders.get(reader.getCoreCacheKey()); + Map readerBuilder = builders.get(reader.getCoreCacheKey()); Terms terms = reader.terms(ParentFieldMapper.NAME); if (terms == null) { // Should not happen @@ -160,10 +158,10 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se for (BytesRef term = termsEnum.next(); term != null; term = termsEnum.term()) { HashedBytesArray[] typeAndId = splitUidIntoTypeAndId(term); - TypeBuilder typeBuilder = readerBuilder.get(typeAndId[0]); + TypeBuilder typeBuilder = readerBuilder.get(typeAndId[0].toUtf8()); if (typeBuilder == null) { typeBuilder = new TypeBuilder(reader); - readerBuilder.put(typeAndId[0], typeBuilder); + readerBuilder.put(typeAndId[0].toUtf8(), typeBuilder); } HashedBytesArray idAsBytes = checkIfCanReuse(builders, typeAndId[1]); @@ -186,9 +184,9 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se // now, build it back - for (Map.Entry> entry : builders.entrySet()) { - MapBuilder types = MapBuilder.newMapBuilder(); - for (Map.Entry typeBuilderEntry : entry.getValue().entrySet()) { + for (Map.Entry> entry : builders.entrySet()) { + MapBuilder types = MapBuilder.newMapBuilder(); + for (Map.Entry typeBuilderEntry : entry.getValue().entrySet()) { types.put(typeBuilderEntry.getKey(), new SimpleIdReaderTypeCache(typeBuilderEntry.getKey(), typeBuilderEntry.getValue().idToDoc, typeBuilderEntry.getValue().docToId, @@ -210,7 +208,7 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se return sizeInBytes; } - private HashedBytesArray checkIfCanReuse(Map> builders, HashedBytesArray idAsBytes) { + private HashedBytesArray checkIfCanReuse(Map> builders, HashedBytesArray idAsBytes) { HashedBytesArray finalIdAsBytes; // go over and see if we can reuse this id for (SimpleIdReaderCache idReaderCache : idReaders.values()) { @@ -219,7 +217,7 @@ public class SimpleIdCache extends AbstractIndexComponent implements IdCache, Se return finalIdAsBytes; } } - for (Map map : builders.values()) { + for (Map map : builders.values()) { for (TypeBuilder typeBuilder : map.values()) { finalIdAsBytes = typeBuilder.canReuse(idAsBytes); if (finalIdAsBytes != null) { diff --git a/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderCache.java b/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderCache.java index f57f65e4648..5d6d5d1abdc 100644 --- a/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderCache.java +++ b/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderCache.java @@ -20,8 +20,6 @@ package org.elasticsearch.index.cache.id.simple; import com.google.common.collect.ImmutableMap; -import org.elasticsearch.common.bytes.BytesArray; -import org.elasticsearch.common.bytes.BytesReference; import org.elasticsearch.common.bytes.HashedBytesArray; import org.elasticsearch.index.cache.id.IdReaderCache; import org.elasticsearch.index.cache.id.IdReaderTypeCache; @@ -33,9 +31,9 @@ public class SimpleIdReaderCache implements IdReaderCache { private final Object readerCacheKey; - private final ImmutableMap types; + private final ImmutableMap types; - public SimpleIdReaderCache(Object readerCacheKey, ImmutableMap types) { + public SimpleIdReaderCache(Object readerCacheKey, ImmutableMap types) { this.readerCacheKey = readerCacheKey; this.types = types; } @@ -47,12 +45,12 @@ public class SimpleIdReaderCache implements IdReaderCache { @Override public IdReaderTypeCache type(String type) { - return types.get(new BytesArray(type)); + return types.get(type); } @Override public HashedBytesArray parentIdByDoc(String type, int docId) { - SimpleIdReaderTypeCache typeCache = types.get(new BytesArray(type)); + SimpleIdReaderTypeCache typeCache = types.get(type); if (typeCache != null) { return typeCache.parentIdByDoc(docId); } @@ -61,7 +59,7 @@ public class SimpleIdReaderCache implements IdReaderCache { @Override public int docById(String type, HashedBytesArray id) { - SimpleIdReaderTypeCache typeCache = types.get(new BytesArray(type)); + SimpleIdReaderTypeCache typeCache = types.get(type); if (typeCache != null) { return typeCache.docById(id); } diff --git a/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderTypeCache.java b/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderTypeCache.java index ac63bc378f0..083e79f3b51 100644 --- a/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderTypeCache.java +++ b/src/main/java/org/elasticsearch/index/cache/id/simple/SimpleIdReaderTypeCache.java @@ -21,7 +21,6 @@ package org.elasticsearch.index.cache.id.simple; import gnu.trove.impl.hash.TObjectHash; import org.elasticsearch.common.RamUsage; -import org.elasticsearch.common.bytes.BytesReference; import org.elasticsearch.common.bytes.HashedBytesArray; import org.elasticsearch.common.trove.ExtTObjectIntHasMap; import org.elasticsearch.index.cache.id.IdReaderTypeCache; @@ -31,7 +30,7 @@ import org.elasticsearch.index.cache.id.IdReaderTypeCache; */ public class SimpleIdReaderTypeCache implements IdReaderTypeCache { - private final BytesReference type; + private final String type; private final ExtTObjectIntHasMap idToDoc; @@ -43,7 +42,7 @@ public class SimpleIdReaderTypeCache implements IdReaderTypeCache { private long sizeInBytes = -1; - public SimpleIdReaderTypeCache(BytesReference type, ExtTObjectIntHasMap idToDoc, HashedBytesArray[] docIdToId, + public SimpleIdReaderTypeCache(String type, ExtTObjectIntHasMap idToDoc, HashedBytesArray[] docIdToId, HashedBytesArray[] parentIdsValues, int[] parentIdsOrdinals) { this.type = type; this.idToDoc = idToDoc; @@ -53,7 +52,7 @@ public class SimpleIdReaderTypeCache implements IdReaderTypeCache { this.parentIdsOrdinals = parentIdsOrdinals; } - public BytesReference type() { + public String type() { return this.type; } diff --git a/src/main/java/org/elasticsearch/index/search/child/ChildCollector.java b/src/main/java/org/elasticsearch/index/search/child/ChildCollector.java index 9a308cb485f..974cd1e2739 100644 --- a/src/main/java/org/elasticsearch/index/search/child/ChildCollector.java +++ b/src/main/java/org/elasticsearch/index/search/child/ChildCollector.java @@ -19,6 +19,8 @@ package org.elasticsearch.index.search.child; +import org.apache.lucene.index.AtomicReader; +import org.apache.lucene.index.AtomicReaderContext; import org.apache.lucene.index.IndexReader; import org.apache.lucene.search.Collector; import org.apache.lucene.search.Scorer; @@ -41,7 +43,7 @@ public class ChildCollector extends Collector { private final SearchContext context; - private final Tuple[] readers; + private final Tuple[] readers; private final Map parentDocs; @@ -53,10 +55,12 @@ public class ChildCollector extends Collector { this.parentDocs = new HashMap(); // create a specific type map lookup for faster lookup operations per doc - this.readers = new Tuple[context.searcher().subReaders().length]; + this.readers = new Tuple[context.searcher().getIndexReader().leaves().size()]; for (int i = 0; i < readers.length; i++) { - IndexReader reader = context.searcher().subReaders()[i]; - readers[i] = new Tuple(reader, context.idCache().reader(reader).type(parentType)); + AtomicReaderContext readerContext = context.searcher().getIndexReader().leaves().get(i); + readers[i] = new Tuple( + readerContext.reader(), context.idCache().reader(readerContext.reader()).type(parentType) + ); } } @@ -75,14 +79,14 @@ public class ChildCollector extends Collector { if (parentId == null) { return; } - for (Tuple tuple : readers) { + for (Tuple tuple : readers) { IndexReader indexReader = tuple.v1(); IdReaderTypeCache idReaderTypeCache = tuple.v2(); if (idReaderTypeCache == null) { // might be if we don't have that doc with that type in this reader continue; } int parentDocId = idReaderTypeCache.docById(parentId); - if (parentDocId != -1 && !indexReader.isDeleted(parentDocId)) { + if (parentDocId != -1) { FixedBitSet docIdSet = parentDocs().get(indexReader.getCoreCacheKey()); if (docIdSet == null) { docIdSet = new FixedBitSet(indexReader.maxDoc()); @@ -95,8 +99,8 @@ public class ChildCollector extends Collector { } @Override - public void setNextReader(IndexReader reader, int docBase) throws IOException { - typeCache = context.idCache().reader(reader).type(parentType); + public void setNextReader(AtomicReaderContext readerContext) throws IOException { + typeCache = context.idCache().reader(readerContext.reader()).type(parentType); } @Override diff --git a/src/main/java/org/elasticsearch/index/search/child/HasChildFilter.java b/src/main/java/org/elasticsearch/index/search/child/HasChildFilter.java index 81955523835..2833fe70746 100644 --- a/src/main/java/org/elasticsearch/index/search/child/HasChildFilter.java +++ b/src/main/java/org/elasticsearch/index/search/child/HasChildFilter.java @@ -20,11 +20,13 @@ package org.elasticsearch.index.search.child; import gnu.trove.set.hash.THashSet; +import org.apache.lucene.index.AtomicReaderContext; import org.apache.lucene.index.IndexReader; import org.apache.lucene.search.Collector; import org.apache.lucene.search.DocIdSet; import org.apache.lucene.search.Filter; import org.apache.lucene.search.Query; +import org.apache.lucene.util.Bits; import org.apache.lucene.util.FixedBitSet; import org.elasticsearch.ElasticSearchIllegalStateException; import org.elasticsearch.common.CacheRecycler; @@ -106,13 +108,15 @@ public abstract class HasChildFilter extends Filter implements ScopePhase.Collec parentDocs = null; } - public DocIdSet getDocIdSet(IndexReader reader) throws IOException { + public DocIdSet getDocIdSet(AtomicReaderContext context, Bits acceptDocs) throws IOException { if (parentDocs == null) { throw new ElasticSearchIllegalStateException("has_child filter/query hasn't executed properly"); } + // np need to use acceptDocs, since the parentDocs were collected with a collector, which means those + // collected docs are not deleted // ok to return null - return parentDocs.get(reader.getCoreCacheKey()); + return parentDocs.get(context.reader().getCoreCacheKey()); } } @@ -138,14 +142,14 @@ public abstract class HasChildFilter extends Filter implements ScopePhase.Collec collectedUids = ((UidCollector) collector).collectedUids; } - public DocIdSet getDocIdSet(IndexReader reader) throws IOException { + public DocIdSet getDocIdSet(AtomicReaderContext context, Bits acceptDocs) throws IOException { if (collectedUids == null) { throw new ElasticSearchIllegalStateException("has_child filter/query hasn't executed properly"); } - IdReaderTypeCache idReaderTypeCache = searchContext.idCache().reader(reader).type(parentType); + IdReaderTypeCache idReaderTypeCache = searchContext.idCache().reader(context.reader()).type(parentType); if (idReaderTypeCache != null) { - return new ParentDocSet(reader, collectedUids, idReaderTypeCache); + return new ParentDocSet(context.reader(), collectedUids, idReaderTypeCache, acceptDocs); } else { return null; } @@ -163,16 +167,18 @@ public abstract class HasChildFilter extends Filter implements ScopePhase.Collec final IndexReader reader; final THashSet parents; final IdReaderTypeCache typeCache; + final Bits acceptDocs; - ParentDocSet(IndexReader reader, THashSet parents, IdReaderTypeCache typeCache) { + ParentDocSet(IndexReader reader, THashSet parents, IdReaderTypeCache typeCache, Bits acceptDocs) { super(reader.maxDoc()); this.reader = reader; this.parents = parents; this.typeCache = typeCache; + this.acceptDocs = acceptDocs; } public boolean get(int doc) { - return !reader.isDeleted(doc) && parents.contains(typeCache.idByDoc(doc)); + return !acceptDocs.get(doc) && parents.contains(typeCache.idByDoc(doc)); } } @@ -196,8 +202,8 @@ public abstract class HasChildFilter extends Filter implements ScopePhase.Collec } @Override - public void setNextReader(IndexReader reader, int docBase) throws IOException { - typeCache = context.idCache().reader(reader).type(parentType); + public void setNextReader(AtomicReaderContext readerContext) throws IOException { + typeCache = context.idCache().reader(readerContext.reader()).type(parentType); } } } diff --git a/src/main/java/org/elasticsearch/index/search/child/HasParentFilter.java b/src/main/java/org/elasticsearch/index/search/child/HasParentFilter.java index 789d174b6ed..57e2822c646 100644 --- a/src/main/java/org/elasticsearch/index/search/child/HasParentFilter.java +++ b/src/main/java/org/elasticsearch/index/search/child/HasParentFilter.java @@ -20,11 +20,14 @@ package org.elasticsearch.index.search.child; import gnu.trove.set.hash.THashSet; +import org.apache.lucene.index.AtomicReader; +import org.apache.lucene.index.AtomicReaderContext; import org.apache.lucene.index.IndexReader; import org.apache.lucene.search.Collector; import org.apache.lucene.search.DocIdSet; import org.apache.lucene.search.Filter; import org.apache.lucene.search.Query; +import org.apache.lucene.util.Bits; import org.apache.lucene.util.FixedBitSet; import org.elasticsearch.ElasticSearchIllegalStateException; import org.elasticsearch.common.CacheRecycler; @@ -104,14 +107,14 @@ public abstract class HasParentFilter extends Filter implements ScopePhase.Colle parents = ((ParentUidsCollector) collector).collectedUids; } - public DocIdSet getDocIdSet(IndexReader reader) throws IOException { + public DocIdSet getDocIdSet(AtomicReaderContext readerContext, Bits acceptDocs) throws IOException { if (parents == null) { throw new ElasticSearchIllegalStateException("has_parent filter/query hasn't executed properly"); } - IdReaderTypeCache idReaderTypeCache = context.idCache().reader(reader).type(parentType); + IdReaderTypeCache idReaderTypeCache = context.idCache().reader(readerContext.reader()).type(parentType); if (idReaderTypeCache != null) { - return new ChildrenDocSet(reader, parents, idReaderTypeCache); + return new ChildrenDocSet(readerContext.reader(), parents, idReaderTypeCache, acceptDocs); } else { return null; } @@ -129,16 +132,18 @@ public abstract class HasParentFilter extends Filter implements ScopePhase.Colle final IndexReader reader; final THashSet parents; final IdReaderTypeCache idReaderTypeCache; + final Bits acceptDocs; - ChildrenDocSet(IndexReader reader, THashSet parents, IdReaderTypeCache idReaderTypeCache) { + ChildrenDocSet(IndexReader reader, THashSet parents, IdReaderTypeCache idReaderTypeCache, Bits acceptDocs) { super(reader.maxDoc()); this.reader = reader; this.parents = parents; this.idReaderTypeCache = idReaderTypeCache; + this.acceptDocs = acceptDocs; } public boolean get(int doc) { - return !reader.isDeleted(doc) && parents.contains(idReaderTypeCache.parentIdByDoc(doc)); + return !acceptDocs.get(doc) && parents.contains(idReaderTypeCache.parentIdByDoc(doc)); } } @@ -161,8 +166,9 @@ public abstract class HasParentFilter extends Filter implements ScopePhase.Colle collectedUids.add(typeCache.idByDoc(doc)); } - public void setNextReader(IndexReader reader, int docBase) throws IOException { - typeCache = context.idCache().reader(reader).type(parentType); + @Override + public void setNextReader(AtomicReaderContext readerContext) throws IOException { + typeCache = context.idCache().reader(readerContext.reader()).type(parentType); } } @@ -188,12 +194,12 @@ public abstract class HasParentFilter extends Filter implements ScopePhase.Colle parentDocs = ((ParentDocsCollector) collector).segmentResults; } - public DocIdSet getDocIdSet(IndexReader reader) throws IOException { + public DocIdSet getDocIdSet(AtomicReaderContext readerContext, Bits acceptDocs) throws IOException { if (parentDocs == null) { throw new ElasticSearchIllegalStateException("has_parent filter/query hasn't executed properly"); } - return new ChildrenDocSet(reader, parentDocs, context, parentType); + return new ChildrenDocSet(readerContext.reader(), parentDocs, context, parentType, acceptDocs); } public void clear() { @@ -203,25 +209,27 @@ public abstract class HasParentFilter extends Filter implements ScopePhase.Colle static class ChildrenDocSet extends GetDocSet { final IdReaderTypeCache currentTypeCache; - final IndexReader currentReader; - final Tuple[] readersToTypeCache; + final AtomicReader currentReader; + final Tuple[] readersToTypeCache; final Map parentDocs; + final Bits acceptDocs; - ChildrenDocSet(IndexReader currentReader, Map parentDocs, - SearchContext context, String parentType) { + ChildrenDocSet(AtomicReader currentReader, Map parentDocs, + SearchContext context, String parentType, Bits acceptDocs) { super(currentReader.maxDoc()); + this.acceptDocs = acceptDocs; this.currentTypeCache = context.idCache().reader(currentReader).type(parentType); this.currentReader = currentReader; this.parentDocs = parentDocs; - this.readersToTypeCache = new Tuple[context.searcher().subReaders().length]; + this.readersToTypeCache = new Tuple[context.searcher().getIndexReader().leaves().size()]; for (int i = 0; i < readersToTypeCache.length; i++) { - IndexReader reader = context.searcher().subReaders()[i]; - readersToTypeCache[i] = new Tuple(reader, context.idCache().reader(reader).type(parentType)); + AtomicReader reader = context.searcher().getIndexReader().leaves().get(i).reader(); + readersToTypeCache[i] = new Tuple(reader, context.idCache().reader(reader).type(parentType)); } } public boolean get(int doc) { - if (currentReader.isDeleted(doc) || doc == -1) { + if (acceptDocs.get(doc) || doc == -1) { return false; } @@ -230,7 +238,7 @@ public abstract class HasParentFilter extends Filter implements ScopePhase.Colle return false; } - for (Tuple readerTypeCacheTuple : readersToTypeCache) { + for (Tuple readerTypeCacheTuple : readersToTypeCache) { int parentDocId = readerTypeCacheTuple.v2().docById(parentId); if (parentDocId == -1) { continue; @@ -254,8 +262,9 @@ public abstract class HasParentFilter extends Filter implements ScopePhase.Colle current.set(doc); } - public void setNextReader(IndexReader reader, int docBase) throws IOException { - segmentResults.put(reader.getCoreCacheKey(), current = new FixedBitSet(reader.maxDoc())); + @Override + public void setNextReader(AtomicReaderContext context) throws IOException { + segmentResults.put(context.reader().getCoreCacheKey(), current = new FixedBitSet(context.reader().maxDoc())); } } } diff --git a/src/main/java/org/elasticsearch/index/search/child/TopChildrenQuery.java b/src/main/java/org/elasticsearch/index/search/child/TopChildrenQuery.java index 47a10f42d3e..7fe64c8a4bb 100644 --- a/src/main/java/org/elasticsearch/index/search/child/TopChildrenQuery.java +++ b/src/main/java/org/elasticsearch/index/search/child/TopChildrenQuery.java @@ -20,9 +20,9 @@ package org.elasticsearch.index.search.child; import gnu.trove.map.hash.TIntObjectHashMap; -import org.apache.lucene.index.IndexReader; -import org.apache.lucene.index.Term; +import org.apache.lucene.index.*; import org.apache.lucene.search.*; +import org.apache.lucene.util.Bits; import org.apache.lucene.util.ToStringUtils; import org.elasticsearch.ElasticSearchIllegalArgumentException; import org.elasticsearch.ElasticSearchIllegalStateException; @@ -124,20 +124,21 @@ public class TopChildrenQuery extends Query implements ScopePhase.TopDocsPhase { public void processResults(TopDocs topDocs, SearchContext context) { Map> parentDocsPerReader = new HashMap>(); for (ScoreDoc scoreDoc : topDocs.scoreDocs) { - int readerIndex = context.searcher().readerIndex(scoreDoc.doc); - IndexReader subReader = context.searcher().subReaders()[readerIndex]; - int subDoc = scoreDoc.doc - context.searcher().docStarts()[readerIndex]; + int readerIndex = ReaderUtil.subIndex(scoreDoc.doc, context.searcher().getIndexReader().leaves()); + AtomicReaderContext subContext = context.searcher().getIndexReader().leaves().get(readerIndex); + int subDoc = scoreDoc.doc - subContext.docBase; // find the parent id - HashedBytesArray parentId = context.idCache().reader(subReader).parentIdByDoc(parentType, subDoc); + HashedBytesArray parentId = context.idCache().reader(subContext.reader()).parentIdByDoc(parentType, subDoc); if (parentId == null) { // no parent found continue; } // now go over and find the parent doc Id and reader tuple - for (IndexReader indexReader : context.searcher().subReaders()) { + for (AtomicReaderContext atomicReaderContext : context.searcher().getIndexReader().leaves()) { + AtomicReader indexReader = atomicReaderContext.reader(); int parentDocId = context.idCache().reader(indexReader).docById(parentType, parentId); - if (parentDocId != -1 && !indexReader.isDeleted(parentDocId)) { + if (parentDocId != -1 && !indexReader.getLiveDocs().get(parentDocId)) { // we found a match, add it and break TIntObjectHashMap readerParentDocs = parentDocsPerReader.get(indexReader.getCoreCacheKey()); @@ -205,15 +206,15 @@ public class TopChildrenQuery extends Query implements ScopePhase.TopDocsPhase { } @Override - public Weight createWeight(Searcher searcher) throws IOException { + public Weight createWeight(IndexSearcher searcher) throws IOException { if (!properlyInvoked) { throw new ElasticSearchIllegalStateException("top_children query hasn't executed properly"); } if (parentDocs != null) { - return new ParentWeight(searcher, query.weight(searcher)); + return new ParentWeight(searcher, query.createWeight(searcher)); } - return query.weight(searcher); + return query.createWeight(searcher); } public String toString(String field) { @@ -225,11 +226,11 @@ public class TopChildrenQuery extends Query implements ScopePhase.TopDocsPhase { class ParentWeight extends Weight { - final Searcher searcher; + final IndexSearcher searcher; final Weight queryWeight; - public ParentWeight(Searcher searcher, Weight queryWeight) throws IOException { + public ParentWeight(IndexSearcher searcher, Weight queryWeight) throws IOException { this.searcher = searcher; this.queryWeight = queryWeight; } @@ -243,28 +244,28 @@ public class TopChildrenQuery extends Query implements ScopePhase.TopDocsPhase { } @Override - public float sumOfSquaredWeights() throws IOException { - float sum = queryWeight.sumOfSquaredWeights(); + public float getValueForNormalization() throws IOException { + float sum = queryWeight.getValueForNormalization(); sum *= getBoost() * getBoost(); return sum; } @Override - public void normalize(float norm) { - // nothing to do here.... + public void normalize(float norm, float topLevelBoost) { + // Nothing to normalize } @Override - public Scorer scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer) throws IOException { - ParentDoc[] readerParentDocs = parentDocs.get(reader.getCoreCacheKey()); + public Scorer scorer(AtomicReaderContext context, boolean scoreDocsInOrder, boolean topScorer, Bits acceptDocs) throws IOException { + ParentDoc[] readerParentDocs = parentDocs.get(context.reader().getCoreCacheKey()); if (readerParentDocs != null) { - return new ParentScorer(getSimilarity(searcher), readerParentDocs); + return new ParentScorer(this, readerParentDocs); } - return new EmptyScorer(getSimilarity(searcher)); + return new EmptyScorer(this); } @Override - public Explanation explain(IndexReader reader, int doc) throws IOException { + public Explanation explain(AtomicReaderContext context, int doc) throws IOException { return new Explanation(getBoost(), "not implemented yet..."); } } @@ -275,8 +276,8 @@ public class TopChildrenQuery extends Query implements ScopePhase.TopDocsPhase { private int index = -1; - private ParentScorer(Similarity similarity, ParentDoc[] docs) throws IOException { - super(similarity); + private ParentScorer(ParentWeight weight, ParentDoc[] docs) throws IOException { + super(weight); this.docs = docs; } @@ -315,5 +316,10 @@ public class TopChildrenQuery extends Query implements ScopePhase.TopDocsPhase { } throw new ElasticSearchIllegalStateException("No support for score type [" + scoreType + "]"); } + + @Override + public float freq() throws IOException { + return docs[index].count; // The number of matches in the child doc, which is propagated to parent + } } }