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; }