public LatLongDistanceFilter(Filter startingFilter, double distance, double lat, double lng, string latField, string lngField) : base(startingFilter, distance)
{
_lat = lat;
_lngField = lngField;
_latField = latField;
_lng = lng;
}
internal Hits(Searcher s, Query q, Filter f)
{
weight = q.Weight(s);
searcher = s;
filter = f;
GetMoreDocs(50); // retrieve 100 initially
}
/// <summary>
/// Create a ToChildBlockJoinQuery.
/// </summary>
/// <param name="parentQuery">Query that matches parent documents</param>
/// <param name="parentsFilter">Filter (must produce FixedBitSet per-segment, like <see cref="FixedBitSetCachingWrapperFilter"/>)
/// identifying the parent documents.</param>
/// <param name="doScores">True if parent scores should be calculated.</param>
public ToChildBlockJoinQuery(Query parentQuery, Filter parentsFilter, bool doScores)
{
_origParentQuery = parentQuery;
_parentQuery = parentQuery;
_parentsFilter = parentsFilter;
_doScores = doScores;
}
/// <summary>
/// 构建Query、Filter、Sort
/// </summary>
/// <param name="query"><see cref="Query"/></param>
/// <param name="filter"><see cref="Filter"/></param>
/// <param name="sort"><see cref="Sort"/></param>
public void BuildQuery(out Query query, out Filter filter, out Sort sort)
{
BooleanQuery q = new BooleanQuery();
foreach (var clause in clauses)
{
q.Add(clause);
}
query = q;
if (filters.Count > 0)
{
BooleanQuery filterQuery = new BooleanQuery();
foreach (var _filter in filters)
filterQuery.Add(_filter);
filter = new QueryWrapperFilter(filterQuery);
}
else
{
filter = null;
}
if (sortFields.Count > 0)
sort = new Sort(sortFields.ToArray());
else
sort = null;
}
public void SearchFiltered(IndexWriter writer, Directory directory, Filter filter, bool optimize)
{
try
{
for (int i = 0; i < 60; i++)
{//Simple docs
Document doc = new Document();
doc.Add(new Field(FIELD, i.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED));
writer.AddDocument(doc);
}
if (optimize)
writer.Optimize();
writer.Close();
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(new TermQuery(new Term(FIELD, "36")), Occur.SHOULD);
IndexSearcher indexSearcher = new IndexSearcher(directory);
ScoreDoc[] hits = indexSearcher.Search(booleanQuery, filter, 1000).ScoreDocs;
Assert.AreEqual(1, hits.Length, "Number of matched documents");
}
catch (System.IO.IOException e)
{
Assert.Fail(e.Message);
}
}
private void SearchWithFilter(IndexReader reader, Weight weight, Filter filter, Collector collector)
{
DocIdSet docIdSet = filter.GetDocIdSet(reader);
if (docIdSet == null)
return;
Scorer scorer = weight.Scorer(reader, true, false);
if (scorer == null)
return;
scorer.DocID();
DocIdSetIterator docIdSetIterator = docIdSet.Iterator();
if (docIdSetIterator == null)
return;
int target = docIdSetIterator.NextDoc();
int num = scorer.Advance(target);
collector.SetScorer(scorer);
while (true)
{
while (num != target)
{
if (num > target)
target = docIdSetIterator.Advance(num);
else
num = scorer.Advance(target);
}
if (num != DocIdSetIterator.NO_MORE_DOCS && !((GroupCollector)collector).GroupLimitReached)
{
collector.Collect(num);
target = docIdSetIterator.NextDoc();
num = scorer.Advance(target);
}
else
break;
}
}
public static OpenBitSet CreateBitSet(IndexReader reader, Filter filter)
{
IndexSearcher searcher = new IndexSearcher(reader);
OpenBitSet result = new OpenBitSet();
searcher.Search(new MatchAllDocsQuery(), filter, new BitSetCollector(result));
return result;
}
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected override void Warm(IndexSearcher searcher)
{
searcher.Search(new MatchAllDocsQuery(), 1);
// Create the tenant filters
_filters = new Dictionary<string, Filter>();
IEnumerable<string> tenantIds = PackageTenantId.GetDistintTenantId(searcher.IndexReader);
foreach (string tenantId in tenantIds)
{
_filters.Add(tenantId, new CachingWrapperFilter(new TenantFilter(tenantId)));
}
_publicFilter = new CachingWrapperFilter(new PublicFilter());
_latestVersion = new CachingWrapperFilter(LatestVersionFilter.Create(searcher.IndexReader, false, false));
_latestVersionIncludeUnlisted = new CachingWrapperFilter(LatestVersionFilter.Create(searcher.IndexReader, false, true));
_latestVersionIncludePrerelease = new CachingWrapperFilter(LatestVersionFilter.Create(searcher.IndexReader, true, false));
_latestVersionIncludePrereleaseIncludeUnlisted = new CachingWrapperFilter(LatestVersionFilter.Create(searcher.IndexReader, true, true));
// Recalculate precalculated Versions arrays
PackageVersions packageVersions = new PackageVersions(searcher.IndexReader);
_versionsByDoc = packageVersions.CreateVersionsLookUp(null);
_versionListsByDoc = packageVersions.CreateVersionListsLookUp();
// Set metadata
LastReopen = DateTime.UtcNow;
NumDocs = searcher.IndexReader.NumDocs();
CommitUserData = searcher.IndexReader.CommitUserData;
}
/// <summary>
/// Create ToParentBlockJoinSortField.
/// </summary>
/// <param name="field"> The sort field on the nested / child level. </param>
/// <param name="type"> The sort type on the nested / child level. </param>
/// <param name="reverse"> Whether natural order should be reversed on the nested / child document level. </param>
/// <param name="order"> Whether natural order should be reversed on the parent level. </param>
/// <param name="parentFilter"> Filter that identifies the parent documents. </param>
/// <param name="childFilter"> Filter that defines which child documents participates in sorting. </param>
public ToParentBlockJoinSortField(string field, Type_e type, bool reverse, bool order, Filter parentFilter, Filter childFilter)
: base(field, type, reverse)
{
Order = order;
ParentFilter = parentFilter;
ChildFilter = childFilter;
}
private ToChildBlockJoinQuery(Query origParentQuery, Query parentQuery, Filter parentsFilter, bool doScores)
: base()
{
_origParentQuery = origParentQuery;
_parentQuery = parentQuery;
_parentsFilter = parentsFilter;
_doScores = doScores;
}
public FacetMatcher(Filter query, IndexReader indexReader)
{
Throw.IfArgumentNull(query);
Throw.IfArgumentNull(indexReader);
this._query = query;
this._indexReader = indexReader;
}
public BrowseRequest()
{
selections = new Dictionary<string, BrowseSelection>();
sortFields = new List<SortField>();
FacetSpecs = new Dictionary<string, FacetSpec>();
Filter = null;
FetchStoredFields = false;
}
/// <summary>
/// Wraps a Filter as a Query. The hits will get a constant score
/// dependent on the boost factor of this query.
/// If you simply want to strip off scores from a Query, no longer use
/// {@code new ConstantScoreQuery(new QueryWrapperFilter(query))}, instead
/// use <seealso cref="#ConstantScoreQuery(Query)"/>!
/// </summary>
public ConstantScoreQuery(Filter filter)
{
if (filter == null)
{
throw new System.NullReferenceException("Filter may not be null");
}
this.filter = filter;
this.query = null;
}
public PKIndexSplitter(Directory input, Directory dir1, Directory dir2, Filter docsInFirstIndex, IndexWriterConfig config1, IndexWriterConfig config2)
{
this.input = input;
this.dir1 = dir1;
this.dir2 = dir2;
this.docsInFirstIndex = docsInFirstIndex;
this.config1 = config1;
this.config2 = config2;
}
public /*internal*/ bool debugCheckedForDeletions = false; // for test purposes.
internal Hits(Searcher s, Query q, Filter f)
{
weight = q.Weight(s);
searcher = s;
filter = f;
nDeletions = CountDeletions(s);
GetMoreDocs(50); // retrieve 100 initially
lengthAtStart = length;
}
/// <summary>
/// Strips off scores from the passed in Query. The hits will get a constant score
/// dependent on the boost factor of this query.
/// </summary>
public ConstantScoreQuery(Query query)
{
if (query == null)
{
throw new System.NullReferenceException("Query may not be null");
}
this.filter = null;
this.query = query;
}
/// <param name="strategy">Needed to compute intersects</param>
/// <param name="args">Used in spatial intersection</param>
/// <param name="field">
/// This field is used to determine which docs have spatial data via
/// <see cref="FieldCache.GetDocsWithField(AtomicReader, string)"/>.
/// Passing null will assume all docs have spatial data.
/// </param>
public DisjointSpatialFilter(SpatialStrategy strategy, SpatialArgs args, string field)
{
this.field = field;
// TODO consider making SpatialArgs cloneable
SpatialOperation origOp = args.Operation; //copy so we can restore
args.Operation = SpatialOperation.Intersects; //temporarily set to intersects
intersectsFilter = strategy.MakeFilter(args);
args.Operation = origOp;
}
private void TstFilterCard(String mes, int expected, Filter filt)
{
DocIdSetIterator disi = filt.GetDocIdSet(reader).Iterator();
int actual = 0;
while (disi.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)
{
actual++;
}
Assert.AreEqual(expected, actual, mes);
}
public ValueSourceFilter(Filter startingFilter, ValueSource source, double min, double max)
{
if (startingFilter == null)
{
throw new ArgumentException("please provide a non-null startingFilter; you can use QueryWrapperFilter(MatchAllDocsQuery) as a no-op filter", "startingFilter");
}
this.startingFilter = startingFilter;
this.source = source;
this.min = min;
this.max = max;
}
public LuceneQueryStatistics(Query query, Filter filter, Sort sort, TimeSpan elapsedPreparationTime, TimeSpan elapsedSearchTime, TimeSpan elapsedRetrievalTime, int totalHits, int skippedHits, int retrievedDocuments)
{
this.totalHits = totalHits;
this.query = query;
this.filter = filter;
this.sort = sort;
this.elapsedPreparationTime = elapsedPreparationTime;
this.elapsedSearchTime = elapsedSearchTime;
this.elapsedRetrievalTime = elapsedRetrievalTime;
this.skippedHits = skippedHits;
this.retrievedDocuments = retrievedDocuments;
}
public void End(IndexReader indexReader)
{
foreach (Tuple<NuGetVersion, string, int> entry in _lookup.Values)
{
string readerName = entry.Item2;
int readerDocumentId = entry.Item3;
_openBitSetLookup[readerName].Set(readerDocumentId);
}
Result = new OpenBitSetLookupFilter(_openBitSetLookup);
}
private void AssertFilterEquals(Filter f1, Filter f2)
{
Query query = new MatchAllDocsQuery();
TopDocs hits1 = @is.Search(query, f1, Ir.MaxDoc());
TopDocs hits2 = @is.Search(query, f2, Ir.MaxDoc());
Assert.AreEqual(hits1.TotalHits, hits2.TotalHits);
CheckHits.CheckEqual(query, hits1.ScoreDocs, hits2.ScoreDocs);
// now do it again to confirm caching works
TopDocs hits3 = @is.Search(query, f1, Ir.MaxDoc());
TopDocs hits4 = @is.Search(query, f2, Ir.MaxDoc());
Assert.AreEqual(hits3.TotalHits, hits4.TotalHits);
CheckHits.CheckEqual(query, hits3.ScoreDocs, hits4.ScoreDocs);
}
public bool TryGetFilter(bool includeUnlisted, bool includePrerelease, string curatedFeed, out Filter filter)
{
Filter visibilityFilter = _latest[includeUnlisted ? 1 : 0][includePrerelease ? 1 : 0];
Filter curatedFeedFilter;
if (!string.IsNullOrEmpty(curatedFeed) && _curatedFeeds.TryGetValue(curatedFeed, out curatedFeedFilter))
{
filter = new ChainedFilter(new[] { visibilityFilter, curatedFeedFilter }, ChainedFilter.Logic.AND);
return true;
}
filter = visibilityFilter;
return true;
}
/// <summary>
/// Expert: Constructs a new query which applies a filter to the results of the original query.
/// <seealso cref="Filter#getDocIdSet"/> will be called every time this query is used in a search. </summary>
/// <param name="query"> Query to be filtered, cannot be <code>null</code>. </param>
/// <param name="filter"> Filter to apply to query results, cannot be <code>null</code>. </param>
/// <param name="strategy"> a filter strategy used to create a filtered scorer.
/// </param>
/// <seealso cref= FilterStrategy </seealso>
public FilteredQuery(Query query, Filter filter, FilterStrategy strategy)
{
if (query == null || filter == null)
{
throw new System.ArgumentException("Query and filter cannot be null.");
}
if (strategy == null)
{
throw new System.ArgumentException("FilterStrategy can not be null");
}
this.strategy = strategy;
this.Query_Renamed = query;
this.Filter_Renamed = filter;
}
public static Sort GetSort(this IndexQuery self, Filter filter, IndexDefinition indexDefinition)
{
var spatialIndexQuery = self as SpatialIndexQuery;
if(spatialIndexQuery != null && spatialIndexQuery.SortByDistance)
{
var dsort = new Lucene.Net.Spatial.Tier.DistanceFieldComparatorSource((Lucene.Net.Spatial.Tier.DistanceFilter)filter);
return new Sort(new SortField("foo", dsort, false));
}
if (self.SortedFields != null && self.SortedFields.Length > 0)
return new Sort(self.SortedFields.Select(x => ToLuceneSortField(indexDefinition, x)).ToArray());
return null;
}
/// <summary>
/// Expert: by default, the cached filter will be shared
/// across reopened segments that only had changes to their
/// deletions.
/// </summary>
/// <param name="filter">Filter to cache results of</param>
/// <param name="deletesMode">See <see cref="DeletesMode" /></param>
///
public CachingWrapperFilter(Filter filter, DeletesMode deletesMode)
{
this.filter = filter;
cache = new AnonymousFilterCache(deletesMode);
//cache = new FilterCache(deletesMode)
// {
// public Object mergeDeletes(final IndexReader r, final Object docIdSet) {
// return new FilteredDocIdSet((DocIdSet) docIdSet) {
// protected boolean match(int docID) {
// return !r.isDeleted(docID);
// }
// };
// }
//};
}
public override void SetUp()
{
Directory = NewDirectory();
IndexWriterConfig config = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()));
IndexWriter indexWriter = new IndexWriter(Directory, config);
for (int i = 0; i < AMOUNT_OF_SEGMENTS; i++)
{
IList<Document> segmentDocs = CreateDocsForSegment(i);
indexWriter.AddDocuments(segmentDocs);
indexWriter.Commit();
}
IndexReader = DirectoryReader.Open(indexWriter, Random().NextBoolean());
indexWriter.Dispose();
IndexSearcher = new IndexSearcher(IndexReader);
ParentsFilter = new FixedBitSetCachingWrapperFilter(new QueryWrapperFilter(new WildcardQuery(new Term("parent", "*"))));
}
/// <summary> A search implementation which spans a new thread for each
/// Searchable, waits for each search to complete and merge
/// the results back together.
/// </summary>
public override TopDocs Search(Weight weight, Filter filter, int nDocs)
{
HitQueue hq = new HitQueue(nDocs, false);
int totalHits = 0;
MultiSearcherThread[] msta = new MultiSearcherThread[searchables.Length];
for (int i = 0; i < searchables.Length; i++)
{
// search each searchable
// Assume not too many searchables and cost of creating a thread is by far inferior to a search
msta[i] = new MultiSearcherThread(searchables[i], weight, filter, nDocs, hq, i, starts, "MultiSearcher thread #" + (i + 1));
msta[i].Start();
}
for (int i = 0; i < searchables.Length; i++)
{
try
{
msta[i].Join();
}
catch (System.Threading.ThreadInterruptedException ie)
{
// In 3.0 we will change this to throw
// InterruptedException instead
SupportClass.ThreadClass.Current().Interrupt();
throw new System.SystemException(ie.Message, ie);
}
System.IO.IOException ioe = msta[i].GetIOException();
if (ioe == null)
{
totalHits += msta[i].Hits();
}
else
{
// if one search produced an IOException, rethrow it
throw ioe;
}
}
ScoreDoc[] scoreDocs = new ScoreDoc[hq.Size()];
for (int i = hq.Size() - 1; i >= 0; i--)
// put docs in array
scoreDocs[i] = (ScoreDoc) hq.Pop();
float maxScore = (totalHits == 0)?System.Single.NegativeInfinity:scoreDocs[0].score;
return new TopDocs(totalHits, scoreDocs, maxScore);
}
public virtual void TestHugeN()
{
TaskScheduler service = new LimitedConcurrencyLevelTaskScheduler(4);
IndexSearcher[] searchers = new IndexSearcher[] { new IndexSearcher(Reader), new IndexSearcher(Reader, service) };
Query[] queries = new Query[] { new MatchAllDocsQuery(), new TermQuery(new Term("field", "1")) };
Sort[] sorts = new Sort[] { null, new Sort(new SortField("field2", SortField.Type_e.STRING)) };
Filter[] filters = new Filter[] { null, new QueryWrapperFilter(new TermQuery(new Term("field2", "true"))) };
ScoreDoc[] afters = new ScoreDoc[] { null, new FieldDoc(0, 0f, new object[] { new BytesRef("boo!") }) };
foreach (IndexSearcher searcher in searchers)
{
foreach (ScoreDoc after in afters)
{
foreach (Query query in queries)
{
foreach (Sort sort in sorts)
{
foreach (Filter filter in filters)
{
searcher.Search(query, int.MaxValue);
searcher.SearchAfter(after, query, int.MaxValue);
searcher.Search(query, filter, int.MaxValue);
searcher.SearchAfter(after, query, filter, int.MaxValue);
if (sort != null)
{
searcher.Search(query, int.MaxValue, sort);
searcher.Search(query, filter, int.MaxValue, sort);
searcher.Search(query, filter, int.MaxValue, sort, true, true);
searcher.Search(query, filter, int.MaxValue, sort, true, false);
searcher.Search(query, filter, int.MaxValue, sort, false, true);
searcher.Search(query, filter, int.MaxValue, sort, false, false);
searcher.SearchAfter(after, query, filter, int.MaxValue, sort);
searcher.SearchAfter(after, query, filter, int.MaxValue, sort, true, true);
searcher.SearchAfter(after, query, filter, int.MaxValue, sort, true, false);
searcher.SearchAfter(after, query, filter, int.MaxValue, sort, false, true);
searcher.SearchAfter(after, query, filter, int.MaxValue, sort, false, false);
}
}
}
}
}
}
TestUtil.ShutdownExecutorService(service);
}
private QueryHelper <TModel> GeoFilter(Expression <Func <TModel, object> > exp, double longitude, double latitude, double distDEG)
{
string name = getName(exp.Body.ToString());
//name = name.IndexOf('.') > -1 ? name.Substring(0, name.LastIndexOf('.')) : name;
SpatialOperation op = SpatialOperation.Intersects;
//SpatialStrategy strat = new PointVectorStrategy(ctx, name);
int maxLevels = 11;
SpatialPrefixTree grid = new GeohashPrefixTree(ctx, maxLevels);
var strat = new RecursivePrefixTreeStrategy(grid, name);
var point = ctx.MakePoint(longitude, latitude);
var shape = ctx.MakeCircle(point, distDEG);
var args = new SpatialArgs(op, shape);
filter = strat.MakeFilter(args);
return(this);
}
public SearchResult GetSearchResult(Query query, Filter filter, int skip, int take, Sort sort)
{
var s = Stopwatch.StartNew();
var searchResult = _luceneSearcher.Search(query, filter, skip + take, sort);
s.Stop();
return(new SearchResult
{
Links = searchResult.ScoreDocs
.Skip(skip)
.Take(take)
.Select(storeDoc => new SearchResultItem {
Link = _luceneSearcher.Doc(storeDoc.Doc).GetField(SearchSettings.Field_ID).StringValue, Score = storeDoc.Score
})
.ToArray(),
Total = searchResult.TotalHits,
ElapsedMilliseconds = (int)s.ElapsedMilliseconds
});
}
protected DistanceFilter(Filter startingFilter, double distance)
{
if (startingFilter == null)
{
throw new ArgumentNullException("startingFilter", "Please provide a non-null startingFilter; you can use QueryWrapperFilter(MatchAllDocsQuery) as a no-op filter");
}
StartingFilter = startingFilter;
Distance = distance;
// NOTE: neither of the distance filters use precision
// now - if we turn that on, we'll need to pass top
// reader into here
// setPrecision(reader.maxDoc());
/* store calculated distances for reuse by other components */
Distances = new Dictionary<int, Double>();
// create an intermediate cache to avoid recomputing distances for the same point
DistanceLookupCache = new Dictionary<string, double>();
}
public IFullTextQuery SetFilter(Lucene.Net.Search.Filter value)
{
this.filter = value;
return(this);
}
/// <param name="filter">Filter to cache results of
/// </param>
public CachingWrapperFilter(Filter filter)
{
this.filter = filter;
}
protected override Query GetFieldQuery(string field, string queryText, bool quoted)
{
try
{
if ((field == "PuckGeoK" && !PuckCache.TypeFields[TypeName].ContainsKey("PuckGeoK")) || (field == "PuckGeoM" && !PuckCache.TypeFields[TypeName].ContainsKey("PuckGeoM")))
{
var parameters = queryText.Split(',', StringSplitOptions.RemoveEmptyEntries);
double longitude;
double latitude;
int distance;
if (parameters.Length == 5 && double.TryParse(parameters[1].Trim(), out longitude) && double.TryParse(parameters[2].Trim(), out latitude) && int.TryParse(parameters[3].Trim(), out distance))
{
var qh = new QueryHelper <T>();
double radius;
if (field == "PuckGeoK")
{
radius = DistanceUtils.EARTH_MEAN_RADIUS_KM;
}
else
{
radius = DistanceUtils.EARTH_MEAN_RADIUS_MI;
}
var distDEG = DistanceUtils.Dist2Degrees(distance, radius);
qh.GeoFilter(parameters[0].Trim(), longitude, latitude, distance);
this.filter = qh.GetFilter();
if (parameters[4] == "asc")
{
qh.SortByDistanceFromPoint(parameters[0].Trim(), longitude, latitude, desc: false);
sort = qh.GetSort();
}
else if (parameters[4] == "desc")
{
qh.SortByDistanceFromPoint(parameters[0].Trim(), longitude, latitude, desc: true);
sort = qh.GetSort();
}
}
}
else
{
Type fieldType = null;
if (FieldTypeMappings != null)
{
if (FieldTypeMappings.TryGetValue(field, out fieldType))
{
}
else
{
PuckCache.TypeFields[TypeName]?.TryGetValue(field, out fieldType);
}
}
else
{
PuckCache.TypeFields[TypeName]?.TryGetValue(field, out fieldType);
}
if (fieldType != null)
{
if (fieldType.Equals(typeof(int)) || fieldType.Equals(typeof(int?)))
{
BytesRef bytes = new BytesRef(NumericUtils.BUF_SIZE_INT32);
NumericUtils.Int32ToPrefixCoded(int.Parse(queryText), 0, bytes);
return(new TermQuery(new Term(field, bytes)));
}
else if (fieldType.Equals(typeof(long)) || fieldType.Equals(typeof(long?)))
{
BytesRef bytes = new BytesRef(NumericUtils.BUF_SIZE_INT64);
NumericUtils.Int64ToPrefixCoded(long.Parse(queryText), 0, bytes);
return(new TermQuery(new Term(field, bytes)));
}
else if (fieldType.Equals(typeof(float)) || fieldType.Equals(typeof(float?)))
{
BytesRef bytes = new BytesRef(NumericUtils.BUF_SIZE_INT32);
int intFloat = NumericUtils.SingleToSortableInt32(float.Parse(queryText));
NumericUtils.Int32ToPrefixCoded(intFloat, 0, bytes);
return(new TermQuery(new Term(field, bytes)));
}
else if (fieldType.Equals(typeof(double)) || fieldType.Equals(typeof(double?)))
{
BytesRef bytes = new BytesRef(NumericUtils.BUF_SIZE_INT64);
long longDouble = NumericUtils.DoubleToSortableInt64(double.Parse(queryText));
NumericUtils.Int64ToPrefixCoded(longDouble, 0, bytes);
return(new TermQuery(new Term(field, bytes)));
}
}
}
}
catch (Exception ex)
{
}
return(base.GetFieldQuery(field, queryText, quoted));
}
