public List<FacetReturn> Filter(Query query, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery)
{
var refinement = new SafeDictionary<string> { { "is facet", "1" } };
int hitsCount;
var facetFields =
Context.ContentDatabase.GetItem(ItemIDs.TemplateRoot)
.Search(refinement, out hitsCount, location: ItemIDs.TemplateRoot.ToString(),
numberOfItemsToReturn: 2000, pageNumber: 1)
.ToList()
.Select((item, sitecoreItem) =>
new
{
FieldId = item.ItemId,
Facet = new Facet(item.Name)
})
.ToList();
facetFields.Sort((f1, f2) => System.String.Compare(f1.Facet.FieldName, f2.Facet.FieldName, System.StringComparison.Ordinal));
var returnFacets = (from facetField in facetFields
from facet in facetField.Facet.GetValues(query, locationFilter, baseQuery).Select(facet => new FacetReturn
{
KeyName = facet.Key,
Value = facet.Value.ToString(),
Type = facetField.Facet.FieldName.ToLower(),
ID = facetField.FieldId + "|" + facet.Key
})
select facet).ToList();
return returnFacets.ToList();
}
public virtual SortCollector GetSortCollector(
SortField[] sort,
Lucene.Net.Search.Query q,
int offset,
int count,
bool fetchStoredFields,
IEnumerable <string> termVectorsToFetch,
bool forceScoring,
string[] groupBy,
int maxPerGroup,
bool collectDocIdCache)
{
return(SortCollector.BuildSortCollector(
this,
q,
sort,
offset,
count,
forceScoring,
fetchStoredFields,
termVectorsToFetch,
groupBy,
maxPerGroup,
collectDocIdCache));
}
public static void CheckHits_(Query query, System.String defaultFieldName, Searcher searcher, int[] results, TestCase testCase)
{
Hits hits = searcher.Search(query);
System.Collections.Hashtable correct = new System.Collections.Hashtable();
for (int i = 0; i < results.Length; i++)
{
correct.Add((System.Int32) results[i], null);
}
System.Collections.Hashtable actual = new System.Collections.Hashtable();
for (int i = 0; i < hits.Length(); i++)
{
actual.Add((System.Int32) hits.Id(i), null);
}
//Assert.AreEqual(correct, actual, query.ToString(defaultFieldName));
if (correct.Count != 0)
{
System.Collections.IDictionaryEnumerator iter = correct.GetEnumerator();
bool status = false;
while (iter.MoveNext())
{
status = actual.ContainsKey(iter.Key);
if (status == false)
break;
}
Assert.IsTrue(status, query.ToString(defaultFieldName));
}
}
private static void Visit(Query query, AzureQueryLogger.IndentedTextWriter writer)
{
writer.WriteLine("Query Type: {0}", (object)query.GetType().FullName);
++writer.Indent;
writer.WriteLine("Boost: {0}", (object)query.Boost);
if (query is BooleanQuery)
AzureQueryLogger.VisitQuery((BooleanQuery)query, writer);
if (query is TermQuery)
AzureQueryLogger.VisitQuery((TermQuery)query, writer);
if (query is PhraseQuery)
AzureQueryLogger.VisitQuery((PhraseQuery)query, writer);
if (query is MultiTermQuery)
AzureQueryLogger.VisitQuery((MultiTermQuery)query, writer);
if (query is MultiPhraseQuery)
AzureQueryLogger.VisitQuery((MultiPhraseQuery)query, writer);
if (query is MatchAllDocsQuery)
AzureQueryLogger.VisitQuery((MatchAllDocsQuery)query, writer);
if (query is FieldScoreQuery)
AzureQueryLogger.VisitQuery((FieldScoreQuery)query, writer);
if (query is ValueSourceQuery)
AzureQueryLogger.VisitQuery((ValueSourceQuery)query, writer);
if (query is CustomScoreQuery)
AzureQueryLogger.VisitQuery((CustomScoreQuery)query, writer);
if (query is FilteredQuery)
AzureQueryLogger.VisitQuery((FilteredQuery)query, writer);
if (query is DisjunctionMaxQuery)
AzureQueryLogger.VisitQuery((DisjunctionMaxQuery)query, writer);
if (query is ConstantScoreQuery)
AzureQueryLogger.VisitQuery((ConstantScoreQuery)query, writer);
if (query is SpanQuery)
AzureQueryLogger.VisitQuery((SpanQuery)query, writer);
--writer.Indent;
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
System.Type type = GetCriteriaClass(criteria);
ISearchFactoryImplementor searchFactory = ContextHelper.GetSearchFactory(GetSession(criteria));
Iesi.Collections.Generic.ISet <System.Type> types;
IndexSearcher searcher = FullTextSearchHelper.BuildSearcher(searchFactory, out types, type);
if (searcher == null)
{
throw new SearchException("Could not find a searcher for class: " + type.FullName);
}
Lucene.Net.Search.Query query = FullTextSearchHelper.FilterQueryByClasses(types, luceneQuery);
Hits hits = searcher.Search(query);
List <object> ids = new List <object>();
for (int i = 0; i < hits.Length(); i++)
{
object id = DocumentBuilder.GetDocumentId(searchFactory, type, hits.Doc(i));
ids.Add(id);
}
base.Values = ids.ToArray();
return(base.ToSqlString(criteria, criteriaQuery, enabledFilters));
}
public TopDocs SearchForQuery(string querytext, out Lucene.Net.Search.Query query, bool toProcess, bool toExpand) // Searches index with query text
{
Stopwatch stopwatch2 = Stopwatch.StartNew();
if (!toProcess)
{
querytext = "\"" + querytext + "\"";
}
else
{
if (toExpand)
{
var standardParser = new QueryParser(VERSION, URL_FN, new StandardAnalyzer(VERSION));
querytext = standardParser.Parse(querytext).ToString().Replace("Url:", "").Replace("Query:", "");
querytext = GetSynonyms(querytext);
}
querytext = querytext.ToLower();
}
if (querytext != string.Empty)
{
query = parser.Parse(querytext);
currentQuery = query;
stopwatch2.Stop();
queryTime = stopwatch2.Elapsed.TotalSeconds.ToString();
finalQuery = query.ToString();
TopDocs results = searcher.Search(query, 100);
return(results);
}
else
{
query = null;
return(null);
}
}
private static Query HandleMethods(Query query)
{
var termQuery = query as TermQuery;
if (termQuery != null && termQuery.Term.Field.StartsWith("@"))
{
return HandleMethodsForQueryAndTerm(query, termQuery.Term);
}
var wildcardQuery = query as WildcardQuery;
if (wildcardQuery != null)
{
return HandleMethodsForQueryAndTerm(query, wildcardQuery.Term);
}
var booleanQuery = query as BooleanQuery;
if (booleanQuery != null)
{
foreach (var c in booleanQuery.Clauses)
{
c.Query = HandleMethods(c.Query);
}
var requiresMerging = booleanQuery.Clauses.All(x => x.Query is IRavenLuceneMethodQuery);
if (requiresMerging == false)
return booleanQuery;
if (booleanQuery.Clauses.Count == 0)
return booleanQuery;
var first = (IRavenLuceneMethodQuery)booleanQuery.Clauses[0].Query;
var ravenLuceneMethodQuery = booleanQuery.Clauses.Skip(1).Aggregate(first, (methodQuery, clause) => methodQuery.Merge(clause.Query));
return (Query)ravenLuceneMethodQuery;
}
return query;
}
private void LogResult(System.String msg, IndexSearcher s, Query q, int doc, float score1)
{
QueryUtils.Check(q, s);
Log(msg + " " + score1);
Log("Explain by: " + q);
Log(s.Explain(q, doc));
}
/// <summary>
/// Gets results that match the given query with a limit applied
/// </summary>
/// <param name="text">Search Query</param>
/// <param name="limit">Result Limit</param>
/// <returns></returns>
public virtual IEnumerable <IFullTextSearchResult> Match(string text, int limit)
{
LucSearch.Query q = this._parser.Parse(text);
LucSearch.TopDocs docs = this._searcher.Search(q, limit);
return(from doc in docs.scoreDocs
select this._searcher.Doc(doc.doc).ToResult(doc.score, this._schema));
}
/// <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;
}
internal SearchResults(Query query, IEnumerable<SortField> sortField, Searcher searcher, int maxResults)
{
LuceneQuery = query;
LuceneSearcher = searcher;
DoSearch(query, sortField, maxResults);
}
private IList<SearchResult> RunQuery(Query query)
{
// If two threads ran this method simultaneously, there would be issues with this.IndexReader.
// Alternatively, there could be one RAMDirectory per filesystem directory.
lock (this)
{
IndexReader newReader = this.indexReader.Reopen();
if (newReader != this.indexReader)
{
this.indexReader.Dispose();
this.indexReader = newReader;
}
IndexSearcher searcher; searcher = new IndexSearcher(newReader);
if (query == null)
{
return new List<SearchResult>();
}
TopDocs hits = searcher.Search(query, 1000);
return hits.ScoreDocs
.Select(scoreDoc => searcher.Doc(scoreDoc.Doc).Get(FullTextFieldType.Path.ToString()))
.Select(path => new SearchResult(path))
.ToList();
}
}
public List<FacetReturn> Filter(Query query, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery)
{
var buckets = new List<SitecoreItem>();
using (var searcher = new IndexSearcher(Constants.Index.Name))
{
if (locationFilter.IsNotEmpty())
{
buckets.AddRange(
searcher.GetItemsViaFieldQuery("isbucket", "1", 200).Value.Where(item => item.GetItem().IsNotNull()).Where(
itm => Context.ContentDatabase.GetItem(locationFilter).Axes.IsAncestorOf(itm.GetItem())));
}
}
var bucketsSelectToList = buckets.OrderBy(i => i.GetItem().Name).Select(item => item.GetItem().ID.ToString()).ToList();
var returnFacets = this.GetSearch(query, bucketsSelectToList, searchQuery, locationFilter, baseQuery).Select(
facet =>
new FacetReturn
{
KeyName = Context.ContentDatabase.GetItem(facet.Key).Name,
Value = facet.Value.ToString(),
Type = "location",
ID = facet.Key
});
return returnFacets.ToList();
}
public override void SetUp()
{
base.SetUp();
INDEX_SIZE = AtLeast(2000);
Index = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), Index);
RandomGen random = new RandomGen(this, Random());
for (int i = 0; i < INDEX_SIZE; ++i) // don't decrease; if to low the
{
// problem doesn't show up
Document doc = new Document();
if ((i % 5) != 0) // some documents must not have an entry in the first
{
// sort field
doc.Add(NewStringField("publicationDate_", random.LuceneDate, Field.Store.YES));
}
if ((i % 7) == 0) // some documents to match the query (see below)
{
doc.Add(NewTextField("content", "test", Field.Store.YES));
}
// every document has a defined 'mandant' field
doc.Add(NewStringField("mandant", Convert.ToString(i % 3), Field.Store.YES));
writer.AddDocument(doc);
}
Reader = writer.Reader;
writer.Dispose();
Query = new TermQuery(new Term("content", "test"));
}
/// <summary>
/// Initializes a new instance of the <see cref="SearchResults" /> class.
/// </summary>
/// <param name="searcher">The searcher.</param>
/// <param name="reader">The reader.</param>
/// <param name="docs">The hits.</param>
/// <param name="criteria">The criteria.</param>
/// <param name="query">The query.</param>
public LuceneSearchResults(Searcher searcher, IndexReader reader, TopDocs docs, ISearchCriteria criteria, Query query)
{
Results = new SearchResults(criteria, null);
CreateDocuments(searcher, docs);
CreateFacets(reader, query);
CreateSuggestions(reader, criteria);
}
private ExplanationResult GetQueryExplanations(ExplanationOptions options, Query luceneQuery, IndexSearcher searcher, ScoreDoc scoreDoc, Document document, global::Lucene.Net.Documents.Document luceneDocument)
{
string key;
var hasGroupKey = options != null && string.IsNullOrWhiteSpace(options.GroupKey) == false;
if (_indexType.IsMapReduce())
{
if (hasGroupKey)
{
key = luceneDocument.Get(options.GroupKey, _state);
if (key == null && document.Data.TryGet(options.GroupKey, out object value))
{
key = value?.ToString();
}
}
else
{
key = luceneDocument.Get(Constants.Documents.Indexing.Fields.ReduceKeyHashFieldName, _state);
}
}
else
{
key = hasGroupKey
? luceneDocument.Get(options.GroupKey, _state)
: document.Id;
}
return(new ExplanationResult
{
Key = key,
Explanation = searcher.Explain(luceneQuery, scoreDoc.Doc, _state)
});
}
private bool IsNoQueryNoFilter(BrowseRequest req)
{
Lucene.Net.Search.Query q = req.Query;
Filter filter = req.Filter;
return((q == null || q is MatchAllDocsQuery) && filter == null && !_reader.HasDeletions);
}
protected virtual Lucene.Net.Search.Query VisitWithinRadius(WithinRadiusNode node, LuceneQueryMapperState mappingState)
{
SpatialContext ctx = SpatialContext.GEO;
var strategy = new PointVectorStrategy(ctx, Sitecore.ContentSearch.Spatial.Common.Constants.LocationFieldName);
if (node.Latitude is double && node.Longitude is double && node.Radius is double)
{
var distance = DistanceUtils.Dist2Degrees((double)node.Radius, DistanceUtils.EARTH_MEAN_RADIUS_MI);
Circle circle = ctx.MakeCircle((double)node.Longitude, (double)node.Latitude, distance);
var spatialArgs = new SpatialArgs(SpatialOperation.IsWithin, circle);
var dq = strategy.MakeQuery(spatialArgs);
DistanceReverseValueSource valueSource = new DistanceReverseValueSource(strategy, circle.GetCenter(), distance);
ValueSourceFilter vsf = new ValueSourceFilter(new QueryWrapperFilter(dq), valueSource, 0, distance);
var filteredSpatial = new FilteredQuery(new MatchAllDocsQuery(), vsf);
mappingState.FilterQuery = filteredSpatial;
Lucene.Net.Search.Query spatialRankingQuery = new FunctionQuery(valueSource);
Random r = new Random(DateTime.Now.Millisecond);
var randomNumber = r.Next(10000101, 11000101);
Lucene.Net.Search.Query dummyQuery = Lucene.Net.Search.NumericRangeQuery.NewIntRange("__smallcreateddate", randomNumber, Int32.Parse(DateTime.Now.ToString("yyyyMMdd")), true, true);
BooleanQuery bq = new BooleanQuery();
bq.Add(filteredSpatial, Occur.MUST);
bq.Add(spatialRankingQuery, Occur.MUST);
bq.Add(dummyQuery, Occur.SHOULD);
return(bq);
}
throw new NotSupportedException("Wrong parameters type, Radius, latitude and longitude must be of type double");
}
/// <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 IEnumerable <LuceneSearchEntry> ExecuteQuery(string indexFolder, LSearch.Query query)
{
var searchIndex = LStore.FSDirectory.Open(indexFolder);
var searchManager = new LSearch.SearcherManager(searchIndex, null);
// try to release locs
searchManager.MaybeRefreshBlocking();
//execute search
var searcher = searchManager.Acquire();
var rawResults = searcher.Search(query, 20);
//convert raw results to model
var outResults = new List <LuceneSearchEntry>();
for (var i = 0; i < rawResults.ScoreDocs.Length; i++)
{
var result = rawResults.ScoreDocs[i];
var doc = searcher.Doc(result.Doc);
outResults.Add(new LuceneSearchEntry
{
Rank = i,
Id = doc.Get("id"),
Uri = doc.Get("uri"),
Title = doc.Get("title"),
Snippet = doc.Get("snippet"),
Score = result.Score
});
}
return(outResults);
}
protected internal override Query GetFieldQuery(string field, string queryText, int slop)
{
if (field == null)
{
IList <BooleanClause> clauses = new List <BooleanClause>();
for (int i = 0; i < fields.Length; i++)
{
Query q = base.GetFieldQuery(fields[i], queryText);
if (q != null)
{
//If the user passes a map of boosts
if (boosts != null)
{
//Get the boost from the map and apply them
Single boost = boosts[fields[i]];
q.Boost = boost;
}
ApplySlop(q, slop);
clauses.Add(new BooleanClause(q, Occur.SHOULD));
}
}
if (clauses.Count == 0)
{
// happens for stopwords
return(null);
}
return(GetBooleanQuery(clauses, true));
}
Query q2 = base.GetFieldQuery(field, queryText);
ApplySlop(q2, slop);
return(q2);
}
public List<int> Get(Query searchQuery)
{
var indexSearcher = _productSearcher.IndexSearcher;
var name = FieldDefinition.GetFieldName<ProductSearchCategoriesDefinition>();
var valueCollector = new ValueCollector(indexSearcher, name);
indexSearcher.Search(searchQuery, valueCollector);
var categoryIds = valueCollector.Values[name].Select(s => Convert.ToInt32(s)).Distinct().ToList();
if (!categoryIds.Any())
return categoryIds;
var mainQuery = new BooleanQuery();
var idsQuery = new BooleanQuery();
const string idFieldName = "id";
foreach (var categoryId in categoryIds)
{
idsQuery.Add(new TermQuery(new Term(idFieldName, categoryId.ToString())), Occur.SHOULD);
}
mainQuery.Add(idsQuery, Occur.MUST);
var publishedOn = FieldDefinition.GetFieldName<PublishedOnFieldDefinition>();
mainQuery.Add(new TermRangeQuery(
publishedOn, null,
DateTools.DateToString(CurrentRequestData.Now, DateTools.Resolution.SECOND), false, true), Occur.MUST);
var webpageSearcher = _indexSearcher.IndexSearcher;
var webpageValueCollector = new ValueCollector(webpageSearcher, idFieldName);
webpageSearcher.Search(mainQuery, null, webpageValueCollector);
return webpageValueCollector.Values[idFieldName].Select(s => Convert.ToInt32(s))
.Intersect(categoryIds)
.ToList();
}
public virtual List<SkinnyItem> RunQuery(Query query, bool showAllVersions)
{
Assert.ArgumentNotNull(Index, "Aqueduct.SitecoreLib");
var items = new List<SkinnyItem>();
try
{
using (var context = new IndexSearchContext(Index))
{
var hits = context.Search(query);
if (hits == null)
{
return null;
}
var resultCollection = hits.FetchResults(0, hits.Length);
SearchHelper.GetItemsFromSearchResult(resultCollection, items, showAllVersions);
}
}
catch (Exception exception)
{
Log.Error("Aqueduct.SitecoreLib. There was a problem while running a search query. Details: " + exception.Message, this);
Log.Error(exception.StackTrace, this);
throw;
}
return items;
}
private TopDocs ExecuteQuery(Query documentQuery, int start, int pageSize, Sort sort)
{
if (sort == null && _indexHasBoostedFields == false && IsBoostedQuery(documentQuery) == false)
{
if (pageSize == int.MaxValue || pageSize >= _searcher.MaxDoc) // we want all docs, no sorting required
{
var gatherAllCollector = new GatherAllCollector(Math.Min(pageSize, _searcher.MaxDoc));
_searcher.Search(documentQuery, gatherAllCollector, _state);
return(gatherAllCollector.ToTopDocs());
}
var noSortingCollector = new NonSortingCollector(Math.Abs(pageSize + start));
_searcher.Search(documentQuery, noSortingCollector, _state);
return(noSortingCollector.ToTopDocs());
}
var minPageSize = GetPageSize(_searcher, (long)pageSize + start);
if (sort != null)
{
_searcher.SetDefaultFieldSortScoring(true, false);
try
{
return(_searcher.Search(documentQuery, null, minPageSize, sort, _state));
}
finally
{
_searcher.SetDefaultFieldSortScoring(false, false);
}
}
return(_searcher.Search(documentQuery, null, minPageSize, _state));
}
public Task <SearchResult> Search(string searchQuery, int skip, int limit, string searchField = "")
{
if (_isRebuilding ||
string.IsNullOrWhiteSpace(searchQuery.Replace("*", string.Empty).Replace("?", string.Empty)))
{
return(new SearchResult(new List <SearchItem>(), 0).AsTask());
}
using var dir = FSDirectory.Open(FileSystemLayout.SearchIndexFolder);
using var reader = DirectoryReader.Open(dir);
var searcher = new IndexSearcher(reader);
int hitsLimit = skip + limit;
using var analyzer = new StandardAnalyzer(AppLuceneVersion);
QueryParser parser = !string.IsNullOrWhiteSpace(searchField)
? new QueryParser(AppLuceneVersion, searchField, analyzer)
: new MultiFieldQueryParser(AppLuceneVersion, new[] { TitleField }, analyzer);
parser.AllowLeadingWildcard = true;
Query query = ParseQuery(searchQuery, parser);
var filter = new DuplicateFilter(TitleAndYearField);
var sort = new Sort(new SortField(SortTitleField, SortFieldType.STRING));
TopFieldDocs topDocs = searcher.Search(query, filter, hitsLimit, sort, true, true);
IEnumerable <ScoreDoc> selectedHits = topDocs.ScoreDocs.Skip(skip).Take(limit);
var searchResult = new SearchResult(
selectedHits.Map(d => ProjectToSearchItem(searcher.Doc(d.Doc))).ToList(),
topDocs.TotalHits);
searchResult.PageMap = GetSearchPageMap(searcher, query, filter, sort, limit);
return(searchResult.AsTask());
}
internal Hits(Searcher s, Query q, Filter f)
{
weight = q.Weight(s);
searcher = s;
filter = f;
GetMoreDocs(50); // retrieve 100 initially
}
/// <summary>
///
/// </summary>
/// <param name="field">The field that should contain terms that are specified in the previous parameter.</param>
/// <param name="fromQuery"></param>
/// <param name="terms">The terms that matching documents should have. The terms must be sorted by natural order.</param>
internal TermsQuery(string field, Query fromQuery, BytesRefHash terms)
: base(field)
{
_fromQuery = fromQuery;
_terms = terms;
_ords = terms.Sort(BytesRef.UTF8SortedAsUnicodeComparer);
}
public static Query MakeQuery(Query existingQuery, SpatialStrategy spatialStrategy, string shapeWKT, SpatialRelation relation,
double distanceErrorPct = 0.025)
{
SpatialOperation spatialOperation;
var shape = ReadShape(shapeWKT);
switch (relation)
{
case SpatialRelation.Within:
spatialOperation = SpatialOperation.IsWithin;
break;
case SpatialRelation.Contains:
spatialOperation = SpatialOperation.Contains;
break;
case SpatialRelation.Disjoint:
spatialOperation = SpatialOperation.IsDisjointTo;
break;
case SpatialRelation.Intersects:
spatialOperation = SpatialOperation.Intersects;
break;
case SpatialRelation.Nearby:
// only sort by this, do not filter
return new FunctionQuery(spatialStrategy.MakeDistanceValueSource(shape.GetCenter()));
default:
throw new ArgumentOutOfRangeException("relation");
}
var args = new SpatialArgs(spatialOperation, shape) { DistErrPct = distanceErrorPct };
if(existingQuery is MatchAllDocsQuery)
return new CustomScoreQuery(spatialStrategy.MakeQuery(args), new ValueSourceQuery(spatialStrategy.MakeRecipDistanceValueSource(shape)));
return spatialStrategy.MakeQuery(args);
}
private static void SearchByFld2(string fld, string txt)
{
string strIndexDir = @"D:\Index";
Analyzer std = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
Lucene.Net.Store.Directory directory = Lucene.Net.Store.FSDirectory.Open(new System.IO.DirectoryInfo(strIndexDir));
Lucene.Net.Search.Searcher srchr =
new Lucene.Net.Search.IndexSearcher(Lucene.Net.Index.IndexReader.Open(directory, true));
var parser = new Lucene.Net.QueryParsers.QueryParser(Lucene.Net.Util.Version.LUCENE_30, fld, std);
Lucene.Net.Search.Query qry = parser.Parse(txt);
var cllctr = srchr.Search(qry, 1000);
Console.WriteLine(cllctr.TotalHits);
ScoreDoc[] hits = cllctr.ScoreDocs;
for (int i = 0; i < hits.Length; i++)
{
int docId = hits[i].Doc;
float score = hits[i].Score;
Lucene.Net.Documents.Document doc = srchr.Doc(docId);
Console.WriteLine("索引时间：" + doc.Get("addtime"));
Console.WriteLine("Searched from Text: " + doc.Get(fld));
}
Console.WriteLine("over");
}
public SearchResult Search(Query searchQuery, int maxHits, string NameField = "Name", Sort sort = null)
{
SearchResult result = new SearchResult();
TopDocs hits = null;
result.SearchResultItems = new List<SearchResultItem>();
if(sort != null)
{
hits = seacher.Search(searchQuery, null, maxHits, sort);
}
else
{
hits = seacher.Search(searchQuery, null, maxHits);
}
for (int i = 0; i < hits.ScoreDocs.Count(); i++)
{
Document doctemp = seacher.Doc(hits.ScoreDocs[i].Doc);
result.SearchResultItems.Add(new SearchResultItem
{
Id = int.Parse(doctemp.Get("Id")),
Name = doctemp.Get(NameField),
Type = (DocumentType) Enum.Parse(typeof(DocumentType), doctemp.Get("Type"))
});
}
result.Hits = hits.ScoreDocs.Count();
return result;
}
private readonly Query match; // query to match
#endregion Fields
#region Constructors
public BoostingQuery(Query match, Query context, float boost)
{
this.match = match;
this.context = (Query) context.Clone(); // clone before boost
this.boost = boost;
this.context.Boost = 0.0f; // ignore context-only matches
}
public virtual Query Visit(Query q)
{
var booleanq = q as BooleanQuery; if (booleanq != null) return VisitBooleanQuery(booleanq);
//var boostingq = q as BoostingQuery; if (boostingq != null) return VisitBoostingQuery(boostingq);
var constantScoreq = q as ConstantScoreQuery; if (constantScoreq != null) return VisitConstantScoreQuery(constantScoreq);
var constantScoreRangeq = q as ConstantScoreRangeQuery; if (constantScoreRangeq != null) return VisitConstantScoreRangeQuery(constantScoreRangeq);
var customScoreq = q as CustomScoreQuery; if (customScoreq != null) return VisitCustomScoreQuery(customScoreq);
var disjunctionMaxq = q as DisjunctionMaxQuery; if (disjunctionMaxq != null) return VisitDisjunctionMaxQuery(disjunctionMaxq);
var filteredq = q as FilteredQuery; if (filteredq != null) return VisitFilteredQuery(filteredq);
//var fuzzyLikeThisq = q as FuzzyLikeThisQuery; if (fuzzyLikeThisq != null) return VisitFuzzyLikeThisQuery(fuzzyLikeThisq);
var matchAllDocsq = q as MatchAllDocsQuery; if (matchAllDocsq != null) return VisitMatchAllDocsQuery(matchAllDocsq);
//var moreLikeThisq = q as MoreLikeThisQuery; if (moreLikeThisq != null) return VisitMoreLikeThisQuery(moreLikeThisq);
var multiPhraseq = q as MultiPhraseQuery; if (multiPhraseq != null) return VisitMultiPhraseQuery(multiPhraseq);
var fuzzyq = q as FuzzyQuery; if (fuzzyq != null) return VisitFuzzyQuery(fuzzyq);
var wildcardq = q as WildcardQuery; if (wildcardq != null) return VisitWildcardQuery(wildcardq);
var phraseq = q as PhraseQuery; if (phraseq != null) return VisitPhraseQuery(phraseq);
var prefixq = q as PrefixQuery; if (prefixq != null) return VisitPrefixQuery(prefixq);
var rangeq = q as RangeQuery; if (rangeq != null) return VisitRangeQuery(rangeq);
var spanFirstq = q as SpanFirstQuery; if (spanFirstq != null) return VisitSpanFirstQuery(spanFirstq);
var spanNearq = q as SpanNearQuery; if (spanNearq != null) return VisitSpanNearQuery(spanNearq);
var spanNotq = q as SpanNotQuery; if (spanNotq != null) return VisitSpanNotQuery(spanNotq);
var spanOrq = q as SpanOrQuery; if (spanOrq != null) return VisitSpanOrQuery(spanOrq);
var spanTermq = q as SpanTermQuery; if (spanTermq != null) return VisitSpanTermQuery(spanTermq);
var termq = q as TermQuery; if (termq != null) return VisitTermQuery(termq);
var valueSourceq = q as ValueSourceQuery; if (valueSourceq != null) return VisitValueSourceQuery(valueSourceq);
var fieldScoreq = q as FieldScoreQuery; if (fieldScoreq != null) return VisitFieldScoreQuery(fieldScoreq);
// <V2.9.2>
var termRangeq = q as TermRangeQuery; if (termRangeq != null) return VisitTermRangeQuery(termRangeq);
var numericRangeq = q as NumericRangeQuery; if (numericRangeq != null) return VisitNumericRangeQuery(numericRangeq);
// </V2.9.2>
throw new NotImplementedException("Unknown query type: " + q.GetType().FullName);
}
public Dictionary<string, int> GetSearch(Query query, List<string> filter, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery)
{
using (var searcher = new IndexSearcher(ItemBucket.Kernel.Util.Constants.Index.Name))
{
var results = searcher.RunFacet(query, false, false, 0, 0, "size", filter, baseQuery, locationFilter);
return results;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LuceneSearcher"/> class.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="indexName">Name of the index.</param>
public LuceneSearcher(Lucene.Net.Search.Query query, string indexName)
{
Assert.ArgumentNotNull(query, "query");
Assert.ArgumentNotNullOrEmpty(indexName, "indexName");
this.query = query;
this.indexName = indexName;
}
/// <summary>
/// Constructs a filter which only matches documents matching
/// <code>query</code>.
/// </summary>
public QueryWrapperFilter(Query query)
{
if (query == null)
{
throw new System.NullReferenceException("Query may not be null");
}
this.Query_Renamed = query;
}
private string GeneratePreviewText(Query q, string text)
{
var scorer = new QueryScorer(q);
Highlighter highlighter = new Highlighter(htmlFormatter, scorer);
highlighter.TextFragmenter = new SimpleFragmenter(250);
TokenStream stream = SearchEnvironment.DefaultAnalyzer.TokenStream("html_content", new StringReader(text));
return highlighter.GetBestFragments(stream, text, 4, "<br/>");
}
internal DocSetIteratorWeight(Query query, Similarity similarity, DocIdSetIterator iter)
{
_query = query;
_similarity = similarity;
_iter = iter;
_queryNorm = 1.0f;
_queryWeight = _query.Boost;
}
public string GetHighlight(string value, IndexSearcher searcher, string highlightField, Query luceneQuery)
{
var scorer = new QueryScorer(luceneQuery.Rewrite(searcher.GetIndexReader()));
var highlighter = new Highlighter(HighlightFormatter, scorer);
var tokenStream = HighlightAnalyzer.TokenStream(highlightField, new StringReader(value));
return highlighter.GetBestFragments(tokenStream, value, MaxNumHighlights, Separator);
}
/// <summary>
/// Given a Lucene Query, this will build the facets and append them to find the Bit comparison of two queries.
/// </summary>
/// <returns>List of FacetReturn</returns>
/// <param name="query">The initial query</param>
/// <param name="filter">The facet filter</param>
/// <param name="searchQuery">The raw search query</param>
/// <param name="locationFilter">The location used to determine which index to use</param>
/// <param name="baseQuery">The initial queries bit array</param>
public Dictionary<string, int> GetSearch(Query query, List<string> filter, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery)
{
using (var searcher = new IndexSearcher(Util.Constants.Index.Name))
{
var results = searcher.RunFacet(query, false, true, 0, 0, "__smallCreatedDate", filter);
return results;
}
}
/// <summary>
/// Decorates the specified query adding context information.
/// </summary>
/// <param name="query">The source query.</param>
/// <returns>The decorated query.</returns>
public Lucene.Net.Search.Query Decorate(Lucene.Net.Search.Query query)
{
BooleanQuery result = new BooleanQuery(true);
result.Add(query, Occur.MUST);
this.AddDecorations(result);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="LuceneSearcher"/> class.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="indexName">Name of the index.</param>
public LuceneSearcher(Lucene.Net.Search.Query query, string indexName)
{
Assert.ArgumentNotNull(query, "query");
Assert.ArgumentNotNullOrEmpty(indexName, "indexName");
this.query = query;
this.indexName = indexName;
}
public void MakesQueriesWithProperPhrasing(string input, Query expected)
{
// arrange, act
var actual = NuGetQuery.MakeQuery(input);
// assert
Assert.Equal(expected, actual);
}
private ToChildBlockJoinQuery(Query origParentQuery, Query parentQuery, Filter parentsFilter, bool doScores)
: base()
{
_origParentQuery = origParentQuery;
_parentQuery = parentQuery;
_parentsFilter = parentsFilter;
_doScores = doScores;
}
public void MakesQueriesSupportingSupportedFields(string input, Query expected)
{
// act
var actual = NuGetQuery.MakeQuery(input);
// assert
Assert.Equal(expected, actual);
}
public static Query MergeQueries(Query queryA, Query queryB, BooleanClause.Occur queryAOccurence, BooleanClause.Occur queryBOccurence)
{
BooleanQuery compoundQuery = new BooleanQuery();
compoundQuery.Add(new BooleanClause(queryA, queryAOccurence));
compoundQuery.Add(new BooleanClause(queryB, queryBOccurence));
return compoundQuery;
}
public List <IndexPageResult> GetDocumentPagesWithQuery(string query)
{
List <IndexPageResult> results = new List <IndexPageResult>();
Dictionary <string, IndexPageResult> fingerprints_already_seen = new Dictionary <string, IndexPageResult>();
try
{
using (IndexReader index_reader = IndexReader.Open(LIBRARY_INDEX_BASE_PATH, true))
{
using (IndexSearcher index_searcher = new IndexSearcher(index_reader))
{
QueryParser query_parser = new QueryParser(Version.LUCENE_29, "content", analyzer);
Lucene.Net.Search.Query query_object = query_parser.Parse(query);
Lucene.Net.Search.Hits hits = index_searcher.Search(query_object);
var i = hits.Iterator();
while (i.MoveNext())
{
Lucene.Net.Search.Hit hit = (Lucene.Net.Search.Hit)i.Current;
string fingerprint = hit.Get("fingerprint");
int page = Convert.ToInt32(hit.Get("page"));
double score = hit.GetScore();
// If this is the first time we have seen this fingerprint, make the top-level record
if (!fingerprints_already_seen.ContainsKey(fingerprint))
{
IndexPageResult result = new IndexPageResult();
result.fingerprint = fingerprint;
result.score = score;
// Add to our structures
results.Add(result);
fingerprints_already_seen[fingerprint] = result;
}
// And add the page record
{
IndexPageResult result = fingerprints_already_seen[fingerprint];
result.page_results.Add(new PageResult {
page = page, score = score
});
}
}
// Close the index
index_searcher.Close();
}
index_reader.Close();
}
}
catch (Exception ex)
{
Logging.Warn(ex, $"GetDocumentPagesWithQuery: There was a problem opening the index file for searching (path: '{LIBRARY_INDEX_BASE_PATH}', query: '{query}')");
}
return(results);
}
/// <summary>
/// classes must be immutable
/// </summary>
public FullTextQueryImpl(Lucene.Net.Search.Query query, System.Type[] classes, ISession session,
ParameterMetadata parameterMetadata)
: base(query.ToString(), FlushMode.Unspecified, session.GetSessionImplementation(), parameterMetadata)
{
luceneQuery = query;
resultSize = -1;
this.classes = classes;
this.filterDefinitions = new Dictionary <string, FullTextFilterImpl>();
}
/// <summary>
/// Gets results that match the given query
/// </summary>
/// <param name="text">Search Query</param>
/// <returns></returns>
public virtual IEnumerable <IFullTextSearchResult> Match(string text)
{
LucSearch.Query q = this._parser.Parse(text);
DocCollector collector = new DocCollector();
this._searcher.Search(q, collector);
return(from doc in collector.Documents
select this._searcher.Doc(doc.Key).ToResult(doc.Value, this._schema));
}
// Test that FieldScoreQuery returns docs with expected score.
private void DoTestCustomScore(System.String field, FieldScoreQuery.Type tp, double dboost)
{
float boost = (float)dboost;
IndexSearcher s = new IndexSearcher(dir, true);
FieldScoreQuery qValSrc = new FieldScoreQuery(field, tp); // a query that would score by the field
QueryParser qp = new QueryParser(Util.Version.LUCENE_CURRENT, TEXT_FIELD, anlzr);
System.String qtxt = "first aid text"; // from the doc texts in FunctionQuerySetup.
// regular (boolean) query.
Query q1 = qp.Parse(qtxt);
Log(q1);
// custom query, that should score the same as q1.
CustomScoreQuery q2CustomNeutral = new CustomScoreQuery(q1);
q2CustomNeutral.Boost = boost;
Log(q2CustomNeutral);
// custom query, that should (by default) multiply the scores of q1 by that of the field
CustomScoreQuery q3CustomMul = new CustomScoreQuery(q1, qValSrc);
q3CustomMul.SetStrict(true);
q3CustomMul.Boost = boost;
Log(q3CustomMul);
// custom query, that should add the scores of q1 to that of the field
CustomScoreQuery q4CustomAdd = new CustomAddQuery(q1, qValSrc);
q4CustomAdd.SetStrict(true);
q4CustomAdd.Boost = boost;
Log(q4CustomAdd);
// custom query, that multiplies and adds the field score to that of q1
CustomScoreQuery q5CustomMulAdd = new CustomMulAddQuery(q1, qValSrc, qValSrc);
q5CustomMulAdd.SetStrict(true);
q5CustomMulAdd.Boost = boost;
Log(q5CustomMulAdd);
// do al the searches
TopDocs td1 = s.Search(q1, null, 1000);
TopDocs td2CustomNeutral = s.Search(q2CustomNeutral, null, 1000);
TopDocs td3CustomMul = s.Search(q3CustomMul, null, 1000);
TopDocs td4CustomAdd = s.Search(q4CustomAdd, null, 1000);
TopDocs td5CustomMulAdd = s.Search(q5CustomMulAdd, null, 1000);
// put results in map so we can verify the scores although they have changed
System.Collections.Hashtable h1 = TopDocsToMap(td1);
System.Collections.Hashtable h2CustomNeutral = TopDocsToMap(td2CustomNeutral);
System.Collections.Hashtable h3CustomMul = TopDocsToMap(td3CustomMul);
System.Collections.Hashtable h4CustomAdd = TopDocsToMap(td4CustomAdd);
System.Collections.Hashtable h5CustomMulAdd = TopDocsToMap(td5CustomMulAdd);
VerifyResults(boost, s, h1, h2CustomNeutral, h3CustomMul, h4CustomAdd, h5CustomMulAdd, q1, q2CustomNeutral, q3CustomMul, q4CustomAdd, q5CustomMulAdd);
}
public void Or(Query left, Query right)
{
if (_operator != OperatorType.Or)
{
ThrowInvalidOperator(OperatorType.Or);
}
AddInternal(left, Occur.SHOULD, OperatorType.Or);
AddInternal(right, Occur.SHOULD, OperatorType.Or);
}
/// <summary>
/// Gets results that match the given query with the score threshold and limit applied
/// </summary>
/// <param name="text">Search Query</param>
/// <param name="scoreThreshold">Score Threshold</param>
/// <param name="limit">Result Limit</param>
/// <returns></returns>
public virtual IEnumerable <IFullTextSearchResult> Match(string text, double scoreThreshold, int limit)
{
this.EnsureCurrent();
LucSearch.Query q = this._parser.Parse(text);
LucSearch.TopDocs docs = this._searcher.Search(q, limit);
return(from doc in docs.ScoreDocs
where doc.Score > scoreThreshold
select this._searcher.Doc(doc.Doc).ToResult(doc.Score, this._schema));
}
public void And(Query left, Query right)
{
if (_operator != OperatorType.And)
{
ThrowInvalidOperator(OperatorType.And);
}
AddInternal(left, Occur.MUST, OperatorType.And);
AddInternal(right, Occur.MUST, OperatorType.And);
}
public bool TryOr(Query right)
{
if (_operator == OperatorType.Or)
{
AddInternal(right, Occur.SHOULD, OperatorType.Or);
return(true);
}
return(false);
}
public void And(Query left, Query right, List <string> buildSteps)
{
if (_operator != OperatorType.And)
{
ThrowInvalidOperator(OperatorType.And);
}
AddInternal(left, Occur.MUST, OperatorType.And, buildSteps);
AddInternal(right, Occur.MUST, OperatorType.And, buildSteps);
}
public bool TryAnd(Query right, List <string> buildSteps)
{
if (_operator == OperatorType.And)
{
AddInternal(right, Occur.MUST, OperatorType.And, buildSteps);
return(true);
}
return(false);
}
public bool TryOr(Query right, List <string> buildSteps)
{
if (_operator == OperatorType.Or)
{
AddInternal(right, Occur.SHOULD, OperatorType.Or, buildSteps);
return(true);
}
return(false);
}
public bool TryAnd(Query right)
{
if (_operator == OperatorType.And)
{
AddInternal(right, Occur.MUST, OperatorType.And);
return(true);
}
return(false);
}
public void Or(Query left, Query right, List <string> buildSteps)
{
if (_operator != OperatorType.Or)
{
ThrowInvalidOperator(OperatorType.Or);
}
AddInternal(left, Occur.SHOULD, OperatorType.Or, buildSteps);
AddInternal(right, Occur.SHOULD, OperatorType.Or, buildSteps);
}
public LuceneBitArray Or(LNS.Query query)
{
collector.Array = this;
searcher.Search(query, null, collector);
if (Debug)
{
Explain(query);
}
return(this);
}
private void ApplySlop(Query q, int slop)
{
if (q is PhraseQuery)
{
((PhraseQuery)q).Slop = slop;
}
else if (q is MultiPhraseQuery)
{
((MultiPhraseQuery)q).Slop = slop;
}
}
