public BitSetRandomAccessDocIdSet(bool multi, MultiValueFacetDataCache multiCache, OpenBitSet openBitSet, FacetDataCache dataCache)
{
m_multi = multi;
m_multiCache = multiCache;
m_openBitSet = openBitSet;
m_dataCache = dataCache;
}
public override double GetFacetSelectivity(BoboSegmentReader reader)
{
double selectivity = 0;
MultiValueFacetDataCache dataCache = m_facetHandler.GetFacetData <MultiValueFacetDataCache>(reader);
int[] idxes = m_valueConverter.Convert(dataCache, m_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(BoboSegmentReader reader)
{
MultiValueFacetDataCache dataCache = m_facetHandler.GetFacetData <MultiValueFacetDataCache>(reader);
int[] index = m_valueConverter.Convert(dataCache, m_vals);
//BigNestedIntArray nestedArray = dataCache.NestedArray;
OpenBitSet bitset = new OpenBitSet(dataCache.ValArray.Count);
foreach (int i in index)
{
bitset.FastSet(i);
}
if (m_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 IFacetCountCollector GetFacetCountCollector(BoboSegmentReader reader, int docBase)
{
MultiValueFacetDataCache dataCache = m_parent.GetFacetData <MultiValueFacetDataCache>(reader);
BigNestedInt32Array _nestedArray = dataCache.NestedArray;
return(new MultiRangeFacetCountCollector(m_parent.Name, dataCache, docBase, this.m_ospec, m_parent.m_predefinedRanges, _nestedArray));
}
public override BoboDocScorer GetDocScorer(BoboSegmentReader 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 MultiValueFacetCountCollector(string name,
MultiValueFacetDataCache dataCache,
int docBase,
BrowseSelection sel,
FacetSpec ospec)
: base(name, dataCache, docBase, sel, ospec)
{
_array = dataCache.NestedArray;
}
public override object[] GetRawFieldValues(BoboSegmentReader reader, int id)
{
MultiValueFacetDataCache dataCache = GetFacetData <MultiValueFacetDataCache>(reader);
if (dataCache != null)
{
return(dataCache.NestedArray.GetRawData(id, dataCache.ValArray));
}
return(new string[0]);
}
public override string[] GetFieldValues(BoboIndexReader reader, int id)
{
MultiValueFacetDataCache dataCache = GetFacetData <MultiValueFacetDataCache>(reader);
if (dataCache != null)
{
return(dataCache.NestedArray.GetTranslatedData(id, dataCache.ValArray));
}
return(new string[0]);
}
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)));
}
internal MultiFacetRangeDocIdSetIterator(int start, int end, MultiValueFacetDataCache dataCache)
{
m_start = start;
m_end = end;
for (int i = start; i <= end; ++i)
{
m_minID = Math.Min(m_minID, dataCache.MinIDs[i]);
m_maxID = Math.Max(m_maxID, dataCache.MaxIDs[i]);
}
m_doc = Math.Max(-1, m_minID - 1);
m_nestedArray = dataCache.NestedArray;
}
public AttributesFacetCountCollector(AttributesFacetHandler attributesFacetHandler, string name, MultiValueFacetDataCache dataCache, int docBase, BrowseSelection browseSelection, FacetSpec ospec, int numFacetsPerKey, char separator)
: base(name, dataCache, docBase, browseSelection, ospec)
{
this.attributesFacetHandler = attributesFacetHandler;
this.dataCache = dataCache;
this.numFacetsPerKey = numFacetsPerKey;
this.separator = separator;
//_array = dataCache.NestedArray; // NOT USED
if (browseSelection != null)
{
values = browseSelection.Values;
}
}
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 FacetDataCache Load(BoboSegmentReader reader, BoboSegmentReader.WorkArea workArea)
{
MultiValueFacetDataCache dataCache = new MultiValueFacetDataCache();
dataCache.MaxItems = maxItems;
if (m_sizePayloadTerm == null)
{
dataCache.Load(m_indexFieldName, reader, m_termListFactory, workArea);
}
else
{
dataCache.Load(m_indexFieldName, reader, m_termListFactory, m_sizePayloadTerm);
}
return(dataCache);
}
public override FacetDataCache Load(BoboIndexReader reader)
{
if (!_multiValue)
{
FacetDataCache dataCache = new FacetDataCache();
dataCache.Load(_indexedName, reader, _termListFactory);
return(dataCache);
}
else
{
MultiValueFacetDataCache dataCache = new MultiValueFacetDataCache();
dataCache.Load(_indexedName, reader, _termListFactory);
return(dataCache);
}
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboSegmentReader reader)
{
FacetDataCache dataCache = m_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 MultiRandomAccessDocIdSet(MultiValueFacetDataCache dataCache, OpenBitSet bitset)
{
this.m_dataCache = dataCache;
this.m_bitset = bitset;
this.m_nestedArray = dataCache.NestedArray;
}
public MultiRangeFacetCountCollector(string name, MultiValueFacetDataCache dataCache,
int docBase, FacetSpec ospec, IList <string> predefinedRanges, BigNestedInt32Array nestedArray)
: base(name, dataCache, docBase, ospec, predefinedRanges)
{
m_nestedArray = nestedArray;
}
public MultiValueFacetDocIdSetIterator(MultiValueFacetDataCache dataCache, int index)
: base(dataCache, index)
{
_nestedArray = dataCache.NestedArray;
}
public MultiValueRandomAccessDocIdSet(MultiValueFacetDataCache dataCache, int index)
{
_dataCache = dataCache;
_index = index;
_nestedArray = dataCache.NestedArray;
}
public override IFacetCountCollector GetFacetCountCollector(BoboIndexReader reader, int docBase)
{
MultiValueFacetDataCache dataCache = _parent.GetFacetData <MultiValueFacetDataCache>(reader);
return(new MultiValueFacetCountCollector(_name, dataCache, docBase, _sel, _ospec));
}
public MultiValueDocScorer(MultiValueFacetDataCache dataCache, IFacetTermScoringFunctionFactory scoreFunctionFactory, float[] boostList)
: base(scoreFunctionFactory.GetFacetTermScoringFunction(dataCache.ValArray.Count, dataCache.NestedArray.Size), boostList)
{
_dataCache = dataCache;
_array = _dataCache.NestedArray;
}
public MultiValueOrFacetDocIdSetIterator(MultiValueFacetDataCache dataCache, OpenBitSet bs)
: base(dataCache, bs)
{
m_nestedArray = dataCache.NestedArray;
}
public override IFacetCountCollector GetFacetCountCollector(BoboSegmentReader reader, int docBase)
{
MultiValueFacetDataCache dataCache = m_parent.GetFacetData <MultiValueFacetDataCache>(reader);
return(new MultiValueFacetCountCollector(m_name, dataCache, docBase, m_sel, m_ospec));
}
