public override RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> prop, bool isNot)
{
RandomAccessFilter filter = null;
if (vals.Length > 1)
{
RandomAccessFilter f = new FacetOrFilter(this, vals, false);
filter = new AdaptiveFacetFilter(
new SimpleFacetHandlerFacetDataCacheBuilder(this.GetFacetData <FacetDataCache>, _name, _indexFieldName),
f,
vals,
isNot);
}
else if (vals.Length == 1)
{
filter = BuildRandomAccessFilter(vals[0], prop);
}
else
{
filter = EmptyFilter.Instance;
}
if (isNot)
{
filter = new RandomAccessNotFilter(filter);
}
return(filter);
}
public virtual RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> prop, bool isNot)
{
List <RandomAccessFilter> filterList = new List <RandomAccessFilter>(vals.Length);
foreach (string val in vals)
{
RandomAccessFilter f = BuildRandomAccessFilter(val, prop);
if (f != null && !(f is EmptyFilter))
{
filterList.Add(f);
}
}
RandomAccessFilter finalFilter;
if (filterList.Count == 0)
{
finalFilter = EmptyFilter.Instance;
}
else
{
finalFilter = new RandomAccessOrFilter(filterList);
}
if (isNot)
{
finalFilter = new RandomAccessNotFilter(finalFilter);
}
return(finalFilter);
}
public override RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> prop, bool isNot)
{
RandomAccessFilter filter = null;
if (vals.Length > 1)
{
MultiValueORFacetFilter f = new MultiValueORFacetFilter(this, vals, false); // catch the "not" case later
if (!isNot)
{
AdaptiveFacetFilter af = new AdaptiveFacetFilter(new SimpleDataCacheBuilder(Name, _indexFieldName), f, vals, false);
return(af);
}
else
{
filter = f;
}
}
else if (vals.Length == 1)
{
filter = BuildRandomAccessFilter(vals[0], prop);
}
else
{
filter = EmptyFilter.Instance;
}
if (isNot)
{
filter = new RandomAccessNotFilter(filter);
}
return(filter);
}
public override RandomAccessFilter BuildRandomAccessAndFilter(string[] bucketStrings, IDictionary <string, string> prop)
{
List <RandomAccessFilter> filterList = new List <RandomAccessFilter>();
var dependOnFacetHandler = GetDependedFacetHandler(m_dependsOnFacetName);
foreach (string bucketString in bucketStrings)
{
string[] vals = m_predefinedBuckets.Get(bucketString);
RandomAccessFilter filter = dependOnFacetHandler.BuildRandomAccessOrFilter(vals, prop, false);
if (filter == EmptyFilter.Instance)
{
return(EmptyFilter.Instance);
}
filterList.Add(filter);
}
if (filterList.Count == 0)
{
return(EmptyFilter.Instance);
}
if (filterList.Count == 1)
{
return(filterList[0]);
}
return(new RandomAccessAndFilter(filterList));
}
public void Test1Filter()
{
BrowseRequest request = CreateRequest(1, "prop3");
FacetCountCollectorSource facetCountCollectorSource = attributesFacetHandler.GetFacetCountCollectorSource(request.GetSelection(AttributeHandlerName), request.GetFacetSpec(AttributeHandlerName));
RandomAccessFilter randomAccessFilter = attributesFacetHandler.BuildFilter(request.GetSelection(AttributeHandlerName));
DocIdSetIterator iterator = randomAccessFilter.GetDocIdSet(boboReader).Iterator();
int docId = iterator.NextDoc();
int[] docIds = new int[2];
int i = 0;
while (docId != DocIdSetIterator.NO_MORE_DOCS)
{
docIds[i] = docId;
i++;
docId = iterator.NextDoc();
}
Assert.AreEqual(Arrays.ToString(new int[] { 1, 2 }), Arrays.ToString(docIds));
BrowseResult res = browser.Browse(request);
Assert.AreEqual(res.NumHits, 2);
IFacetAccessible fa = res.GetFacetAccessor(AttributeHandlerName);
IEnumerable <BrowseFacet> facets = fa.GetFacets();
Console.WriteLine(facets);
Assert.AreEqual(3, facets.Count());
BrowseFacet facet = facets.Get(0);
Assert.AreEqual(1, facet.FacetValueHitCount);
}
public override RandomAccessFilter BuildRandomAccessFilter(string val, IDictionary <string, string> props)
{
GeoLatLonRange range = GeoLatLonRange.Parse(val);
RandomAccessFilter latFilter = _latFacetHandler.BuildRandomAccessFilter(range.latRange, props);
RandomAccessFilter longFilter = _longFacetHandler.BuildRandomAccessFilter(range.lonRange, props);
return(new RandomAccessAndFilter(new RandomAccessFilter[] { latFilter, longFilter }));
}
public override RandomAccessFilter BuildRandomAccessFilter(string value, IDictionary <string, string> selectionProperty)
{
RandomAccessFilter retFilter = EmptyFilter.Instance;
ComboSelection comboSel = ComboSelection.Parse(value, _separator);
if (comboSel != null)
{
IFacetHandler handler = GetDependedFacetHandler(comboSel.Name);
if (handler != null)
{
retFilter = handler.BuildRandomAccessFilter(comboSel.Value, selectionProperty);
}
}
return(retFilter);
}
public override RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> props, bool isNot)
{
List <string> latValList = new List <string>(vals.Length);
List <string> longValList = new List <string>(vals.Length);
foreach (string val in vals)
{
GeoLatLonRange range = GeoLatLonRange.Parse(val);
latValList.Add(range.latRange);
longValList.Add(range.lonRange);
}
RandomAccessFilter latFilter = _latFacetHandler.BuildRandomAccessOrFilter(latValList.ToArray(), props, isNot);
RandomAccessFilter longFilter = _longFacetHandler.BuildRandomAccessOrFilter(longValList.ToArray(), props, isNot);
return(new RandomAccessAndFilter(new RandomAccessFilter[] { latFilter, longFilter }));
}
public virtual RandomAccessFilter BuildFilter(BrowseSelection sel)
{
string[] selections = sel.Values;
string[] notSelections = sel.NotValues;
IDictionary <string, string> prop = sel.SelectionProperties;
RandomAccessFilter filter = null;
if (selections != null && selections.Length > 0)
{
if (sel.SelectionOperation == BrowseSelection.ValueOperation.ValueOperationAnd)
{
filter = BuildRandomAccessAndFilter(selections, prop);
if (filter == null)
{
filter = EmptyFilter.Instance;
}
}
else
{
filter = BuildRandomAccessOrFilter(selections, prop, false);
if (filter == null)
{
return(EmptyFilter.Instance);
}
}
}
if (notSelections != null && notSelections.Length > 0)
{
RandomAccessFilter notFilter = BuildRandomAccessOrFilter(notSelections, prop, true);
if (filter == null)
{
filter = notFilter;
}
else
{
RandomAccessFilter andFilter =
new RandomAccessAndFilter(new RandomAccessFilter[] { filter, notFilter }.ToList());
filter = andFilter;
}
}
return(filter);
}
public override RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> prop, bool isNot)
{
IDictionary <string, IList <string> > valMap = ConvertMap(vals, _separator);
List <RandomAccessFilter> filterList = new List <RandomAccessFilter>();
foreach (var entry in valMap)
{
string name = entry.Key;
IFacetHandler facetHandler = GetDependedFacetHandler(name);
if (facetHandler == null)
{
continue;
}
IList <string> selVals = entry.Value;
if (selVals == null || selVals.Count == 0)
{
continue;
}
RandomAccessFilter f = facetHandler.BuildRandomAccessOrFilter(selVals.ToArray(), prop, isNot);
if (f == EmptyFilter.Instance)
{
continue;
}
filterList.Add(f);
}
if (filterList.Count == 0)
{
return(EmptyFilter.Instance);
}
if (filterList.Count == 1)
{
return(filterList.Get(0));
}
if (isNot)
{
return(new RandomAccessAndFilter(filterList));
}
else
{
return(new RandomAccessOrFilter(filterList));
}
}
public override RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> prop, bool isNot)
{
RandomAccessFilter filter = null;
if (vals.Length > 0)
{
filter = new CompactMultiValueFacetFilter(this, vals);
}
else
{
filter = EmptyFilter.Instance;
}
if (isNot)
{
filter = new RandomAccessNotFilter(filter);
}
return(filter);
}
public override RandomAccessFilter BuildRandomAccessAndFilter(string[] vals, IDictionary <string, string> prop)
{
if (vals.Length > 1)
{
return(EmptyFilter.Instance);
}
else
{
RandomAccessFilter f = BuildRandomAccessFilter(vals[0], prop);
if (f != null)
{
return(f);
}
else
{
return(EmptyFilter.Instance);
}
}
}
// NOTE: The Weight.Scorer method lost the scoreDocsInOrder and topScorer parameters between
// Lucene 4.3.0 and 4.8.0. They are not used by BoboBrowse anyway, so the code here diverges
// from the original Java source to remove these two parameters.
// public override Scorer Scorer(AtomicReaderContext context, bool scoreDocsInOrder, bool topScorer, Bits acceptDocs)
public override Scorer GetScorer(AtomicReaderContext context, IBits acceptDocs)
{
AtomicReader reader = context.AtomicReader;
if (reader is BoboSegmentReader)
{
BoboSegmentReader boboReader = (BoboSegmentReader)reader;
IFacetHandler fhandler = boboReader.GetFacetHandler(m_parent.m_name);
if (fhandler != null)
{
DocIdSetIterator dociter = null;
RandomAccessFilter filter = fhandler.BuildFilter(m_parent.m_sel);
if (filter != null)
{
RandomAccessDocIdSet docset = filter.GetRandomAccessDocIdSet(boboReader);
if (docset != null)
{
dociter = BuildIterator(docset, boboReader, acceptDocs);
}
}
if (dociter == null)
{
dociter = new MatchAllDocIdSetIterator(reader, acceptDocs);
}
BoboDocScorer scorer = null;
if (fhandler is IFacetScoreable)
{
scorer = ((IFacetScoreable)fhandler).GetDocScorer(boboReader, m_parent.m_scoringFactory, m_parent.m_boostMap);
}
return(new FacetTermScorer(m_parent, m_similarity, dociter, scorer));
}
else
{
logger.Error("FacetHandler is not defined for the field: " + m_parent.m_name);
}
return(null);
}
else
{
throw new IOException("index reader not instance of " + typeof(BoboSegmentReader));
}
}
public override RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> prop, bool isNot)
{
if (vals.Length > 1)
{
if (vals.Length > 0)
{
int depth = GetDepth(prop);
bool strict = IsStrict(prop);
PathValueConverter valConverter = new PathValueConverter(depth, strict, _separator);
if (_multiValue)
{
return(new MultiValueORFacetFilter(this, vals, valConverter, isNot));
}
return(new FacetOrFilter(this, vals, isNot, valConverter));
}
else
{
if (isNot)
{
return(null);
}
else
{
return(EmptyFilter.Instance);
}
}
}
else
{
RandomAccessFilter f = BuildRandomAccessFilter(vals[0], prop);
if (f == null)
{
return(f);
}
if (isNot)
{
f = new RandomAccessNotFilter(f);
}
return(f);
}
}
public override RandomAccessFilter BuildRandomAccessOrFilter(string[] vals, IDictionary <string, string> prop, bool isNot)
{
if (vals.Length > 1)
{
return(new BitSetFilter(new ValueConverterBitSetBuilder(FacetRangeFilter.FacetRangeValueConverter.Instance, vals, isNot), new SimpleDataCacheBuilder(Name, _indexFieldName)));
}
else
{
RandomAccessFilter filter = BuildRandomAccessFilter(vals[0], prop);
if (filter == null)
{
return(filter);
}
if (isNot)
{
filter = new RandomAccessNotFilter(filter);
}
return(filter);
}
}
public override Scorer Scorer(IndexReader reader, bool scoreDocsInOrder, bool topScorer)
{
if (reader is BoboIndexReader)
{
BoboIndexReader boboReader = (BoboIndexReader)reader;
TermDocs termDocs = boboReader.TermDocs(null);
IFacetHandler fhandler = boboReader.GetFacetHandler(parent._name);
if (fhandler != null)
{
DocIdSetIterator dociter = null;
RandomAccessFilter filter = fhandler.BuildFilter(parent._sel);
if (filter != null)
{
RandomAccessDocIdSet docset = filter.GetRandomAccessDocIdSet(boboReader);
if (docset != null)
{
dociter = BuildIterator(docset, termDocs);
}
}
if (dociter == null)
{
dociter = new MatchAllDocIdSetIterator(reader);
}
BoboDocScorer scorer = null;
if (fhandler is IFacetScoreable)
{
scorer = ((IFacetScoreable)fhandler).GetDocScorer(boboReader, parent._scoringFactory, parent._boostMap);
}
return(new FacetTermScorer(parent, _similarity, dociter, scorer));
}
else
{
logger.Error("FacetHandler is not defined for the field: " + parent._name);
}
return(null);
}
else
{
throw new IOException("index reader not instance of " + typeof(BoboIndexReader));
}
}
public override RandomAccessFilter BuildRandomAccessOrFilter(string[] bucketStrings, IDictionary <string, string> prop, bool isNot)
{
if (isNot)
{
RandomAccessFilter excludeFilter = BuildRandomAccessAndFilter(bucketStrings, prop);
return(new RandomAccessNotFilter(excludeFilter));
}
else
{
var dependOnFacetHandler = GetDependedFacetHandler(m_dependsOnFacetName);
HashSet <string> selections = new HashSet <string>();
foreach (string bucket in bucketStrings)
{
string[] vals = m_predefinedBuckets.Get(bucket);
if (vals != null)
{
foreach (string val in vals)
{
selections.Add(val);
}
}
}
if (selections != null && selections.Count > 0)
{
string[] sels = selections.ToArray();
if (selections.Count == 1)
{
return(dependOnFacetHandler.BuildRandomAccessFilter(sels[0], prop));
}
else
{
return(dependOnFacetHandler.BuildRandomAccessOrFilter(sels, prop, false));
}
}
else
{
return(EmptyFilter.Instance);
}
}
}
public override RandomAccessFilter BuildRandomAccessAndFilter(string[] vals, IDictionary <string, string> prop)
{
List <RandomAccessFilter> filterList = new List <RandomAccessFilter>(vals.Length);
foreach (string val in vals)
{
RandomAccessFilter f = BuildRandomAccessFilter(val, prop);
if (f != null)
{
filterList.Add(f);
}
else
{
return(EmptyFilter.Instance);
}
}
if (filterList.Count == 1)
{
return(filterList[0]);
}
return(new RandomAccessAndFilter(filterList));
}
public virtual void Browse(
BrowseRequest req,
Weight weight,
Collector collector,
IDictionary <string, IFacetAccessible> facetMap,
int start)
{
if (_reader == null)
{
return;
}
// initialize all RuntimeFacetHandlers with data supplied by user at run-time.
_runtimeFacetHandlers = new List <IRuntimeFacetHandler>(_runtimeFacetHandlerFactoryMap.Count());
IEnumerable <string> runtimeFacetNames = _runtimeFacetHandlerFactoryMap.Keys;
foreach (string facetName in runtimeFacetNames)
{
var sfacetHandler = this.GetFacetHandler(facetName);
if (sfacetHandler != null)
{
logger.Warn("attempting to reset facetHandler: " + sfacetHandler);
continue;
}
IRuntimeFacetHandlerFactory factory = (IRuntimeFacetHandlerFactory)_runtimeFacetHandlerFactoryMap.Get(facetName);
try
{
FacetHandlerInitializerParam data = req.GetFacetHandlerData(facetName);
if (data == null)
{
data = FacetHandlerInitializerParam.EMPTY_PARAM;
}
if (data != FacetHandlerInitializerParam.EMPTY_PARAM || !factory.IsLoadLazily)
{
IRuntimeFacetHandler facetHandler = factory.Get(data);
if (facetHandler != null)
{
_runtimeFacetHandlers.Add(facetHandler); // add to a list so we close them after search
this.SetFacetHandler(facetHandler);
}
}
}
catch (Exception e)
{
throw new BrowseException("error trying to set FacetHandler : " + facetName + ":" + e.Message, e);
}
}
// done initialize all RuntimeFacetHandlers with data supplied by user at run-time.
IEnumerable <string> fields = FacetNames;
List <Filter> preFilterList = new List <Filter>();
List <FacetHitCollector> facetHitCollectorList = new List <FacetHitCollector>();
Filter baseFilter = req.Filter;
if (baseFilter != null)
{
preFilterList.Add(baseFilter);
}
int selCount = req.SelectionCount;
bool isNoQueryNoFilter = IsNoQueryNoFilter(req);
bool isDefaultSearch = isNoQueryNoFilter && selCount == 0;
try
{
foreach (string name in fields)
{
BrowseSelection sel = req.GetSelection(name);
FacetSpec ospec = req.GetFacetSpec(name);
var handler = GetFacetHandler(name);
if (handler == null)
{
logger.Error("facet handler: " + name + " is not defined, ignored.");
continue;
}
FacetHitCollector facetHitCollector = null;
RandomAccessFilter filter = null;
if (sel != null)
{
filter = handler.BuildFilter(sel);
}
if (ospec == null)
{
if (filter != null)
{
preFilterList.Add(filter);
}
}
else
{
/*FacetSpec fspec = new FacetSpec(); // OrderValueAsc,
* fspec.setMaxCount(0);
* fspec.setMinHitCount(1);
*
* fspec.setExpandSelection(ospec.isExpandSelection());*/
FacetSpec fspec = ospec;
facetHitCollector = new FacetHitCollector();
facetHitCollector.facetHandler = handler;
if (isDefaultSearch)
{
facetHitCollector._collectAllSource = handler.GetFacetCountCollectorSource(sel, fspec);
}
else
{
facetHitCollector._facetCountCollectorSource = handler.GetFacetCountCollectorSource(sel, fspec);
if (ospec.ExpandSelection)
{
if (isNoQueryNoFilter && sel != null && selCount == 1)
{
facetHitCollector._collectAllSource = handler.GetFacetCountCollectorSource(sel, fspec);
if (filter != null)
{
preFilterList.Add(filter);
}
}
else
{
if (filter != null)
{
facetHitCollector._filter = filter;
}
}
}
else
{
if (filter != null)
{
preFilterList.Add(filter);
}
}
}
}
if (facetHitCollector != null)
{
facetHitCollectorList.Add(facetHitCollector);
}
}
Filter finalFilter = null;
if (preFilterList.Count > 0)
{
if (preFilterList.Count == 1)
{
finalFilter = preFilterList.First();
}
else
{
finalFilter = new AndFilter(preFilterList);
}
}
this.FacetHitCollectorList = facetHitCollectorList;
try
{
if (weight == null)
{
var q = req.Query;
if (q == null)
{
q = new MatchAllDocsQuery();
}
weight = CreateWeight(q);
}
Search(weight, finalFilter, collector, start, req.MapReduceWrapper);
}
finally
{
foreach (FacetHitCollector facetCollector in facetHitCollectorList)
{
string name = facetCollector.facetHandler.Name;
List <IFacetCountCollector> resultcollector = null;
resultcollector = facetCollector._countCollectorList;
if (resultcollector == null || resultcollector.Count == 0)
{
resultcollector = facetCollector._collectAllCollectorList;
}
if (resultcollector != null)
{
FacetSpec fspec = req.GetFacetSpec(name);
Debug.Assert(fspec != null);
if (resultcollector.Count == 1)
{
facetMap.Put(name, resultcollector[0]);
}
else
{
List <IFacetAccessible> finalList = new List <IFacetAccessible>(resultcollector.Count);
foreach (IFacetCountCollector fc in resultcollector)
{
finalList.Add((IFacetAccessible)fc);
}
CombinedFacetAccessible combinedCollector = new CombinedFacetAccessible(fspec, finalList);
facetMap.Put(name, combinedCollector);
}
}
}
}
}
catch (Exception ioe)
{
throw new BrowseException(ioe.Message, ioe);
}
}