public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = _facetFilter.GetFacetSelectivity(reader);
if (_takeComplement)
return 1.0 - selectivity;
return selectivity;
}
public void Init()
{
facetHandlers = new List <IFacetHandler>();
directory = new RAMDirectory();
analyzer = new WhitespaceAnalyzer();
selectionProperties = new Dictionary <string, string>();
IndexWriter writer = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED);
writer.AddDocument(Doc("prop1=val1", "prop2=val1", "prop5=val1"));
writer.AddDocument(Doc("prop1=val2", "prop3=val1", "prop7=val7"));
writer.AddDocument(Doc("prop1=val2", "prop3=val2", "prop3=val3"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1", "prop4=val2", "prop4=val3"));
writer.Commit();
attributesFacetHandler = new AttributesFacetHandler(AttributeHandlerName, AttributeHandlerName, null, null,
new Dictionary <string, string>());
facetHandlers.Add(attributesFacetHandler);
IndexReader reader = IndexReader.Open(directory, true);
boboReader = BoboIndexReader.GetInstance(reader, facetHandlers);
attributesFacetHandler.LoadFacetData(boboReader);
browser = new BoboBrowser(boboReader);
}
public override int GetNumItems(BoboIndexReader reader, int id)
{
var dependOnFacetHandler = GetDependedFacetHandler(_dependsOnFacetName);
FacetDataCache data = dependOnFacetHandler.GetFacetData <FacetDataCache>(reader);
return(data.GetNumItems(id));
}
public override FacetDataCache Load(BoboIndexReader reader)
{
FacetDataCache dataCache = new FacetDataCache();
dataCache.Load(_indexFieldName, reader, _termListFactory);
return(dataCache);
}
public void Init()
{
facetHandlers = new List<IFacetHandler>();
directory = new RAMDirectory();
analyzer = new WhitespaceAnalyzer();
selectionProperties = new Dictionary<string, string>();
IndexWriter writer = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED);
writer.AddDocument(Doc("prop1=val1", "prop2=val1", "prop5=val1"));
writer.AddDocument(Doc("prop1=val2", "prop3=val1", "prop7=val7"));
writer.AddDocument(Doc("prop1=val2", "prop3=val2", "prop3=val3"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1", "prop4=val2", "prop4=val3"));
writer.Commit();
attributesFacetHandler = new AttributesFacetHandler(AttributeHandlerName, AttributeHandlerName, null, null,
new Dictionary<string, string>());
facetHandlers.Add(attributesFacetHandler);
IndexReader reader = IndexReader.Open(directory, true);
boboReader = BoboIndexReader.GetInstance(reader, facetHandlers);
attributesFacetHandler.LoadFacetData(boboReader);
browser = new BoboBrowser(boboReader);
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
FacetDataCache dataCache = _facetHandler.GetFacetData <FacetDataCache>(reader);
bool multi = dataCache is MultiValueFacetDataCache;
BigNestedIntArray nestedArray = multi ? ((MultiValueFacetDataCache)dataCache).NestedArray : null;
int[] range = Parse(dataCache, _rangeString);
if (range == null)
{
return(null);
}
if (range[0] > range[1])
{
return(EmptyDocIdSet.Instance);
}
if (range[0] == range[1] && range[0] < 0)
{
return(EmptyDocIdSet.Instance);
}
int start = range[0];
int end = range[1];
return(new RangeRandomAccessDocIdSet(start, end, dataCache, nestedArray, multi));
}
public override IFacetCountCollector GetFacetCountCollector(BoboIndexReader reader, int docBase)
{
MultiValueFacetDataCache dataCache = parent.GetFacetData <MultiValueFacetDataCache>(reader);
BigNestedIntArray _nestedArray = dataCache.NestedArray;
return(new MultiRangeFacetCountCollector(parent.Name, dataCache, docBase, this.ospec, parent._predefinedRanges, _nestedArray));
}
public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = 0;
FacetDataCache dataCache = _facetHandler.GetFacetData<FacetDataCache>(reader);
int accumFreq = 0;
foreach (string val in _vals)
{
int idx = dataCache.ValArray.IndexOf(val);
if (idx < 0)
{
continue;
}
accumFreq += dataCache.Freqs[idx];
}
int total = reader.MaxDoc;
selectivity = (double)accumFreq / (double)total;
if (selectivity > 0.999)
{
selectivity = 1.0;
}
if (_takeCompliment)
{
selectivity = 1.0 - selectivity;
}
return selectivity;
}
private void ModifiedSetup()
{
directory = new RAMDirectory();
analyzer = new WhitespaceAnalyzer();
IndexWriter writer = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED);
writer.AddDocument(Doc("prop1=val1", "prop2=val1", "prop5=val1"));
writer.AddDocument(Doc("prop1=val2", "prop3=val1", "prop7=val7"));
writer.AddDocument(Doc("prop1=val2", "prop3=val2", "prop3=val3"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1"));
writer.AddDocument(Doc("prop1=val1", "prop2=val1", "prop4=val2", "prop4=val3"));
writer.Commit();
IDictionary <string, string> facetProps = new Dictionary <string, string>();
facetProps.Put(AttributesFacetHandler.MAX_FACETS_PER_KEY_PROP_NAME, "1");
attributesFacetHandler = new AttributesFacetHandler(AttributeHandlerName, AttributeHandlerName, null, null,
facetProps);
facetHandlers.Add(attributesFacetHandler);
IndexReader reader = IndexReader.Open(directory, true);
boboReader = BoboIndexReader.GetInstance(reader, facetHandlers);
attributesFacetHandler.LoadFacetData(boboReader);
browser = new BoboBrowser(boboReader);
}
public override BoboDocScorer GetDocScorer(BoboIndexReader reader, IFacetTermScoringFunctionFactory scoringFunctionFactory,
IDictionary <string, float> boostMap)
{
MultiValueFacetDataCache dataCache = GetFacetData <MultiValueFacetDataCache>(reader);
float[] boostList = BoboDocScorer.BuildBoostList(dataCache.ValArray, boostMap);
return(new MultiValueFacetHandler.MultiValueDocScorer(dataCache, scoringFunctionFactory, boostList));
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
int maxDoc = reader.MaxDoc;
GeoFacetHandler.GeoFacetData dataCache = _handler.GetFacetData<GeoFacetHandler.GeoFacetData>(reader);
return new GeoDocIdSet(dataCache.xValArray, dataCache.yValArray, dataCache.zValArray,
_lat, _lon, _rad, maxDoc, _miles);
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
int maxDoc = reader.MaxDoc;
GeoFacetHandler.GeoFacetData dataCache = _handler.GetFacetData <GeoFacetHandler.GeoFacetData>(reader);
return(new GeoDocIdSet(dataCache.xValArray, dataCache.yValArray, dataCache.zValArray,
_lat, _lon, _rad, maxDoc, _miles));
}
public BoboSubBrowser(BoboIndexReader reader)
: base(reader)
{
_reader = reader;
_runtimeFacetHandlerMap = new Dictionary<string, IFacetHandler>();
_runtimeFacetHandlerFactoryMap = reader.RuntimeFacetHandlerFactoryMap;
_allFacetHandlerMap = null;
}
public virtual BoboDocScorer GetDocScorer(BoboIndexReader reader,
IFacetTermScoringFunctionFactory scoringFunctionFactory,
IDictionary <string, float> boostMap)
{
FacetDataCache dataCache = GetFacetData <FacetDataCache>(reader);
float[] boostList = BoboDocScorer.BuildBoostList(dataCache.ValArray, boostMap);
return(new RangeBoboDocScorer(dataCache, scoringFunctionFactory, boostList));
}
public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = _facetFilter.GetFacetSelectivity(reader);
if (_takeComplement)
{
return(1.0 - selectivity);
}
return(selectivity);
}
public override object[] GetRawFieldValues(BoboIndexReader reader, int id)
{
FacetDataCache dataCache = GetFacetData <FacetDataCache>(reader);
if (dataCache != null)
{
return(new object[] { dataCache.ValArray.GetRawValue(dataCache.OrderArray.Get(id)) });
}
return(new string[0]);
}
public static IBrowseService CreateBrowseService(Directory idxDir) // throws BrowseException
{
BoboIndexReader bReader = GetBoboIndexReader(idxDir);
DefaultBrowseServiceImpl bs = (DefaultBrowseServiceImpl)CreateBrowseService(bReader);
bs.CloseReaderOnCleanup = true;
return(bs);
}
public override object[] GetRawFieldValues(BoboIndexReader reader, int id)
{
MultiValueFacetDataCache dataCache = GetFacetData <MultiValueFacetDataCache>(reader);
if (dataCache != null)
{
return(dataCache.NestedArray.GetRawData(id, dataCache.ValArray));
}
return(new string[0]);
}
public override int GetNumItems(BoboIndexReader reader, int id)
{
MultiValueFacetDataCache data = GetFacetData <MultiValueFacetDataCache>(reader);
if (data == null)
{
return(0);
}
return(data.GetNumItems(id));
}
public override IFacetCountCollector GetFacetCountCollector(BoboIndexReader reader, int docBase)
{
var collectorList = new List <DefaultFacetCountCollector>(_facetHandlers.Count());
foreach (var facetHandler in _facetHandlers)
{
collectorList.Add((DefaultFacetCountCollector)facetHandler.GetFacetCountCollectorSource(_sel, _fspec).GetFacetCountCollector(reader, docBase));
}
return(new GroupbyFacetCountCollector(_name, _fspec, collectorList.ToArray(), reader.MaxDoc, _sep));
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
if (_vals.Length == 0)
{
return EmptyDocIdSet.Instance;
}
else
{
return new FacetOrRandomAccessDocIdSet(_facetHandler, reader, _vals, _valueConverter, _takeCompliment);
}
}
public override DocComparator GetComparator(IndexReader reader, int docbase)
{
if (!reader.GetType().Equals(typeof(BoboIndexReader)))
{
throw new ArgumentException("reader must be instance of BoboIndexReader");
}
BoboIndexReader boboReader = (BoboIndexReader)reader;
MultiValueFacetDataCache dataCache = (MultiValueFacetDataCache)cacheBuilder.Build(boboReader);
return(new MultiFacetDocComparator(dataCache));
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
if (_vals.Length == 0)
{
return(EmptyDocIdSet.Instance);
}
else
{
return(new FacetOrRandomAccessDocIdSet(_facetHandler, reader, _vals, _valueConverter, _takeCompliment));
}
}
public override IFacetCountCollector GetFacetCountCollector(BoboIndexReader reader, int docBase)
{
int facetsPerKey = _parent.GetFacetsPerKey(_browseSelection);
if (_ospec.Properties != null && _ospec.Properties.ContainsKey(MAX_FACETS_PER_KEY_PROP_NAME))
{
facetsPerKey = int.Parse(_ospec.Properties.Get(MAX_FACETS_PER_KEY_PROP_NAME));
}
MultiValueFacetDataCache dataCache = (MultiValueFacetDataCache)reader.GetFacetData(_parent.Name);
return(new AttributesFacetCountCollector(_parent, _parent.Name, dataCache, docBase, _browseSelection, _ospec, facetsPerKey, _parent.GetSeparator(_browseSelection)));
}
public BrowseServiceImpl(DirectoryInfo idxDir)
{
this.idxDir = idxDir;
try
{
reader = NewIndexReader();
}
catch (IOException e)
{
logger.Error(e.Message, e);
}
}
public override void Load(BoboIndexReader reader)
{
FacetHandler handler = reader.GetFacetHandler(_inner);
if (handler is RangeFacetHandler)
{
_innerHandler = (RangeFacetHandler)handler;
}
else
{
throw new IOException("inner handler is not instance of "+typeof(RangeFacetHandler));
}
}
public IEnumerable<IFacetHandler> LoadFacetHandlers(string springConfigFile, BoboIndexReader.WorkArea workArea)
{
if (File.Exists(springConfigFile))
{
XmlApplicationContext appCtx = new XmlApplicationContext(springConfigFile);
return appCtx.GetObjectsOfType(typeof(IFacetHandler)).Values.OfType<IFacetHandler>().ToList();
}
else
{
return new List<IFacetHandler>();
}
}
public override int GetNumItems(BoboIndexReader reader, int id)
{
FacetDataCache dataCache = GetFacetData <FacetDataCache>(reader);
if (dataCache == null)
{
return(0);
}
int encoded = dataCache.OrderArray.Get(id);
return(CountBits(encoded));
}
public override FacetDataNone Load(BoboIndexReader reader)
{
_dataFacetHandler = reader.GetFacetHandler(_dataHandlerName);
if (_dataFacetHandler is RangeFacetHandler)
{
if (((RangeFacetHandler)_dataFacetHandler).HasPredefinedRanges)
{
throw new NotSupportedException("underlying range facet handler should not have the predefined ranges");
}
}
return(FacetDataNone.Instance);
}
public override DocComparator GetComparator(IndexReader reader, int docbase)
{
if (!(reader.GetType().Equals(typeof(BoboIndexReader))))
{
throw new ArgumentException("reader not instance of BoboIndexReader");
}
BoboIndexReader boboReader = (BoboIndexReader)reader;
FacetDataCache dataCache = _facetHandler.GetFacetData <FacetDataCache>(boboReader);
BigSegmentedArray orderArray = dataCache.OrderArray;
return(new FacetDocComparator(dataCache, orderArray));
}
public BrowseServiceImpl(DirectoryInfo idxDir)
{
this._idxDir = idxDir;
try
{
_reader = NewIndexReader();
}
catch (IOException e)
{
logger.Error(e.Message, e);
}
}
public override IFacetCountCollector GetFacetCountCollector(BoboIndexReader reader, int docBase)
{
FacetDataCache dataCache = _parent.GetFacetData <FacetDataCache>(reader);
if (_multiValue)
{
return(new MultiValuedPathFacetCountCollector(_name, _separator, _sel, _ospec, dataCache));
}
else
{
return(new PathFacetCountCollector(_name, _separator, _sel, _ospec, dataCache));
}
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
MultiValueFacetDataCache dataCache = (MultiValueFacetDataCache)multiDataCacheBuilder.Build(reader);
int index = dataCache.ValArray.IndexOf(_val);
if (index < 0)
{
return EmptyDocIdSet.Instance;
}
else
{
return new MultiValueRandomAccessDocIdSet(dataCache, index);
}
}
public override IFacetCountCollector GetFacetCountCollector(BoboIndexReader reader, int docBase)
{
IFacetCountCollector defaultCollector = _dependOnFacetHandler.GetFacetCountCollectorSource(_sel, _ospec).GetFacetCountCollector(reader, docBase);
if (defaultCollector is DefaultFacetCountCollector)
{
return(new BucketFacetCountCollector(_name, (DefaultFacetCountCollector)defaultCollector, _ospec, _predefinedBuckets, reader.NumDocs()));
}
else
{
throw new InvalidOperationException("dependent facet handler must build DefaultFacetCountCollector");
}
}
public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = 0;
FacetDataCache dataCache = multiDataCacheBuilder.Build(reader);
int idx = dataCache.ValArray.IndexOf(_val);
if (idx < 0)
{
return 0.0;
}
int freq = dataCache.Freqs[idx];
int total = reader.MaxDoc;
selectivity = (double)freq / (double)total;
return selectivity;
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
MultiValueFacetDataCache dataCache = (MultiValueFacetDataCache)multiDataCacheBuilder.Build(reader);
int index = dataCache.ValArray.IndexOf(_val);
if (index < 0)
{
return(EmptyDocIdSet.Instance);
}
else
{
return(new MultiValueRandomAccessDocIdSet(dataCache, index));
}
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
FacetDataCache latDataCache = _latFacetHandler.GetFacetData <FacetDataCache>(reader);
FacetDataCache longDataCache = _longFacetHandler.GetFacetData <FacetDataCache>(reader);
int[] latRange = FacetRangeFilter.Parse(latDataCache, _latRangeString);
int[] longRange = FacetRangeFilter.Parse(longDataCache, _longRangeString);
if ((latRange == null) || (longRange == null))
{
return(null);
}
return(new GeoSimpleRandomAccessDocIdSet(latRange, longRange, latDataCache, longDataCache));
}
public InternalBrowseHitCollector(BoboBrowser boboBrowser, SortField[] sort, int offset, int count, bool fetchStoredFields)
{
this.boboBrowser = boboBrowser;
reader = boboBrowser.GetIndexReader();
sortFields = QueryUtils.convertSort(sort, reader);
this.offset = offset;
this.count = count;
this.numHits = offset + count;
hitQueue = new SortedHitQueue(this.boboBrowser, sortFields, offset + count);
totalHits = 0;
this.fetchStoredFields = fetchStoredFields;
this.reverseMul = (from s in sortFields select s.Reverse ? -1 : 1).ToArray();
}
public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = 0;
foreach (RandomAccessFilter filter in _filters)
{
selectivity += filter.GetFacetSelectivity(reader);
}
if(selectivity > 0.999)
{
selectivity = 1.0;
}
return selectivity;
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
FacetDataCache dataCache = _facetHandler.GetFacetData <FacetDataCache>(reader);
int index = dataCache.ValArray.IndexOf(_value);
if (index < 0)
{
return(EmptyDocIdSet.Instance);
}
else
{
return(new FacetDataRandomAccessDocIdSet(dataCache, index));
}
}
public override FacetDataNone Load(BoboIndexReader reader)
{
IFacetHandler handler = reader.GetFacetHandler(_inner);
if (handler is RangeFacetHandler)
{
_innerHandler = (RangeFacetHandler)handler;
return(FacetDataNone.Instance);
}
else
{
throw new IOException("inner handler is not instance of RangeFacetHandler");
}
}
public override void SetNextReader(IndexReader reader, int docBase)
{
if (!(reader is BoboIndexReader))
{
throw new ArgumentException("reader must be a BoboIndexReader");
}
_currentReader = (BoboIndexReader)reader;
_currentComparator = _compSource.GetComparator(reader, docBase);
_currentQueue = new DocIDPriorityQueue(_currentComparator, _numHits, docBase);
if (groupBy != null)
{
if (_facetCountCollectorMulti != null) // _facetCountCollectorMulti.Length >= 1
{
for (int i = 0; i < _facetCountCollectorMulti.Length; ++i)
{
_facetCountCollectorMulti[i] = groupByMulti[i].GetFacetCountCollectorSource(null, null, true).GetFacetCountCollector(_currentReader, docBase);
}
//if (_facetCountCollector != null)
// collectTotalGroups();
_facetCountCollector = _facetCountCollectorMulti[0];
if (_facetAccessibleLists != null)
{
for (int i = 0; i < _facetCountCollectorMulti.Length; ++i)
{
_facetAccessibleLists[i].Add(_facetCountCollectorMulti[i]);
}
}
}
if (_currentValueDocMaps != null)
{
_currentValueDocMaps.Clear();
}
// NightOwl888: The _collectDocIdCache setting seems to put arrays into
// memory, but then do nothing with the arrays. Seems wasteful and unnecessary.
//if (contextList != null)
//{
// _currentContext = new CollectorContext(_currentReader, docBase, _currentComparator);
// contextList.Add(_currentContext);
//}
}
MyScoreDoc myScoreDoc = (MyScoreDoc)_tmpScoreDoc;
myScoreDoc.queue = _currentQueue;
myScoreDoc.reader = _currentReader;
myScoreDoc.sortValue = null;
_pqList.Add(_currentQueue);
_queueFull = false;
}
public void TestNotValuesForSimpleFacetHandler()
{
BrowseRequest br = new BrowseRequest();
br.Count = 20;
br.Offset = 0;
BrowseSelection colorSel = new BrowseSelection("color");
colorSel.AddValue("red");
br.AddSelection(colorSel);
BrowseSelection idSel = new BrowseSelection("id");
idSel.AddNotValue("0");
br.AddSelection(idSel);
BrowseResult result = null;
BoboBrowser boboBrowser = null;
int expectedHitNum = (_documentSize / 2) - 1;
using (Directory ramIndexDir = CreateIndex())
{
using (IndexReader srcReader = IndexReader.Open(ramIndexDir, true))
{
using (boboBrowser = new BoboBrowser(BoboIndexReader.GetInstance(srcReader, _facetHandlers, null)))
{
result = boboBrowser.Browse(br);
Assert.AreEqual(expectedHitNum, result.NumHits);
StringBuilder buffer = new StringBuilder();
BrowseHit[] hits = result.Hits;
for (int i = 0; i < hits.Length; ++i)
{
int expectedID = (i + 1) * 2;
Assert.AreEqual(expectedID, int.Parse(hits[i].GetField("id")));
if (i != 0)
{
buffer.Append('\n');
}
buffer.Append("id=" + hits[i].GetField("id") + "," + "color=" + hits[i].GetField("color"));
}
log.Info(buffer.ToString());
}
}
}
}
public static void GatherSubReaders(IList<BoboIndexReader> readerList, BoboIndexReader reader)
{
BoboIndexReader[] subReaders = reader.SubReaders;
if (subReaders == null)
{
readerList.Add(reader);
}
else
{
for (int i = 0; i < subReaders.Length; i++)
{
GatherSubReaders(readerList, subReaders[i]);
}
}
}
public virtual void Start()
{
IndexReader reader = IndexReader.Open(FSDirectory.Open(_idxDir), true);
try
{
_boboReader = BoboIndexReader.GetInstance(reader);
}
catch
{
if (reader != null)
{
reader.Dispose();
}
}
}
public override MultiValueFacetDataCache Load(BoboIndexReader reader, BoboIndexReader.WorkArea workArea)
{
MultiValueWithWeightFacetDataCache dataCache = new MultiValueWithWeightFacetDataCache();
dataCache.MaxItems = _maxItems;
if (_sizePayloadTerm == null)
{
dataCache.Load(_indexFieldName, reader, _termListFactory, workArea);
}
else
{
dataCache.Load(_indexFieldName, reader, _termListFactory, _sizePayloadTerm);
}
return dataCache;
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
FacetDataCache dataCache = facetDataCacheBuilder.Build(reader);
OpenBitSet openBitSet = GetBitSet(dataCache);
long count = openBitSet.Cardinality();
if (count == 0)
{
return EmptyDocIdSet.Instance;
}
else
{
bool multi = dataCache is MultiValueFacetDataCache;
MultiValueFacetDataCache multiCache = multi ? (MultiValueFacetDataCache)dataCache : null;
return new BitSetRandomAccessDocIdSet(multi, multiCache, openBitSet, dataCache);
}
}
public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = double.MaxValue;
foreach (RandomAccessFilter filter in _filters)
{
double curSelectivity = filter.GetFacetSelectivity(reader);
if(selectivity > curSelectivity)
{
selectivity = curSelectivity;
}
}
if (selectivity > 0.999)
{
selectivity = 1.0;
}
return selectivity;
}
public FacetBasedBoostingScorer(FacetBasedBoostScorerBuilder parent, BoboIndexReader reader, Similarity similarity, Scorer innerScorer)
: base(similarity)
{
_innerScorer = innerScorer;
List<BoboDocScorer> list = new List<BoboDocScorer>();
foreach (var boostEntry in parent._boostMaps)
{
string facetName = boostEntry.Key;
IFacetHandler handler = reader.GetFacetHandler(facetName);
if (!(handler is IFacetScoreable))
throw new ArgumentException(facetName + " does not implement FacetScoreable");
IFacetScoreable facetScoreable = (IFacetScoreable)handler;
BoboDocScorer scorer = facetScoreable.GetDocScorer(reader, parent._scoringFunctionFactory, boostEntry.Value);
if (scorer != null) list.Add(scorer);
}
_facetScorers = list.ToArray();
_docid = -1;
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
RandomAccessDocIdSet innerDocSet = _facetFilter.GetRandomAccessDocIdSet(reader);
if (innerDocSet == EmptyDocIdSet.Instance)
{
return innerDocSet;
}
FacetDataCache dataCache = _facetDataCacheBuilder.Build(reader);
int totalCount = reader.MaxDoc;
ITermValueList valArray = dataCache.ValArray;
int freqCount = 0;
var validVals = new List<string>(_valSet.Count());
foreach (string val in _valSet)
{
int idx = valArray.IndexOf(val);
if (idx >= 0)
{
validVals.Add(valArray.Get(idx)); // get and format the value
freqCount += dataCache.Freqs[idx];
}
}
if (validVals.Count == 0)
{
return EmptyDocIdSet.Instance;
}
// takeComplement is only used to choose between TermListRandomAccessDocIdSet and innerDocSet
int validFreqCount = _takeComplement ? (totalCount - freqCount) : freqCount;
if (_facetDataCacheBuilder.IndexFieldName != null && ((validFreqCount << 1) < totalCount))
{
return new TermListRandomAccessDocIdSet(_facetDataCacheBuilder.IndexFieldName, innerDocSet, validVals, reader);
}
else
{
return innerDocSet;
}
}
public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = 0;
FacetDataCache dataCache = _facetHandler.GetFacetData<FacetDataCache>(reader);
int[] range = Parse(dataCache, _rangeString);
if (range != null)
{
int accumFreq = 0;
for (int idx = range[0]; idx <= range[1]; ++idx)
{
accumFreq += dataCache.Freqs[idx];
}
int total = reader.MaxDoc;
selectivity = (double)accumFreq / (double)total;
}
if (selectivity > 0.999)
{
selectivity = 1.0;
}
return selectivity;
}
public virtual void Close() // throws BrowseException
{
if (_closeReader)
{
lock (this)
{
if (_reader != null)
{
try
{
_reader.Dispose();
_reader = null;
}
catch (IOException ioe)
{
throw new BrowseException(ioe.Message, ioe);
}
}
}
}
}
public override double GetFacetSelectivity(BoboIndexReader reader)
{
double selectivity = 0;
MultiValueFacetDataCache dataCache = _facetHandler.GetFacetData<MultiValueFacetDataCache>(reader);
int[] idxes = _valueConverter.Convert(dataCache, _vals);
if (idxes == null)
{
return 0.0;
}
int accumFreq = 0;
foreach (int idx in idxes)
{
accumFreq += dataCache.Freqs[idx];
}
int total = reader.MaxDoc;
selectivity = (double)accumFreq / (double)total;
if (selectivity > 0.999)
{
selectivity = 1.0;
}
return selectivity;
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
var count = _filters.Count();
if (count == 1)
{
return _filters.ElementAt(0).GetRandomAccessDocIdSet(reader);
}
else
{
List<DocIdSet> list = new List<DocIdSet>(count);
List<RandomAccessDocIdSet> randomAccessList = new List<RandomAccessDocIdSet>(count);
foreach (RandomAccessFilter f in _filters)
{
RandomAccessDocIdSet s = f.GetRandomAccessDocIdSet(reader);
list.Add(s);
randomAccessList.Add(s);
}
RandomAccessDocIdSet[] randomAccessDocIdSets = randomAccessList.ToArray();
DocIdSet andDocIdSet = new AndDocIdSet(list);
return new RandomAccessAndFilterSet(randomAccessDocIdSets, andDocIdSet);
}
}
public void SetNextReader(BoboIndexReader reader, int docBase)
{
if (_collectAllSource != null)
{
IFacetCountCollector collector = _collectAllSource.GetFacetCountCollector(reader, docBase);
_collectAllCollectorList.Add(collector);
collector.CollectAll();
}
else
{
if (_filter != null)
{
_currentPointers.DocIdSet = _filter.GetRandomAccessDocIdSet(reader);
_currentPointers.PostDocIDSetIterator = _currentPointers.DocIdSet.Iterator();
_currentPointers.Doc = _currentPointers.PostDocIDSetIterator.NextDoc();
}
if (_facetCountCollectorSource != null)
{
_currentPointers.FacetCountCollector = _facetCountCollectorSource.GetFacetCountCollector(reader, docBase);
_countCollectorList.Add(_currentPointers.FacetCountCollector);
}
}
}
public static BoboIndexReader NewIndexReader(Directory idxDir)
{
if (!IndexReader.IndexExists(idxDir))
{
return null;
}
long start = System.Environment.TickCount;
IndexReader ir = IndexReader.Open(idxDir, true);
BoboIndexReader reader;
try
{
reader = BoboIndexReader.GetInstance(ir);
}
catch (IOException ioe)
{
try
{
ir.Dispose();
}
catch
{
}
throw ioe;
}
long end = System.Environment.TickCount;
if (logger.IsDebugEnabled)
{
logger.Debug("New index loading took: " + (end - start));
}
return reader;
}
public static SortField[] convertSort(SortField[] sortSpec, BoboIndexReader idxReader)
{
SortField[] retVal = DEFAULT_SORT;
if (sortSpec != null && sortSpec.Length > 0)
{
List<SortField> sortList = new List<SortField>(sortSpec.Length + 1);
bool relevanceSortAdded = false;
for (int i = 0; i < sortSpec.Length; ++i)
{
if (SortField.FIELD_DOC.Equals(sortSpec[i]))
{
sortList.Add(SortField.FIELD_DOC);
}
else if (SortField.FIELD_SCORE.Equals(sortSpec[i]))
{
sortList.Add(SortField.FIELD_SCORE);
relevanceSortAdded = true;
}
else
{
string fieldname = sortSpec[i].Field;
if (fieldname != null)
{
SortField sf = sortSpec[i];
sortList.Add(sf);
}
}
}
if (!relevanceSortAdded)
{
sortList.Add(SortField.FIELD_SCORE);
}
retVal = sortList.ToArray();
}
return retVal;
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (_closeReader)
{
lock (this)
{
if (_reader != null)
{
try
{
_reader.Dispose();
_reader = null;
}
catch (Exception ioe)
{
throw new BrowseException(ioe.Message, ioe);
}
}
}
}
}
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
MultiValueFacetDataCache dataCache = _facetHandler.GetFacetData<MultiValueFacetDataCache>(reader);
int[] index = _valueConverter.Convert(dataCache, _vals);
//BigNestedIntArray nestedArray = dataCache.NestedArray;
OpenBitSet bitset = new OpenBitSet(dataCache.ValArray.Count);
foreach (int i in index)
{
bitset.FastSet(i);
}
if (_takeCompliment)
{
// flip the bits
int size = dataCache.ValArray.Count;
for (int i = 0; i < size; ++i)
{
bitset.FastFlip(i);
}
}
long count = bitset.Cardinality();
if (count == 0)
{
return new EmptyRandomAccessDocIdSet();
}
else
{
return new MultiRandomAccessDocIdSet(dataCache, bitset);
}
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboIndexReader reader)
{
return EmptyDocIdSet.Instance;
}
