/// <summary>
/// Adds the query.
/// </summary>
/// <param name="fieldName">Name of the field.</param>
/// <param name="query">The query.</param>
/// <param name="filter">The filter.</param>
protected void AddQuery(string fieldName, BooleanQuery query, StringCollection filter)
{
fieldName = fieldName.ToLower();
if (filter.Count > 0)
{
if (filter.Count != 1)
{
var booleanQuery = new BooleanQuery();
var containsFilter = false;
foreach (var index in filter)
{
if (String.IsNullOrEmpty(index))
{
continue;
}
var nodeQuery = new WildcardQuery(new Term(fieldName, index));
booleanQuery.Add(nodeQuery, Occur.SHOULD);
containsFilter = true;
}
if (containsFilter)
{
query.Add(booleanQuery, Occur.MUST);
}
}
else
{
if (!String.IsNullOrEmpty(filter[0]))
{
this.AddQuery(fieldName, query, filter[0].ToLower());
}
}
}
}
public int GetCount(string keyword, string field)
{
int count = 0;
string indexname = ConfigurationManager.AppSettings["CRMIndex"].ToString();
string typename = ConfigurationManager.AppSettings["CRMMemberType"].ToString();
//QueryContainer query = new QueryStringQuery() { Query = keyword, DefaultOperator = Operator.Or, DefaultField = type };
//QueryContainer termQuery = new TermQuery { Field = type, Value = keyword };
if (string.IsNullOrEmpty(field))
{
field = "_all";
}
else
{
field = field.ToLower();
}
//QueryContainer prefixQuery = new PrefixQuery { Field = field, Value = keyword };
//QueryContainer matchQuery = new MatchQuery() { Field = field, Query = keyword, Operator = Operator.And };
QueryContainer wildcardQuery = new WildcardQuery()
{
Field = field, Value = string.Format("*{0}*", keyword)
};
//调用仅取数量方法
var counts = Connect.GetSearchClient().Count <Member>(s => s
.Index(indexname)
.Type(typename)
.Query(wildcardQuery)
);
count = (int)counts.Count;
return(count);
}
public Query CreateQuery(ILuceneQueryService builder, LuceneQueryContext context, string type, JObject query)
{
if (type != "wildcard")
{
return(null);
}
var first = query.Properties().First();
switch (first.Value.Type)
{
case JTokenType.String:
return(new WildcardQuery(new Term(first.Name, first.Value.ToString())));
case JTokenType.Object:
var obj = (JObject)first.Value;
if (!obj.TryGetValue("value", out var value))
{
throw new ArgumentException("Missing value in wildcard query");
}
var wildCardQuery = new WildcardQuery(new Term(value.Value <string>()));
if (obj.TryGetValue("boost", out var boost))
{
wildCardQuery.Boost = boost.Value <float>();
}
return(wildCardQuery);
default: throw new ArgumentException("Invalid wildcard query");
}
}
public virtual void TestTermWithoutWildcard()
{
var indexStore = GetIndexStore("field", new System.String[] { "nowildcard", "nowildcardx" });
IndexSearcher searcher = new IndexSearcher(indexStore, true);
MultiTermQuery wq = new WildcardQuery(new Term("field", "nowildcard"));
AssertMatches(searcher, wq, 1);
wq.RewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
wq.Boost = 0.1f;
Query q = searcher.Rewrite(wq);
Assert.IsTrue(q is TermQuery);
Assert.AreEqual(q.Boost, wq.Boost);
wq.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE;
wq.Boost = 0.2f;
q = searcher.Rewrite(wq);
Assert.IsTrue(q is ConstantScoreQuery);
Assert.AreEqual(q.Boost, wq.Boost);
wq.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
wq.Boost = 0.3F;
q = searcher.Rewrite(wq);
Assert.IsTrue(q is ConstantScoreQuery);
Assert.AreEqual(q.Boost, wq.Boost);
wq.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
wq.Boost = 0.4F;
q = searcher.Rewrite(wq);
Assert.IsTrue(q is ConstantScoreQuery);
Assert.AreEqual(q.Boost, wq.Boost);
}
public virtual void TestAsterisk()
{
var indexStore = GetIndexStore("body", new System.String[] { "metal", "metals" });
IndexSearcher searcher = new IndexSearcher(indexStore, true);
Query query1 = new TermQuery(new Term("body", "metal"));
Query query2 = new WildcardQuery(new Term("body", "metal*"));
Query query3 = new WildcardQuery(new Term("body", "m*tal"));
Query query4 = new WildcardQuery(new Term("body", "m*tal*"));
Query query5 = new WildcardQuery(new Term("body", "m*tals"));
BooleanQuery query6 = new BooleanQuery();
query6.Add(query5, Occur.SHOULD);
BooleanQuery query7 = new BooleanQuery();
query7.Add(query3, Occur.SHOULD);
query7.Add(query5, Occur.SHOULD);
// Queries do not automatically lower-case search terms:
Query query8 = new WildcardQuery(new Term("body", "M*tal*"));
AssertMatches(searcher, query1, 1);
AssertMatches(searcher, query2, 2);
AssertMatches(searcher, query3, 1);
AssertMatches(searcher, query4, 2);
AssertMatches(searcher, query5, 1);
AssertMatches(searcher, query6, 1);
AssertMatches(searcher, query7, 2);
AssertMatches(searcher, query8, 0);
AssertMatches(searcher, new WildcardQuery(new Term("body", "*tall")), 0);
AssertMatches(searcher, new WildcardQuery(new Term("body", "*tal")), 1);
AssertMatches(searcher, new WildcardQuery(new Term("body", "*tal*")), 2);
}
public void TestPrefixTerm()
{
var indexStore = GetIndexStore("field", new String[] { "prefix", "prefixx" });
IndexSearcher searcher = new IndexSearcher(indexStore, true);
MultiTermQuery wq = new WildcardQuery(new Term("field", "prefix*"));
AssertMatches(searcher, wq, 2);
MultiTermQuery expected = new PrefixQuery(new Term("field", "prefix"));
wq.RewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
wq.Boost = 0.1F;
expected.RewriteMethod = wq.RewriteMethod;
expected.Boost = wq.Boost;
Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
wq.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE;
wq.Boost = 0.2F;
expected.RewriteMethod = wq.RewriteMethod;
expected.Boost = wq.Boost;
Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
wq.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT;
wq.Boost = 0.3F;
expected.RewriteMethod = wq.RewriteMethod;
expected.Boost = wq.Boost;
Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
wq.RewriteMethod = MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
wq.Boost = 0.4F;
expected.RewriteMethod = wq.RewriteMethod;
expected.Boost = wq.Boost;
Assert.AreEqual(searcher.Rewrite(expected), searcher.Rewrite(wq));
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
WildcardQuery query = (WildcardQuery)value;
if (query == null)
{
return;
}
/*
* { "wildcard" : { "user" : { "wildcard" : "ki*y", "boost" : 2.0 } } }
*/
writer.WriteStartObject();
writer.WritePropertyName("wildcard");
writer.WriteStartObject();
writer.WritePropertyName(query.Field);
writer.WriteStartObject();
writer.WritePropertyName("wildcard");
writer.WriteValue(query.Value);
if (Math.Abs(query.Boost - Constants.DF_Boost) > 0)
{
writer.WritePropertyName("boost");
writer.WriteValue(query.Boost);
}
writer.WriteEndObject();
writer.WriteEndObject();
writer.WriteEndObject();
}
public override Query VisitWildcardQuery(WildcardQuery wildcardq)
{
var pattern = wildcardq.GetTerm().Text();
if (pattern.Contains("?"))
{
throw new NotSupportedException("Cannot compile WildcardQuery, which contains '?', to SQL expression");
}
if (pattern.StartsWith("*") && pattern.EndsWith("*"))
{
_operators.Push("%LIKE%");
}
else if (pattern.StartsWith("*"))
{
_operators.Push("%LIKE");
}
else if (pattern.EndsWith("*"))
{
_operators.Push("LIKE%");
}
var q = base.VisitWildcardQuery(wildcardq);
_operators.Pop();
return(q);
}
public List <Member> GetList(string keyword, string field, int start, int size)
{
string indexname = ConfigurationManager.AppSettings["CRMIndex"].ToString();
string typename = ConfigurationManager.AppSettings["CRMMemberType"].ToString();
//QueryContainer query = new QueryStringQuery() { Query = keyword, DefaultOperator = Operator.Or, DefaultField = type};
//QueryContainer termQuery = new TermQuery { Field = type, Value = keyword };
if (string.IsNullOrEmpty(field))
{
field = "_all";
}
else
{
field = field.ToLower();
}
//QueryContainer prefixQuery = new PrefixQuery { Field = field, Value = keyword };
//QueryContainer matchQuery = new MatchQuery() { Field = field, Query = keyword, Type = "phrase" };
QueryContainer wildcardQuery = new WildcardQuery()
{
Field = field, Value = string.Format("*{0}*", keyword)
};
var searchResults = Connect.GetSearchClient().Search <Member>(s => s
.Index(indexname)
.Type(typename)
.Query(wildcardQuery)
//.Sort(st => st.OnField(f => f.newsid).Order(SortOrder.Descending)) /*按ID排序，id为数字，排序正常*/
.From(start)
.Size(size)
);
List <Member> eslist = new List <Member>(searchResults.Documents);
return(eslist);
}
/// <summary>
/// Attempt to determine if a given query pattern contains whitespace and
/// the analyzer does not tokenize on whitespace. This is a work-around
/// for cases when QueryParser would split a keyword that contains whitespace
/// into multiple tokens.
/// </summary>
protected virtual bool TryParseKeywordContainingWhitespace(string pattern, out Query query)
{
query = null;
if (pattern.IndexOfAny(new[] { ' ', '\t', '\r', '\n' }) < 0)
{
return(false);
}
var terms = Analyzer.GetTerms(FieldName, pattern).ToList();
if (terms.Count > 1)
{
return(false);
}
var termValue = Unescape(terms.Single());
var term = new Term(FieldName, termValue);
if (IsWildcardPattern(termValue))
{
query = new WildcardQuery(term);
}
else
{
query = new TermQuery(term);
}
return(true);
}
/// <summary>
/// Builds a new <see cref="WildcardQuery"/> instance
/// </summary>
/// <param name="t">wildcard term</param>
/// <returns>new <see cref="WildcardQuery"/> instance</returns>
protected internal virtual Query NewWildcardQuery(Term t)
{
WildcardQuery query = new WildcardQuery(t);
query.MultiTermRewriteMethod = MultiTermRewriteMethod;
return(query);
}
public override Query VisitWildcardQuery(WildcardQuery wildcardq)
{
_text.Append(TermToString(wildcardq.GetTerm()));
_text.Append(BoostToString(wildcardq.GetBoost()));
return(base.VisitWildcardQuery(wildcardq));
}
public static WildcardQuery BuildWildcardQuery(Aliyun.OTS.DataModel.Search.Query.WildcardQuery query)
{
WildcardQuery.Builder builder = WildcardQuery.CreateBuilder();
builder.SetFieldName(query.FieldName);
builder.SetValue(query.Value);
return(builder.Build());
}
public override void TestEscapedWildcard()
{
ICommonQueryParserConfiguration qp = GetParserConfig(new MockAnalyzer(Random, MockTokenizer.WHITESPACE, false));
WildcardQuery q = new WildcardQuery(new Term("field", "foo?ba?r"));//TODO not correct!!
assertEquals(q, GetQuery("foo\\?ba?r", qp));
}
public void InitializerTypedTests()
{
QueryContainer boolQuery =
new WildcardQuery<ElasticsearchProject>(p => p.Name)
{
Value = "value",
Rewrite = RewriteMultiTerm.constant_score_boolean
}
&& new WildcardQuery
{
Field = "my_other_prefix_field",
Value = "value"
};
var searchRequest = new SearchRequest()
{
Query = boolQuery
};
var search = this._client.Search<ElasticsearchProject>(searchRequest);
var request = search.RequestInformation.Request.Utf8String();
request.Should().Contain("name");
request.Should().Contain("my_other_prefix_field");
Assert.Pass(request);
}
internal static WildcardQuery GetLuceneWildcardSearchQuery(String fieldName, String searchPattern)
{
var term = new Term(fieldName, searchPattern);
var query = new WildcardQuery(term);
return(query);
}
public virtual void TestNoSuchMultiTermsInSpanFirst()
{
//this hasn't been a problem
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(fuzzyNoSuch);
SpanQuery spanFirst = new SpanFirstQuery(spanNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(wcNoSuch);
spanFirst = new SpanFirstQuery(spanWCNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(rgxNoSuch);
spanFirst = new SpanFirstQuery(spanRgxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper <MultiTermQuery>(prfxNoSuch);
spanFirst = new SpanFirstQuery(spanPrfxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
}
private static Query ParseQuery(SearchFilter searchFilter)
{
if (String.IsNullOrWhiteSpace(searchFilter.SearchTerm))
{
return(new MatchAllDocsQuery());
}
var fields = new[] { "Id", "Title", "Tags", "Description", "Author" };
var analyzer = new StandardAnalyzer(LuceneCommon.LuceneVersion);
var queryParser = new MultiFieldQueryParser(LuceneCommon.LuceneVersion, fields, analyzer);
// All terms in the multi-term query appear in at least one of the fields.
var conjuctionQuery = new BooleanQuery();
conjuctionQuery.SetBoost(2.0f);
// Some terms in the multi-term query appear in at least one of the fields.
var disjunctionQuery = new BooleanQuery();
disjunctionQuery.SetBoost(0.1f);
// Suffix wildcard search e.g. jquer*
var wildCardQuery = new BooleanQuery();
wildCardQuery.SetBoost(0.5f);
// Escape the entire term we use for exact searches.
var escapedSearchTerm = Escape(searchFilter.SearchTerm);
var exactIdQuery = new TermQuery(new Term("Id-Exact", escapedSearchTerm));
exactIdQuery.SetBoost(2.5f);
var wildCardIdQuery = new WildcardQuery(new Term("Id-Exact", "*" + escapedSearchTerm + "*"));
foreach (var term in GetSearchTerms(searchFilter.SearchTerm))
{
var termQuery = queryParser.Parse(term);
conjuctionQuery.Add(termQuery, BooleanClause.Occur.MUST);
disjunctionQuery.Add(termQuery, BooleanClause.Occur.SHOULD);
foreach (var field in fields)
{
var wildCardTermQuery = new WildcardQuery(new Term(field, term + "*"));
wildCardTermQuery.SetBoost(0.7f);
wildCardQuery.Add(wildCardTermQuery, BooleanClause.Occur.SHOULD);
}
}
// Create an OR of all the queries that we have
var combinedQuery =
conjuctionQuery.Combine(new Query[] { exactIdQuery, wildCardIdQuery, conjuctionQuery, disjunctionQuery, wildCardQuery });
if (searchFilter.SortProperty == SortProperty.Relevance)
{
// If searching by relevance, boost scores by download count.
var downloadCountBooster = new FieldScoreQuery("DownloadCount", FieldScoreQuery.Type.INT);
return(new CustomScoreQuery(combinedQuery, downloadCountBooster));
}
return(combinedQuery);
}
public IEnumerable <SearchResult> GetSearchResults(string queryText, int maxResults = 10)
{
queryText = queryText.ToLower();
using (var directory = FSDirectory.Open(new DirectoryInfo(this.AppSettings.SearchIndexesDirectoryPath)))
{
var reader = DirectoryReader.Open(directory);
var searcher = new IndexSearcher(reader);
var queryParser = new QueryParser(Lucene.Net.Util.LuceneVersion.LUCENE_48, "text", GetAnalyzer());
queryParser.AllowLeadingWildcard = true;
queryParser.DefaultOperator = Operator.AND;
var fullQuery = new BooleanQuery();
//wrap every term so that we do exact match, fuzzy match, and wildcard match
{
var parsedQuery = queryParser.Parse(queryText);
parsedQuery = parsedQuery.Rewrite(reader);
var terms = new HashSet <Term>();
parsedQuery.ExtractTerms(terms);
//for every term, create a boolean query that includes exact match, fuzzy match and wildcard match
foreach (var term in terms)
{
var subquery = new BooleanQuery();
var text = term.Text();
//add the initial term
subquery.Add(new TermQuery(term), Occur.SHOULD);
//TODO - remove permanently if this fixes the search issues
// var fuzzyQuery = new FuzzyQuery(new Term(term.Field, term.Text()));
// fuzzyQuery.Boost = 0.5f;
// subquery.Add(fuzzyQuery, Occur.SHOULD);
var wildQuery = new WildcardQuery(new Term(term.Field, $"*{term.Text()}*"));
wildQuery.Boost = 0.1f;
subquery.Add(wildQuery, Occur.SHOULD);
fullQuery.Add(subquery, Occur.MUST);
}
}
var hits = searcher.Search(fullQuery, maxResults);
var returnValue = new List <SearchResult>();
foreach (var hit in hits.ScoreDocs)
{
var resultDoc = searcher.Doc(hit.Doc);
var id = resultDoc.GetField("id").GetInt32Value().Value;
var searchResult = new SearchResult()
{
MediaItemId = id
};
returnValue.Add(searchResult);
}
return(returnValue);
}
}
public virtual void TestPrefix()
{
WildcardQuery wq = new WildcardQuery(new Term("field", "extrem*"));
SpanQuery swq = new SpanMultiTermQueryWrapper<MultiTermQuery>(wq);
// will only match "jumps over extremely very lazy broxn dog"
SpanFirstQuery sfq = new SpanFirstQuery(swq, 3);
Assert.AreEqual(1, Searcher.Search(sfq, 10).TotalHits);
}
public virtual void TestPrefix()
{
WildcardQuery wq = new WildcardQuery(new Term("field", "extrem*"));
SpanQuery swq = new SpanMultiTermQueryWrapper<MultiTermQuery>(wq);
// will only match "jumps over extremely very lazy broxn dog"
SpanFirstQuery sfq = new SpanFirstQuery(swq, 3);
Assert.AreEqual(1, searcher.Search(sfq, 10).TotalHits);
}
public virtual void TestWildcard()
{
WildcardQuery wq = new WildcardQuery(new Term("field", "bro?n"));
SpanQuery swq = new SpanMultiTermQueryWrapper<MultiTermQuery>(wq);
// will only match quick brown fox
SpanFirstQuery sfq = new SpanFirstQuery(swq, 2);
Assert.AreEqual(1, Searcher.Search(sfq, 10).TotalHits);
}
public virtual void TestWildcard()
{
WildcardQuery wq = new WildcardQuery(new Term("field", "bro?n"));
SpanQuery swq = new SpanMultiTermQueryWrapper<MultiTermQuery>(wq);
// will only match quick brown fox
SpanFirstQuery sfq = new SpanFirstQuery(swq, 2);
Assert.AreEqual(1, searcher.Search(sfq, 10).TotalHits);
}
public List <Hit> GetEmailResults(StringDictionary queryDic)
{
try
{
List <Hit> results = new List <Hit>();
IndexSearcher ids = new IndexSearcher(GlobalData.EmailIndexPath);
//Iterate over all the properties involved in the query
foreach (string property in queryDic.Keys)
{
Query q = null;
#region Based on the property to be indexed, Create the necessary Analyser
switch (property)
{
case "body":
{
q = new QueryParser(property, new KeywordAnalyzer()).Parse(queryDic[property]);
}
break;
case "date":
{
int idx;
string from, to;
idx = queryDic[property].IndexOf(' ');
from = queryDic[property].Substring(0, idx);
to = queryDic[property].Substring(idx + 1);
q = new RangeQuery(new Term(property, from), new Term(property, to), true);
}
break;
default:
if (queryDic[property].Contains("*") || queryDic[property].Contains("?"))
{
q = new WildcardQuery(new Term(property, queryDic[property]));
}
else
{
// PerFieldAnalyzerWrapper pfaw = new PerFieldAnalyzerWrapper();
q = new QueryParser(property, new KeywordAnalyzer()).Parse(queryDic[property]);
}
break;
}
#endregion
//Get the results
Hits hits = ids.Search(q);
foreach (Hit hit in hits)
{
results.Add(hit); //Add the results to a List
}
}
// ids.Close();
return(results);//Return the list
}
catch { return(null); }
}
private int BuildIndexToDocIdMap(IndexReader indexReader, out List <Tuple <int, int> > indexToDocIdMapping)
{
// The problem is, we want to access the list of files given a consecutive file index number, but there are gaps in the doc-ids caused by tag documents
//
// DocId 0 Tag
// DocId 1 File => Index 0
// DocId 2 Tag
// DocId 3 Tag
// DocId 4 File => Index 1
// DocId 5 File => Index 2
// DocId 6 File => Index 3
// DocId 7 Tag
// DocId 8 Tag
// DocId 9 Tag
// DocId 10 File => Index 4
// DocId 11 Tag
// DocId 12 Tag
// ............ => Index 5
// Therfore we construct a list of index to docId tuples, which can be searched using binary search in order to map the index to the corresponding doc id.
indexToDocIdMapping = new List <Tuple <int, int> >();
using (var indexSearcher = new IndexSearcher(indexReader))
{
var tagQuery = new WildcardQuery(new Term(FIELD_TAG, "*"));
var tagDocs = indexSearcher.Search(tagQuery, mIndex.mIndexReader.NumDocs()).ScoreDocs;
if (tagDocs.Length > 0)
{
// Ensure docids are sorted in ascending order, such that they are consecutive too
Array.Sort(tagDocs, (x, y) => x.Doc - y.Doc);
var docId = tagDocs[0].Doc;
int maxGapId = -1;
int baseIndex = 0;
// Sweep and detect gaps...
for (int i = 0; i < tagDocs.Length; ++i)
{
docId = tagDocs[i].Doc;
if (docId - maxGapId > 1)
{
// Gap => emit mapping
indexToDocIdMapping.Add(new Tuple <int, int>(baseIndex, maxGapId + 1));
baseIndex += docId - (maxGapId + 1);
maxGapId = docId;
}
else
{
maxGapId = docId;
}
}
// Emit last mapping
indexToDocIdMapping.Add(new Tuple <int, int>(baseIndex, maxGapId + 1));
}
return(tagDocs.Length);
}
}
private BsonDocument VisitWilcard(WildcardQuery wildcardQuery)
{
var doc = CreateDefaultDoc(wildcardQuery, wildcardQuery.Term);
return(new BsonDocument
{
["wildcard"] = doc
});
}
public override Query VisitWildcardQuery(WildcardQuery wildcardq)
{
_dump.Append("WildcardQ(");
var q = base.VisitWildcardQuery(wildcardq);
_dump.Append(BoostToString(q));
_dump.Append(")");
return(q);
}
public override Query VisitWildcardQuery(WildcardQuery wildcardq)
{
#pragma warning disable CS0618 // Type or member is obsolete
_text.Append(TermToString(wildcardq.GetTerm()));
#pragma warning restore CS0618 // Type or member is obsolete
_text.Append(BoostToString(wildcardq.GetBoost()));
return(base.VisitWildcardQuery(wildcardq));
}
public static void WildcardQueryTest(Analyzer analyzer, string field, string keyword)
{
Console.WriteLine("====WildcardQuery====");
WildcardQuery query = new WildcardQuery(new Term(field, keyword));
ShowQueryExpression(analyzer, query, keyword);
SearchToShow(query);
Console.WriteLine();
}
public virtual Query VisitWildcardQuery(WildcardQuery wildcardq)
{
#pragma warning disable CS0618 // Type or member is obsolete
var term = wildcardq.GetTerm();
#pragma warning restore CS0618 // Type or member is obsolete
var visited = VisitTerm(term);
if (term == visited)
return wildcardq;
return new WildcardQuery(visited);
}
private ParameterizedSql BuildWildcard(WildcardQuery wildcardQuery)
{
Term term = CopyTerm(wildcardQuery.Term);
if (term != null)
{
return(BuildQuery(new WildcardQuery(term)));
}
return(null);
}
public virtual Query VisitWildcardQuery(WildcardQuery wildcardq)
{
var term = wildcardq.GetTerm();
var visited = VisitTerm(term);
if (term == visited)
{
return(wildcardq);
}
return(new WildcardQuery(visited));
}
public void TestConstantSocreWithWildQuery()
{
var query = new WildcardQuery("name","张*");
var constanQuery = new ConstantScoreQuery(query);
var result = client.Search(index, "type" , constanQuery, 0, 5);
Assert.AreEqual(3, result.GetTotalCount());
Assert.AreEqual(3, result.GetHits().Hits.Count);
}
public void Export_Omits_Field_If_Not_Provided()
{
var query = new WildcardQuery("wildcard");
var expected = JsonConvert.SerializeObject(new
{
wildcard = "wildcard"
}, Formatting.None);
Assert.Equal(expected, query.Export().ToString(Formatting.None));
}
public void TestWildcards()
{
Directory dir = NewDirectory();
// use simpleanalyzer for more natural tokenization (else "test." is a token)
Analyzer analyzer = new MockAnalyzer(Random, MockTokenizer.SIMPLE, true);
IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
iwc.SetMergePolicy(NewLogMergePolicy());
RandomIndexWriter iw = new RandomIndexWriter(Random, dir, iwc);
FieldType offsetsType = new FieldType(TextField.TYPE_STORED);
offsetsType.IndexOptions = (IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS);
Field body = new Field("body", "", offsetsType);
Document doc = new Document();
doc.Add(body);
body.SetStringValue("This is a test.");
iw.AddDocument(doc);
body.SetStringValue("Test a one sentence document.");
iw.AddDocument(doc);
IndexReader ir = iw.GetReader();
iw.Dispose();
IndexSearcher searcher = NewSearcher(ir);
ICUPostingsHighlighter highlighter = new PostingsHighlighterAnalyzerHelper(analyzer);
Query query = new WildcardQuery(new Term("body", "te*"));
TopDocs topDocs = searcher.Search(query, null, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.TotalHits);
String[] snippets = highlighter.Highlight("body", query, searcher, topDocs);
assertEquals(2, snippets.Length);
assertEquals("This is a <b>test</b>.", snippets[0]);
assertEquals("<b>Test</b> a one sentence document.", snippets[1]);
// wrong field
BooleanQuery bq = new BooleanQuery();
bq.Add(new MatchAllDocsQuery(), Occur.SHOULD);
bq.Add(new WildcardQuery(new Term("bogus", "te*")), Occur.SHOULD);
topDocs = searcher.Search(bq, null, 10, Sort.INDEXORDER);
assertEquals(2, topDocs.TotalHits);
snippets = highlighter.Highlight("body", bq, searcher, topDocs);
assertEquals(2, snippets.Length);
assertEquals("This is a test.", snippets[0]);
assertEquals("Test a one sentence document.", snippets[1]);
ir.Dispose();
dir.Dispose();
}
public void InitializerTests()
{
QueryContainer wildcardQuery = new WildcardQuery
{
Field = "my_prefix_field",
Value = "value",
Rewrite = RewriteMultiTerm.ConstantScoreBoolean
};
var searchRequest = new SearchRequest()
{
Query = wildcardQuery
};
var search = this._client.Search<ElasticsearchProject>(searchRequest);
var request = search.RequestInformation.Request.Utf8String();
request.Should().Contain("my_prefix_field");
Assert.Pass(request);
}
public int GetCount(string keyword,string field)
{
int count = 0;
string indexname = ConfigurationManager.AppSettings["CRMIndex"].ToString();
string typename = ConfigurationManager.AppSettings["CRMMemberType"].ToString();
//QueryContainer query = new QueryStringQuery() { Query = keyword, DefaultOperator = Operator.Or, DefaultField = type };
//QueryContainer termQuery = new TermQuery { Field = type, Value = keyword };
if (string.IsNullOrEmpty(field))
{ field = "_all"; }
else { field = field.ToLower(); }
//QueryContainer prefixQuery = new PrefixQuery { Field = field, Value = keyword };
//QueryContainer matchQuery = new MatchQuery() { Field = field, Query = keyword, Operator = Operator.And };
QueryContainer wildcardQuery = new WildcardQuery() { Field = field, Value = string.Format("*{0}*", keyword) };
//调用仅取数量方法
var counts = Connect.GetSearchClient().Count<Member>(s => s
.Index(indexname)
.Type(typename)
.Query(wildcardQuery)
);
count = (int)counts.Count;
return count;
}
public int GetCountByM(SearchCondition sc)
{
int count = 0;
string indexname = ConfigurationManager.AppSettings["CRMIndex"].ToString();
string typename = ConfigurationManager.AppSettings["CRMMemberType"].ToString();
string field = "";
if (string.IsNullOrEmpty(sc.field))
{ field = ""; }
else { field = sc.field.ToLower(); }
string classVaule = "";
if (string.IsNullOrEmpty(sc.classx))
{
sc.classx = "";
}
else
{
sc.classx = sc.classx.ToLower();
classVaule = "1";
}
//must
List<QueryContainer> mustquerys = new List<QueryContainer>();
if (field.Equals("lastcontacttime"))
{
string timeG = sc.keywords[0];
string timeL = DateTime.Parse(timeG).AddDays(-7).ToString("yyyy-MM-dd");
QueryContainer rangeQuyery = new RangeQuery() { Field = field, GreaterThanOrEqualTo = timeL, LowerThanOrEqualTo = timeG, TimeZone = "+08:00" };
mustquerys.Add(rangeQuyery);
}
else if (field.Equals("enterprise"))
{
foreach (string keyw in sc.keywords)
{
List<QueryContainer> shouooo = new List<QueryContainer>();
QueryContainer termQ = new TermQuery() { Field = "enterprise", Value = sc.keyword.Replace(',', ' ') };
QueryContainer lowerQuery = new WildcardQuery() { Field = "enterprise", Value = string.IsNullOrEmpty(keyw) ? "*" : string.Format("*{0}*", keyw.ToLower()) };
QueryContainer notlowerQuery = new WildcardQuery() { Field = "enterprise.lower", Value = string.IsNullOrEmpty(keyw) ? "*" : string.Format("*{0}*", keyw.ToLower()) };
shouooo.Add(termQ);
shouooo.Add(lowerQuery);
shouooo.Add(notlowerQuery);
QueryContainer boooQuery = new BoolQuery() { Should = shouooo };
mustquerys.Add(boooQuery);
}
}
else
{
foreach (string keyw in sc.keywords)
{
QueryContainer wildcardQuery = new WildcardQuery() { Field = field, Value = string.IsNullOrEmpty(keyw) ? "*" : string.Format("*{0}*", keyw) };
mustquerys.Add(wildcardQuery);
}
}
QueryContainer matchQueryT = new MatchQuery() { Field = "tracktypeid", Query = Convert.ToString(sc.tracktype) };
QueryContainer matchQueryC = new MatchQuery() { Field = sc.classx, Query = classVaule };
QueryContainer queryCountry = new WildcardQuery() { Field = "country", Value = string.Format("*{0}*", sc.country) };
QueryContainer queryProvince = new WildcardQuery() { Field = "province", Value = string.Format("*{0}*", sc.province) };
QueryContainer queryCity = new WildcardQuery() { Field = "city", Value = string.Format("*{0}*", sc.city) };
if (!string.IsNullOrEmpty(sc.tracktype))
{
mustquerys.Add(matchQueryT);
}
if (!string.IsNullOrEmpty(sc.classx))
{
mustquerys.Add(matchQueryC);
}
if (!string.IsNullOrEmpty(sc.country))
{
mustquerys.Add(queryCountry);
}
if (!string.IsNullOrEmpty(sc.province))
{
mustquerys.Add(queryProvince);
}
if (!string.IsNullOrEmpty(sc.city))
{
mustquerys.Add(queryCity);
}
QueryContainer boolQuery = new BoolQuery() { Must = mustquerys };
//QueryContainer wildcardQuery = new WildcardQuery() { Field = field, Value = string.IsNullOrEmpty(sc.keyword) ? "*" : string.Format("*{0}*", sc.keyword) };
var searchResults = Connect.GetSearchClient().Count<Member>(s => s
.Index(indexname)
.Type(typename)
.Query(boolQuery)
);
count = (int)searchResults.Count;
return count;
}
static IEnumerable<WildcardQuery> BuildWildCardQueries(IndexSearcher aSearcher, string[] aTerms, Int64 aSize, bool aShowOfflineBots, int aStart, int aLimit)
{
var queries = new List<WildcardQuery>();
int count = 0;
int missing = aLimit;
foreach (string term in aTerms)
{
var query = BuildQuery(term, aSize, aShowOfflineBots);
var total = GetTotalResults(aSearcher, query);
if (total > 0)
{
var wq = new WildcardQuery { Enabled = true, Query = query, Term = term, Total = total };
if (count + total <= aStart || missing == 0)
{
wq.Enabled = false;
}
else
{
wq.Start = aStart > count ? aStart - count : 0;
if (wq.Total - wq.Start >= missing)
{
wq.Limit = missing;
missing = 0;
}
else
{
wq.Limit = wq.Total - wq.Start;
missing -= wq.Limit;
}
}
queries.Add(wq);
count += wq.Total;
}
}
return queries;
}
public SpanMultiQuery(WildcardQuery query)
{
_query = query;
}
/// <summary>
/// WEBAPI使用方法，直接获取Member
/// </summary>
/// <param name="sc"></param>
/// <param name="em"></param>
/// <returns></returns>
public string GetMember(SearchCondition sc, out int em)
{
string indexname = ConfigurationManager.AppSettings["CRMIndex"].ToString();
string typename = ConfigurationManager.AppSettings["CRMMemberType"].ToString();
string field = "";
if (string.IsNullOrEmpty(sc.field))
{ field = ""; }
else { field = sc.field.ToLower(); }
string classVaule = "";
if (string.IsNullOrEmpty(sc.classx))
{
sc.classx = "";
}
else
{
sc.classx = sc.classx.ToLower();
classVaule = "1";
}
//must
List<QueryContainer> mustquerys = new List<QueryContainer>();
if (field.Equals("lastcontacttime"))
{
string timeG = sc.keywords[0];
string timeL = DateTime.Parse(timeG).AddDays(-7).ToString("yyyy-MM-dd");
QueryContainer rangeQuyery = new RangeQuery() { Field = field, GreaterThanOrEqualTo = timeL, LowerThanOrEqualTo = timeG, TimeZone = "+08:00" };
mustquerys.Add(rangeQuyery);
}
else if (field.Equals("enterprise"))
{
foreach (string keyw in sc.keywords)
{
List<QueryContainer> shouooo = new List<QueryContainer>();
QueryContainer termQ = new TermQuery() { Field = "enterprise", Value = sc.keyword.Replace(',', ' ') };
QueryContainer lowerQuery = new WildcardQuery() { Field = "enterprise", Value = string.IsNullOrEmpty(keyw) ? "*" : string.Format("*{0}*", keyw.ToLower()) };
QueryContainer notlowerQuery = new WildcardQuery() { Field = "enterprise.lower", Value = string.IsNullOrEmpty(keyw) ? "*" : string.Format("*{0}*", keyw.ToLower()) };
shouooo.Add(termQ);
shouooo.Add(lowerQuery);
shouooo.Add(notlowerQuery);
QueryContainer boooQuery = new BoolQuery() { Should = shouooo };
mustquerys.Add(boooQuery);
}
}
else
{
foreach (string keyw in sc.keywords)
{
QueryContainer wildcardQuery = new WildcardQuery() { Field = field, Value = string.IsNullOrEmpty(keyw) ? "*" : string.Format("*{0}*", keyw) };
mustquerys.Add(wildcardQuery);
}
}
QueryContainer matchQueryT = new MatchQuery() { Field = "tracktypeid", Query = Convert.ToString(sc.tracktype) };
QueryContainer matchQueryC = new MatchQuery() { Field = sc.classx, Query = classVaule };
QueryContainer queryCountry = new WildcardQuery() { Field = "country", Value = string.Format("*{0}*", sc.country) };
QueryContainer queryProvince = new WildcardQuery() { Field = "province", Value = string.Format("*{0}*", sc.province) };
QueryContainer queryCity = new WildcardQuery() { Field = "city", Value = string.Format("*{0}*", sc.city) };
if (!string.IsNullOrEmpty(sc.tracktype))
{
mustquerys.Add(matchQueryT);
}
if (!string.IsNullOrEmpty(sc.classx))
{
mustquerys.Add(matchQueryC);
}
if (!string.IsNullOrEmpty(sc.country))
{
mustquerys.Add(queryCountry);
}
if (!string.IsNullOrEmpty(sc.province))
{
mustquerys.Add(queryProvince);
}
if (!string.IsNullOrEmpty(sc.city))
{
mustquerys.Add(queryCity);
}
QueryContainer boolQuery = new BoolQuery() { Must = mustquerys };
var searchResults = Connect.GetSearchClient().Search<Member>(s => s
.Index(indexname)
.Type(typename)
.Fields(f => f.Id, f => f.Enterprise, f => f.Isstar, f => f.Masterlinkman, f => f.Tracktypeid, f => f.Sourceid, f => f.Lastcontacttime, f => f.Enddate, f => f.Adminname, f => f.Addtime)
.Query(boolQuery)
.Sort(st => st.OnField(f => f.Lastcontacttime).Order(SortOrder.Descending)) /*排序*/
.From(sc.start)
.Size(sc.size)
);
em = searchResults.ElapsedMilliseconds;
StringBuilder ResultJson = new StringBuilder("");
ResultJson.Append("[");
foreach (var hit in searchResults.Hits)
{
ResultJson.Append("{");
ResultJson.Append(
String.Join(",",
hit.Fields.FieldValuesDictionary
.Select(FVD => "'" + FVD.Key + "':'" + FVD.Value.ToString().Replace("[", "").Replace("]", "") + "'")
.ToArray()
)
);
ResultJson.Append("},");
}
if (ResultJson.Length > 1)
ResultJson.Length = ResultJson.Length - 1;
ResultJson.Append("]");
return ResultJson.ToString();
}
/// <summary>
/// Adds the query.
/// </summary>
/// <param name="fieldName">Name of the field.</param>
/// <param name="query">The query.</param>
/// <param name="filter">The filter.</param>
protected void AddQuery(string fieldName, BooleanQuery query, string filter)
{
fieldName = fieldName.ToLower();
var nodeQuery = new WildcardQuery(new Term(fieldName, filter.ToLower()));
query.Add(nodeQuery, Occur.MUST);
}
public List<Member> GetList(string keyword, string field, int start, int size)
{
string indexname = ConfigurationManager.AppSettings["CRMIndex"].ToString();
string typename = ConfigurationManager.AppSettings["CRMMemberType"].ToString();
//QueryContainer query = new QueryStringQuery() { Query = keyword, DefaultOperator = Operator.Or, DefaultField = type};
//QueryContainer termQuery = new TermQuery { Field = type, Value = keyword };
if (string.IsNullOrEmpty(field))
{ field = "_all"; }
else { field = field.ToLower(); }
//QueryContainer prefixQuery = new PrefixQuery { Field = field, Value = keyword };
//QueryContainer matchQuery = new MatchQuery() { Field = field, Query = keyword, Type = "phrase" };
QueryContainer wildcardQuery = new WildcardQuery() {Field = field ,Value = string.Format("*{0}*", keyword) };
var searchResults = Connect.GetSearchClient().Search<Member>(s => s
.Index(indexname)
.Type(typename)
.Query(wildcardQuery)
//.Sort(st => st.OnField(f => f.newsid).Order(SortOrder.Descending)) /*按ID排序，id为数字，排序正常*/
.From(start)
.Size(size)
);
List<Member> eslist = new List<Member>(searchResults.Documents);
return eslist;
}
public void TestFilterdQuery()
{
var termQuery = new TermQuery("type", "common");
var termFilter = new TermFilter("age", "24");
var filteredQuery = new FilteredQuery(termQuery,termFilter);
var result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(1, result2.GetTotalCount());
Assert.AreEqual(1, result2.GetHits().Hits.Count);
var wildQuery = new WildcardQuery("name", "张三*");
termFilter = new TermFilter("age", "23");
filteredQuery = new FilteredQuery(wildQuery, termFilter);
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(1, result2.GetTotalCount());
Assert.AreEqual(1, result2.GetHits().Hits.Count);
Assert.AreEqual("张三丰",result2.GetHits().Hits[0].Source["name"]);
var boolQuery = new BoolQuery();
boolQuery.Must(new TermQuery("type", "common"));
boolQuery.Must(new WildcardQuery("name", "张三*"));
boolQuery.Should(new TermQuery("age", 24));
filteredQuery=new FilteredQuery(boolQuery,new TermFilter("age","23"));
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(1, result2.GetTotalCount());
Assert.AreEqual(1, result2.GetHits().Hits.Count);
Assert.AreEqual("张三丰", result2.GetHits().Hits[0].Source["name"]);
filteredQuery = new FilteredQuery(boolQuery, new TermFilter("age", "24"));
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(1, result2.GetTotalCount());
Assert.AreEqual(1, result2.GetHits().Hits.Count);
Assert.AreEqual("张三", result2.GetHits().Hits[0].Source["name"]);
filteredQuery = new FilteredQuery(boolQuery, new TermFilter("type", "common"));
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(2, result2.GetTotalCount());
Assert.AreEqual(2, result2.GetHits().Hits.Count);
//test should
boolQuery = new BoolQuery();
boolQuery.Must(new TermQuery("type", "common"));
boolQuery.Must(new WildcardQuery("name", "张*"));
boolQuery.Should(new TermQuery("age", 24));
filteredQuery = new FilteredQuery(boolQuery, new TermFilter("type", "common"));
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(3, result2.GetTotalCount());
Assert.AreEqual(3, result2.GetHits().Hits.Count);
boolQuery = new BoolQuery();
boolQuery.Must(new TermQuery("type", "common"));
boolQuery.Must(new WildcardQuery("name", "张*"));
boolQuery.Should(new TermQuery("age", 24));
boolQuery.Should(new TermQuery("age", 28));
boolQuery.Should(new TermQuery("age", 22));
//must+should ->[should] make nonsense
filteredQuery = new FilteredQuery(boolQuery, new TermFilter("type", "common"));
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(3, result2.GetTotalCount());
Assert.AreEqual(3, result2.GetHits().Hits.Count);
boolQuery = new BoolQuery();
boolQuery.Should(new TermQuery("age", 24));
boolQuery.Should(new TermQuery("age", 28));
boolQuery.Should(new TermQuery("age", 22));
filteredQuery = new FilteredQuery(boolQuery, new TermFilter("type", "common"));
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(1, result2.GetTotalCount());
Assert.AreEqual(1, result2.GetHits().Hits.Count);
Assert.AreEqual("张三", result2.GetHits().Hits[0].Source["name"]);
boolQuery.Should(new TermQuery("age", 25));
filteredQuery = new FilteredQuery(boolQuery, new TermFilter("type", "common"));
result2 = client.Search(index, "type" , filteredQuery, 0, 5);
Assert.AreEqual(2, result2.GetTotalCount());
Assert.AreEqual(2, result2.GetHits().Hits.Count);
}
public virtual void TestNoSuchMultiTermsInOr()
{
//test to make sure non existent multiterms aren't throwing null pointer exceptions
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(fuzzyNoSuch);
SpanQuery term = new SpanTermQuery(new Term("field", "brown"));
SpanOrQuery near = new SpanOrQuery(new SpanQuery[] { term, spanNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
//flip
near = new SpanOrQuery(new SpanQuery[] { spanNoSuch, term });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(wcNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanWCNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(rgxNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanRgxNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(prfxNoSuch);
near = new SpanOrQuery(new SpanQuery[] { term, spanPrfxNoSuch });
Assert.AreEqual(1, Searcher.Search(near, 10).TotalHits);
near = new SpanOrQuery(new SpanQuery[] { spanPrfxNoSuch });
Assert.AreEqual(0, Searcher.Search(near, 10).TotalHits);
near = new SpanOrQuery(new SpanQuery[] { spanPrfxNoSuch, spanPrfxNoSuch });
Assert.AreEqual(0, Searcher.Search(near, 10).TotalHits);
}
public void TestWildcardQuery()
{
var query = new WildcardQuery("name","张*");
var result = client.Search(index, "type" , query, 0, 5);
Assert.AreEqual(3, result.GetTotalCount());
Assert.AreEqual(3, result.GetHits().Hits.Count);
foreach (var VARIABLE in result.GetHits().Hits)
{
Console.WriteLine(VARIABLE.Source["name"]);
}
Console.WriteLine("--");
query = new WildcardQuery("name", "张三*");
result = client.Search(index, "type" , query, 0, 5);
Assert.AreEqual(2, result.GetTotalCount());
Assert.AreEqual(2, result.GetHits().Hits.Count);
foreach (var VARIABLE in result.GetHits().Hits)
{
Console.WriteLine(VARIABLE.Source["name"]);
}
}
public virtual void TestNoSuchMultiTermsInSpanFirst()
{
//this hasn't been a problem
FuzzyQuery fuzzyNoSuch = new FuzzyQuery(new Term("field", "noSuch"), 1, 0, 1, false);
SpanQuery spanNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(fuzzyNoSuch);
SpanQuery spanFirst = new SpanFirstQuery(spanNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
WildcardQuery wcNoSuch = new WildcardQuery(new Term("field", "noSuch*"));
SpanQuery spanWCNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(wcNoSuch);
spanFirst = new SpanFirstQuery(spanWCNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
RegexpQuery rgxNoSuch = new RegexpQuery(new Term("field", "noSuch"));
SpanQuery spanRgxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(rgxNoSuch);
spanFirst = new SpanFirstQuery(spanRgxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
PrefixQuery prfxNoSuch = new PrefixQuery(new Term("field", "noSuch"));
SpanQuery spanPrfxNoSuch = new SpanMultiTermQueryWrapper<MultiTermQuery>(prfxNoSuch);
spanFirst = new SpanFirstQuery(spanPrfxNoSuch, 10);
Assert.AreEqual(0, Searcher.Search(spanFirst, 10).TotalHits);
}
/// <summary>
/// Adds a wildcard clause to this instance
/// </summary>
/// <remarks>Wildcard clauses include '*' and '?' character</remarks>
/// <param name="term">Term to add to this query</param>
/// <param name="occurrence">Defines how the term is added to this query</param>
public void AddWildcardClause(SearchTerm term, ClauseOccurrence occurrence)
{
if (term == null)
throw new ArgumentNullException("term", "term cannot be null");
IncrementTotalClauses(1);
WildcardQuery wildcardQuery = new WildcardQuery(term.GetLuceneTerm());
wildcardQuery.SetBoost(term.Boost);
this.luceneQuery.Add(wildcardQuery, TypeConverter.ConvertToLuceneClauseOccurrence(occurrence));
wildcardQuery = null;
}
