public virtual Explanation Explain(AtomicReader reader, int doc, Explanation innerExplanation)
{
if (reader is BoboSegmentReader)
{
BoboSegmentReader boboReader = (BoboSegmentReader)reader;
object dataObj = boboReader.GetFacetData(m_timeFacetName);
if (dataObj is FacetDataCache)
{
FacetDataCache facetDataCache = (FacetDataCache)(boboReader.GetFacetData(m_timeFacetName));
BigSegmentedArray orderArray = facetDataCache.OrderArray;
TermInt64List termList = (TermInt64List)facetDataCache.ValArray;
Explanation finalExpl = new Explanation();
finalExpl.AddDetail(innerExplanation);
float rawScore = innerExplanation.Value;
long timeVal = termList.GetPrimitiveValue(orderArray.Get(doc));
float timeScore = ComputeTimeFactor(timeVal);
float finalScore = CombineScores(timeScore, rawScore);
finalExpl.Value = finalScore;
finalExpl.Description = "final score = (time score: " + timeScore + ") * (raw score: " + rawScore + "), timeVal: " + timeVal;
return(finalExpl);
}
else
{
throw new InvalidOperationException("underlying facet data must be of type FacetDataCache<long>");
}
}
else
{
throw new ArgumentException("reader not instance of " + typeof(BoboSegmentReader));
}
}
public override object[] GetRawFieldValues(BoboSegmentReader reader, int id)
{
FacetDataCache dataCache = GetFacetData <FacetDataCache>(reader);
if (dataCache == null)
{
return(new string[0]);
}
int encoded = dataCache.OrderArray.Get(id);
if (encoded == 0)
{
return(new object[0]);
}
else
{
int count = 1;
List <Object> valList = new List <Object>(MAX_VAL_COUNT);
while (encoded != 0)
{
if ((encoded & 0x00000001) != 0x0)
{
valList.Add(dataCache.ValArray.GetRawValue(count));
}
count++;
encoded = (int)(((uint)encoded) >> 1);
}
return(valList.ToArray());
}
}
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 string[] GetFieldValues(BoboSegmentReader reader, int id)
{
List <string> valList = new List <string>();
foreach (IFacetHandler handler in m_facetHandlers)
{
StringBuilder buf = new StringBuilder();
bool firsttime = true;
string[] vals = handler.GetFieldValues(reader, id);
if (vals != null && vals.Length > 0)
{
if (!firsttime)
{
buf.Append(",");
}
else
{
firsttime = false;
}
foreach (string val in vals)
{
buf.Append(val);
}
}
valList.Add(buf.ToString());
}
return(valList.ToArray());
}
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 GeoFacetData Load(BoboSegmentReader reader)
{
GeoFacetData dataCache = new GeoFacetData();
dataCache.Load(m_latFieldName, m_lonFieldName, reader);
return(dataCache);
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboSegmentReader reader)
{
FacetDataCache dataCache = m_facetHandler.GetFacetData <FacetDataCache>(reader);
int[] indexes = FacetDataCache.Convert(dataCache, m_vals);
int bits;
bits = 0x0;
foreach (int i in indexes)
{
bits |= 0x00000001 << (i - 1);
}
int finalBits = bits;
BigSegmentedArray orderArray = dataCache.OrderArray;
if (indexes.Length == 0)
{
return(EmptyDocIdSet.Instance);
}
else
{
return(new CompactMultiValueFacetFilterDocIdSet(dataCache, indexes, finalBits, orderArray));
}
}
public FacetBasedBoostingScorer(FacetBasedBoostScorerBuilder parent, BoboSegmentReader reader, Scorer innerScorer)
: base(innerScorer.Weight)
{
m_innerScorer = innerScorer;
List <BoboDocScorer> list = new List <BoboDocScorer>();
foreach (var boostEntry in parent.m_boostMaps)
{
string facetName = boostEntry.Key;
IFacetHandler handler = reader.GetFacetHandler(facetName);
if (!(handler is IFacetScoreable))
{
throw new ArgumentException(facetName + " does not implement IFacetScoreable");
}
IFacetScoreable facetScoreable = (IFacetScoreable)handler;
BoboDocScorer scorer = facetScoreable.GetDocScorer(reader, parent.m_scoringFunctionFactory, boostEntry.Value);
if (scorer != null)
{
list.Add(scorer);
}
}
m_facetScorers = list.ToArray();
m_docid = -1;
}
public override FacetDataCache Load(BoboSegmentReader reader)
{
FacetDataCache dataCache = new FacetDataCache();
dataCache.Load(m_indexFieldName, reader, m_termListFactory);
return(dataCache);
}
public override double GetFacetSelectivity(BoboSegmentReader reader)
{
double selectivity = m_innerFilter.GetFacetSelectivity(reader);
selectivity = selectivity > 0.999 ? 0.0 : (1 - selectivity);
return(selectivity);
}
public override IFacetCountCollector GetFacetCountCollector(BoboSegmentReader reader, int docBase)
{
FacetDataCache latDataCache = _latFacetHandler.GetFacetData <FacetDataCache>(reader);
FacetDataCache longDataCache = _longFacetHandler.GetFacetData <FacetDataCache>(reader);
return(new GeoSimpleFacetCountCollector(_name, latDataCache, longDataCache, docBase, _fspec, _list));
}
public virtual BoboDocScorer GetDocScorer(BoboSegmentReader reader, IFacetTermScoringFunctionFactory scoringFunctionFactory, IDictionary <string, float> boostMap)
{
MultiValueFacetDataCache dataCache = GetFacetData <MultiValueFacetDataCache>(reader);
float[] boostList = BoboDocScorer.BuildBoostList(dataCache.ValArray, boostMap);
return(new MultiValueDocScorer(dataCache, scoringFunctionFactory, boostList));
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboSegmentReader reader)
{
RandomAccessDocIdSet innerDocIdSet = m_innerFilter.GetRandomAccessDocIdSet(reader);
DocIdSet notInnerDocIdSet = new NotDocIdSet(innerDocIdSet, reader.MaxDoc);
return(new NotRandomAccessDocIdSet(innerDocIdSet, notInnerDocIdSet));
}
public override double GetFacetSelectivity(BoboSegmentReader reader)
{
double selectivity = 0;
FacetDataCache dataCache = m_facetHandler.GetFacetData <FacetDataCache>(reader);
int accumFreq = 0;
foreach (string val in m_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 (m_takeCompliment)
{
selectivity = 1.0 - selectivity;
}
return(selectivity);
}
public override IFacetCountCollector GetFacetCountCollector(BoboSegmentReader reader, int docBase)
{
FacetDataCache dataCache = (FacetDataCache)reader.GetFacetData(m_dataHandlerName);
IFacetCountCollector baseCollector = m_baseCollectorSrc.GetFacetCountCollector(reader, docBase);
return(new HistogramCollector(m_name, baseCollector, dataCache, m_ospec, m_start, m_end, m_unit));
}
public override int GetNumItems(BoboSegmentReader reader, int id)
{
var dependOnFacetHandler = GetDependedFacetHandler(m_dependsOnFacetName);
FacetDataCache data = dependOnFacetHandler.GetFacetData <FacetDataCache>(reader);
return(data.GetNumItems(id));
}
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 Explanation Explain(AtomicReaderContext context, int docid)
{
BoboSegmentReader boboReader = (BoboSegmentReader)context.Reader;
IFacetHandler fhandler = boboReader.GetFacetHandler(m_parent.m_name);
if (fhandler != null)
{
BoboDocScorer scorer = null;
if (fhandler is IFacetScoreable)
{
scorer = ((IFacetScoreable)fhandler).GetDocScorer(boboReader, m_parent.m_scoringFactory, m_parent.m_boostMap);
Explanation exp1 = scorer.Explain(docid);
Explanation exp2 = new Explanation(m_parent.Boost, "boost");
Explanation expl = new Explanation();
expl.Description = "product of:";
expl.Value = (exp1.Value * exp2.Value);
expl.AddDetail(exp1);
expl.AddDetail(exp2);
return(expl);
}
else
{
return(null);
}
}
return(null);
}
public MyScoreDoc(int docid, float score, DocIDPriorityQueue queue, BoboSegmentReader reader)
: base(docid, score)
{
this.m_queue = queue;
this.m_reader = reader;
this.m_sortValue = null;
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboSegmentReader reader)
{
int maxDoc = reader.MaxDoc;
GeoFacetHandler.GeoFacetData dataCache = m_handler.GetFacetData <GeoFacetHandler.GeoFacetData>(reader);
return(new GeoDocIdSet(dataCache.xValArray, dataCache.yValArray, dataCache.zValArray,
m_lat, m_lon, m_rad, maxDoc, m_miles));
}
public BoboSearcher(BoboSegmentReader reader)
: base(reader)
{
m_facetCollectors = new List <FacetHitCollector>();
var readerList = new List <BoboSegmentReader>();
readerList.Add(reader);
m_subReaders = readerList.ToArray();
}
public override double GetFacetSelectivity(BoboSegmentReader reader)
{
double selectivity = m_facetFilter.GetFacetSelectivity(reader);
if (m_takeComplement)
{
return(1.0 - selectivity);
}
return(selectivity);
}
public override object[] GetRawFieldValues(BoboSegmentReader 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 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 int GetNumItems(BoboSegmentReader reader, int id)
{
MultiValueFacetDataCache data = GetFacetData <MultiValueFacetDataCache>(reader);
if (data == null)
{
return(0);
}
return(data.GetNumItems(id));
}
public override IFacetCountCollector GetFacetCountCollector(BoboSegmentReader reader, int docBase)
{
var collectorList = new List <DefaultFacetCountCollector>(m_facetHandlers.Count);
foreach (var facetHandler in m_facetHandlers)
{
collectorList.Add((DefaultFacetCountCollector)facetHandler.GetFacetCountCollectorSource(m_sel, m_fspec).GetFacetCountCollector(reader, docBase));
}
return(new GroupbyFacetCountCollector(m_name, m_fspec, collectorList.ToArray(), reader.MaxDoc, m_sep));
}
public override RandomAccessDocIdSet GetRandomAccessDocIdSet(BoboSegmentReader reader)
{
if (m_vals.Length == 0)
{
return(EmptyDocIdSet.Instance);
}
else
{
return(new FacetOrRandomAccessDocIdSet(m_facetHandler, reader, m_vals, m_valueConverter, m_takeCompliment));
}
}
public override DocComparer GetComparer(AtomicReader reader, int docbase)
{
if (!(reader is BoboSegmentReader))
{
throw new ArgumentException("reader must be instance of " + typeof(BoboSegmentReader).Name);
}
BoboSegmentReader boboReader = (BoboSegmentReader)reader;
MultiValueFacetDataCache dataCache = (MultiValueFacetDataCache)m_cacheBuilder.Build(boboReader);
return(new MultiFacetDocComparer(dataCache));
}
public override FacetDataNone Load(BoboSegmentReader reader)
{
m_dataFacetHandler = reader.GetFacetHandler(m_dataHandlerName);
if (m_dataFacetHandler is RangeFacetHandler)
{
if (((RangeFacetHandler)m_dataFacetHandler).HasPredefinedRanges)
{
throw new NotSupportedException("underlying range facet handler should not have the predefined ranges");
}
}
return(FacetDataNone.Instance);
}
public override void SetNextReader(AtomicReaderContext context)
{
AtomicReader reader = context.AtomicReader;
if (!(reader is BoboSegmentReader))
{
throw new ArgumentException("reader must be a BoboIndexReader");
}
m_currentReader = (BoboSegmentReader)reader;
int docBase = context.DocBase;
m_currentComparer = m_compSource.GetComparer(m_currentReader, docBase);
m_currentQueue = new DocIDPriorityQueue(m_currentComparer, m_numHits, docBase);
if (m_groupBy != null)
{
if (m_facetCountCollectorMulti != null) // _facetCountCollectorMulti.Length >= 1
{
for (int i = 0; i < m_facetCountCollectorMulti.Length; ++i)
{
m_facetCountCollectorMulti[i] = m_groupByMulti[i].GetFacetCountCollectorSource(null, null, true).GetFacetCountCollector(m_currentReader, docBase);
}
//if (_facetCountCollector != null)
// collectTotalGroups();
m_facetCountCollector = m_facetCountCollectorMulti[0];
if (m_facetAccessibleLists != null)
{
for (int i = 0; i < m_facetCountCollectorMulti.Length; ++i)
{
m_facetAccessibleLists[i].Add(m_facetCountCollectorMulti[i]);
}
}
}
if (m_currentValueDocMaps != null)
{
m_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, _currentComparer);
// contextList.Add(_currentContext);
//}
}
MyScoreDoc myScoreDoc = (MyScoreDoc)m_tmpScoreDoc;
myScoreDoc.m_queue = m_currentQueue;
myScoreDoc.m_reader = m_currentReader;
myScoreDoc.m_sortValue = null;
m_pqList.Add(m_currentQueue);
m_queueFull = false;
}
