public void AndExtension()
{
BooleanQuery originalQuery = new BooleanQuery();
BooleanQuery innerQuery = new BooleanQuery();
Term term = new Term("_name", "value1");
TermQuery termQuery1 = new TermQuery(term);
innerQuery.Add(termQuery1, Occur.MUST);
Term term2 = new Term("_name", "value2");
TermQuery termQuery2 = new TermQuery(term2);
innerQuery.Add(termQuery2, Occur.MUST);
originalQuery.Add(innerQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.And
(
x => x.Term("_name", "value1"),
x => x.Term("_name", "value2")
);
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public virtual void TestEmptyPhraseQuery()
{
BooleanQuery q2 = new BooleanQuery();
q2.Add(new PhraseQuery(), Occur.MUST);
q2.ToString();
}
public void TestQuery()
{
BooleanQuery booleanQuery=new BooleanQuery();
booleanQuery.Add(new TermQuery(new Term("name","medcl")),BooleanClause.Occur.MUST);
booleanQuery.Add(new TermQuery(new Term("age","25")),BooleanClause.Occur.MUST);
new ElasticSearch.Client.ElasticSearchClient("localhost").Search("index", "type", booleanQuery.ToString());
}
public virtual void TestBooleanOptionalWithTiebreaker()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.SHOULD); // false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.SHOULD); // false,false);
}
QueryUtils.Check(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score0 = h[0].Score;
float score1 = h[1].Score;
float score2 = h[2].Score;
float score3 = h[3].Score;
string doc0 = s.Doc(h[0].Doc).Get("id");
string doc1 = s.Doc(h[1].Doc).Get("id");
string doc2 = s.Doc(h[2].Doc).Get("id");
string doc3 = s.Doc(h[3].Doc).Get("id");
Assert.IsTrue(doc0.Equals("d2", StringComparison.Ordinal) || doc0.Equals("d4", StringComparison.Ordinal), "doc0 should be d2 or d4: " + doc0);
Assert.IsTrue(doc1.Equals("d2", StringComparison.Ordinal) || doc1.Equals("d4", StringComparison.Ordinal), "doc1 should be d2 or d4: " + doc0);
Assert.AreEqual(score0, score1, SCORE_COMP_THRESH, "score0 and score1 should match");
Assert.AreEqual("d3", doc2, "wrong third");
Assert.IsTrue(score1 > score2, "d3 does not have worse score then d2 and d4: " + score1 + " >? " + score2);
Assert.AreEqual("d1", doc3, "wrong fourth");
Assert.IsTrue(score2 > score3, "d1 does not have worse score then d3: " + score2 + " >? " + score3);
}
catch (Exception e) when(e.IsError())
{
PrintHits("testBooleanOptionalWithTiebreaker", h, s);
throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details)
}
}
public virtual void TestBooleanOptionalWithTiebreakerAndBoost()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
q1.Add(Tq("hed", "albino", 1.5f));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.SHOULD); // false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
q2.Add(Tq("hed", "elephant", 1.5f));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.SHOULD); // false,false);
}
QueryUtils.Check(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score0 = h[0].Score;
float score1 = h[1].Score;
float score2 = h[2].Score;
float score3 = h[3].Score;
string doc0 = s.Doc(h[0].Doc).Get("id");
string doc1 = s.Doc(h[1].Doc).Get("id");
string doc2 = s.Doc(h[2].Doc).Get("id");
string doc3 = s.Doc(h[3].Doc).Get("id");
Assert.AreEqual("d4", doc0, "doc0 should be d4: ");
Assert.AreEqual("d3", doc1, "doc1 should be d3: ");
Assert.AreEqual("d2", doc2, "doc2 should be d2: ");
Assert.AreEqual("d1", doc3, "doc3 should be d1: ");
Assert.IsTrue(score0 > score1, "d4 does not have a better score then d3: " + score0 + " >? " + score1);
Assert.IsTrue(score1 > score2, "d3 does not have a better score then d2: " + score1 + " >? " + score2);
Assert.IsTrue(score2 > score3, "d3 does not have a better score then d1: " + score2 + " >? " + score3);
}
catch (Exception /*e*/)
{
PrintHits("TestBooleanOptionalWithTiebreakerAndBoost", h, s);
throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details)
}
}
public virtual void TestBooleanOptionalWithTiebreaker()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.SHOULD); //false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.SHOULD); //false,false);
}
QueryUtils.Check(q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score0 = h[0].Score;
float score1 = h[1].Score;
float score2 = h[2].Score;
float score3 = h[3].Score;
System.String doc0 = s.Doc(h[0].Doc).Get("id");
System.String doc1 = s.Doc(h[1].Doc).Get("id");
System.String doc2 = s.Doc(h[2].Doc).Get("id");
System.String doc3 = s.Doc(h[3].Doc).Get("id");
Assert.IsTrue(doc0.Equals("d2") || doc0.Equals("d4"), "doc0 should be d2 or d4: " + doc0);
Assert.IsTrue(doc1.Equals("d2") || doc1.Equals("d4"), "doc1 should be d2 or d4: " + doc0);
Assert.AreEqual(score0, score1, SCORE_COMP_THRESH, "score0 and score1 should match");
Assert.AreEqual("d3", doc2, "wrong third");
Assert.IsTrue(score1 > score2, "d3 does not have worse score then d2 and d4: " + score1 + " >? " + score2);
Assert.AreEqual("d1", doc3, "wrong fourth");
Assert.IsTrue(score2 > score3, "d1 does not have worse score then d3: " + score2 + " >? " + score3);
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanOptionalWithTiebreaker", h, s);
throw e;
}
}
public virtual void TestBooleanOptionalWithTiebreakerAndBoost()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
q1.Add(Tq("hed", "albino", 1.5f));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.SHOULD); //false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
q2.Add(Tq("hed", "elephant", 1.5f));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.SHOULD); //false,false);
}
QueryUtils.Check(q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score0 = h[0].Score;
float score1 = h[1].Score;
float score2 = h[2].Score;
float score3 = h[3].Score;
System.String doc0 = s.Doc(h[0].Doc).Get("id");
System.String doc1 = s.Doc(h[1].Doc).Get("id");
System.String doc2 = s.Doc(h[2].Doc).Get("id");
System.String doc3 = s.Doc(h[3].Doc).Get("id");
Assert.AreEqual("d4", doc0, "doc0 should be d4: ");
Assert.AreEqual("d3", doc1, "doc1 should be d3: ");
Assert.AreEqual("d2", doc2, "doc2 should be d2: ");
Assert.AreEqual("d1", doc3, "doc3 should be d1: ");
Assert.IsTrue(score0 > score1, "d4 does not have a better score then d3: " + score0 + " >? " + score1);
Assert.IsTrue(score1 > score2, "d3 does not have a better score then d2: " + score1 + " >? " + score2);
Assert.IsTrue(score2 > score3, "d3 does not have a better score then d1: " + score2 + " >? " + score3);
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanOptionalWithTiebreakerAndBoost", h, s);
throw e;
}
}
public virtual void TestBooleanRequiredEqualScores()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.MUST); // true,false);
QueryUtils.Check(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, q1, s);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.MUST); // true,false);
QueryUtils.Check(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, q2, s);
}
QueryUtils.Check(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(3, h.Length, "3 docs should match " + q.ToString());
float score = h[0].Score;
for (int i = 1; i < h.Length; i++)
{
Assert.AreEqual(score, h[i].Score, SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
}
catch (Exception e) when(e.IsError())
{
PrintHits("testBooleanRequiredEqualScores1", h, s);
throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details)
}
}
public void CaseInsensitiveMandatoryTerm()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.MUST);
string queryString = originalQuery.ToString();
// LuceneQueryable luceneQueryable = new LuceneQueryable();
//var items = luceneQueryable.Where(x => x.Term("_name", "Value"));
//Query replacementQuery = luceneQueryable.Build();
//string newQueryString = replacementQuery.ToString();
//Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void BoostedCaseInsensitiveMandatoryTerm()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.MUST);
termQuery.Boost = 10;
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.Term("_name", "Value", boost:10));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void AddLuceneApiQuery()
{
// shows you can add regular lucene queries to lucinq
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
TermQuery termQuery2 = new TermQuery(term);
builder.Add(termQuery2, Matches.Always);
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public virtual void TestBooleanOptionalNoTiebreaker()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.SHOULD); // false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.SHOULD); // false,false);
}
QueryUtils.Check(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score = h[0].Score;
for (int i = 1; i < h.Length - 1; i++) // note: -1
{
Assert.AreEqual(score, h[i].Score, SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
Assert.AreEqual("d1", s.Doc(h[h.Length - 1].Doc).Get("id"), "wrong last");
float score1 = h[h.Length - 1].Score;
Assert.IsTrue(score > score1, "d1 does not have worse score then others: " + score + " >? " + score1);
}
catch (Exception e) when(e.IsError())
{
PrintHits("testBooleanOptionalNoTiebreaker", h, s);
throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details)
}
}
public virtual void TestBooleanOptionalNoTiebreaker()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.SHOULD); //false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.SHOULD); //false,false);
}
QueryUtils.Check(q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score = h[0].Score;
for (int i = 1; i < h.Length - 1; i++)
{
/* note: -1 */
Assert.AreEqual(score, h[i].Score, SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
Assert.AreEqual("d1", s.Doc(h[h.Length - 1].Doc).Get("id"), "wrong last");
float score1 = h[h.Length - 1].Score;
Assert.IsTrue(score > score1, "d1 does not have worse score then others: " + score + " >? " + score1);
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanOptionalNoTiebreaker", h, s);
throw e;
}
}
public virtual void TestBooleanRequiredEqualScores()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, Occur.MUST); //true,false);
QueryUtils.Check(q1, s);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, Occur.MUST); //true,false);
QueryUtils.Check(q2, s);
}
QueryUtils.Check(q, s);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(3, h.Length, "3 docs should match " + q.ToString());
float score = h[0].Score;
for (int i = 1; i < h.Length; i++)
{
Assert.AreEqual(score, h[i].Score, SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanRequiredEqualScores1", h, s);
throw e;
}
}
public void LongRange()
{
BooleanQuery originalQuery = new BooleanQuery();
NumericRangeQuery<long> numericRangeQuery = NumericRangeQuery.NewLongRange("field", 1, 0L, 10L, true, true);
originalQuery.Add(numericRangeQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.NumericRange("field", 0L, 10L));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void IntegerRange()
{
BooleanQuery originalQuery = new BooleanQuery();
NumericRangeQuery numericRangeQuery = NumericRangeQuery.NewIntRange("field", 1, 0, 10, true, true);
originalQuery.Add(numericRangeQuery, BooleanClause.Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.NumericRange("field", 0, 10));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void CompositeTermPhraseWildcardTests()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.MUST);
PhraseQuery phraseQuery = new PhraseQuery();
Term phraseTerm = new Term("_name", "phrase");
phraseQuery.Slop = 2;
phraseQuery.Add(phraseTerm);
originalQuery.Add(phraseQuery, Occur.MUST);
Term wildcardTerm = new Term("_name", "*wildcard*");
WildcardQuery wildcardQuery = new WildcardQuery(wildcardTerm);
originalQuery.Add(wildcardQuery, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup
(
x => x.Term("_name", "value"),
x => x.Phrase(2).AddTerm("_name", "phrase"),
x => x.WildCard("_name", "*wildcard*", Matches.Sometimes)
);
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public virtual void TestBooleanOptionalNoTiebreaker()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, BooleanClause.Occur.SHOULD); // false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, BooleanClause.Occur.SHOULD); // false,false);
}
QueryUtils.Check(Random(), q, s, Similarity);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score = h[0].Score;
for (int i = 1; i < h.Length - 1; i++) // note: -1
{
Assert.AreEqual(score, h[i].Score, SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
Assert.AreEqual("d1", s.Doc(h[h.Length - 1].Doc).Get("id"), "wrong last");
float score1 = h[h.Length - 1].Score;
Assert.IsTrue(score > score1, "d1 does not have worse score then others: " + score + " >? " + score1);
}
catch (Exception e)
{
PrintHits("testBooleanOptionalNoTiebreaker", h, s);
throw e;
}
}
public void BoostedCaseInsensitivePhrase()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
PhraseQuery phraseQuery = new PhraseQuery();
phraseQuery.Slop = 2;
phraseQuery.Add(term);
phraseQuery.Boost = 10;
originalQuery.Add(phraseQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.Phrase(2, 10).AddTerm("_name", "Value"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public virtual void TestEmptyPhraseQuery()
{
BooleanQuery q2 = new BooleanQuery();
q2.Add(new PhraseQuery(), Occur.MUST);
q2.ToString();
}
public void QueryCaseSensitiveTermRange()
{
BooleanQuery originalQuery = new BooleanQuery();
TermRangeQuery termRangeQuery = new TermRangeQuery("field", "Lower", "Upper", true, true);
originalQuery.Add(termRangeQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{CaseSensitive = true};
builder.Setup(x => x.TermRange("field", "Lower", "Upper"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public virtual void TestBooleanOptionalWithTiebreaker()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, BooleanClause.Occur.SHOULD); //false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, BooleanClause.Occur.SHOULD); //false,false);
}
QueryUtils.Check(q, s);
Hits h = s.Search(q);
try
{
Assert.AreEqual(4, h.Length(), "4 docs should match " + q.ToString());
float score0 = h.Score(0);
float score1 = h.Score(1);
float score2 = h.Score(2);
float score3 = h.Score(3);
System.String doc0 = h.Doc(0).Get("id");
System.String doc1 = h.Doc(1).Get("id");
System.String doc2 = h.Doc(2).Get("id");
System.String doc3 = h.Doc(3).Get("id");
Assert.IsTrue(doc0.Equals("d2") || doc0.Equals("d4"), "doc0 should be d2 or d4: " + doc0);
Assert.IsTrue(doc1.Equals("d2") || doc1.Equals("d4"), "doc1 should be d2 or d4: " + doc0);
Assert.AreEqual(score0, score1, SCORE_COMP_THRESH, "score0 and score1 should match");
Assert.AreEqual("d3", doc2, "wrong third");
Assert.IsTrue(score1 > score2, "d3 does not have worse score then d2 and d4: " + score1 + " >? " + score2);
Assert.AreEqual("d1", doc3, "wrong fourth");
Assert.IsTrue(score2 > score3, "d1 does not have worse score then d3: " + score2 + " >? " + score3);
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanOptionalWithTiebreaker", h);
throw e;
}
}
private void DoTest(Random random, PrintWriter @out, bool useCompoundFiles, int MAX_DOCS)
{
Directory directory = newDirectory();
Analyzer analyzer = new MockAnalyzer(random);
IndexWriterConfig conf = newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
MergePolicy mp = conf.MergePolicy;
mp.NoCFSRatio = useCompoundFiles ? 1.0 : 0.0;
IndexWriter writer = new IndexWriter(directory, conf);
if (VERBOSE)
{
Console.WriteLine("TEST: now build index MAX_DOCS=" + MAX_DOCS);
}
for (int j = 0; j < MAX_DOCS; j++)
{
Document d = new Document();
d.Add(newTextField(PRIORITY_FIELD, HIGH_PRIORITY, Field.Store.YES));
d.Add(newTextField(ID_FIELD, Convert.ToString(j), Field.Store.YES));
writer.addDocument(d);
}
writer.Dispose();
// try a search without OR
IndexReader reader = DirectoryReader.Open(directory);
IndexSearcher searcher = newSearcher(reader);
Query query = new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY));
@out.println("Query: " + query.ToString(PRIORITY_FIELD));
if (VERBOSE)
{
Console.WriteLine("TEST: search query=" + query);
}
Sort sort = new Sort(SortField.FIELD_SCORE, new SortField(ID_FIELD, SortField.Type.INT));
ScoreDoc[] hits = searcher.Search(query, null, MAX_DOCS, sort).scoreDocs;
PrintHits(@out, hits, searcher);
CheckHits(hits, MAX_DOCS, searcher);
// try a new search with OR
searcher = newSearcher(reader);
hits = null;
BooleanQuery booleanQuery = new BooleanQuery();
booleanQuery.Add(new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY)), BooleanClause.Occur_e.SHOULD);
booleanQuery.Add(new TermQuery(new Term(PRIORITY_FIELD, MED_PRIORITY)), BooleanClause.Occur_e.SHOULD);
@out.println("Query: " + booleanQuery.ToString(PRIORITY_FIELD));
hits = searcher.search(booleanQuery, null, MAX_DOCS, sort).scoreDocs;
PrintHits(@out, hits, searcher);
CheckHits(hits, MAX_DOCS, searcher);
reader.Close();
directory.Close();
}
public virtual void TestBooleanOptionalNoTiebreaker()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, BooleanClause.Occur.SHOULD); //false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, BooleanClause.Occur.SHOULD); //false,false);
}
QueryUtils.Check(q, s);
Hits h = s.Search(q);
try
{
Assert.AreEqual(4, h.Length(), "4 docs should match " + q.ToString());
float score = h.Score(0);
for (int i = 1; i < h.Length() - 1; i++)
{
/* note: -1 */
Assert.AreEqual(score, h.Score(i), SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
Assert.AreEqual("d1", h.Doc(h.Length() - 1).Get("id"), "wrong last");
float score1 = h.Score(h.Length() - 1);
Assert.IsTrue(score > score1, "d1 does not have worse score then others: " + score + " >? " + score1);
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanOptionalNoTiebreaker", h);
throw e;
}
}
public virtual void TestBooleanRequiredEqualScores()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, BooleanClause.Occur.MUST); //false,false);
QueryUtils.Check(q1, s);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, BooleanClause.Occur.MUST); //false,false);
QueryUtils.Check(q2, s);
}
QueryUtils.Check(q, s);
Hits h = s.Search(q);
try
{
Assert.AreEqual(3, h.Length(), "3 docs should match " + q.ToString());
float score = h.Score(0);
for (int i = 1; i < h.Length(); i++)
{
Assert.AreEqual(score, h.Score(i), SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanRequiredEqualScores1", h);
throw e;
}
}
public virtual void TestBooleanOptionalWithTiebreakerAndBoost()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
q1.Add(Tq("hed", "albino", 1.5f));
q1.Add(Tq("dek", "albino"));
q.Add(q1, BooleanClause.Occur.SHOULD); // false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
q2.Add(Tq("hed", "elephant", 1.5f));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, BooleanClause.Occur.SHOULD); // false,false);
}
QueryUtils.Check(Random(), q, s, Similarity);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(4, h.Length, "4 docs should match " + q.ToString());
float score0 = h[0].Score;
float score1 = h[1].Score;
float score2 = h[2].Score;
float score3 = h[3].Score;
string doc0 = s.Doc(h[0].Doc).Get("id");
string doc1 = s.Doc(h[1].Doc).Get("id");
string doc2 = s.Doc(h[2].Doc).Get("id");
string doc3 = s.Doc(h[3].Doc).Get("id");
Assert.AreEqual("d4", doc0, "doc0 should be d4: ");
Assert.AreEqual("d3", doc1, "doc1 should be d3: ");
Assert.AreEqual("d2", doc2, "doc2 should be d2: ");
Assert.AreEqual("d1", doc3, "doc3 should be d1: ");
Assert.IsTrue(score0 > score1, "d4 does not have a better score then d3: " + score0 + " >? " + score1);
Assert.IsTrue(score1 > score2, "d3 does not have a better score then d2: " + score1 + " >? " + score2);
Assert.IsTrue(score2 > score3, "d3 does not have a better score then d1: " + score2 + " >? " + score3);
}
catch (Exception e)
{
PrintHits("TestBooleanOptionalWithTiebreakerAndBoost", h, s);
throw e;
}
}
public void Or()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value1");
TermQuery termQuery1 = new TermQuery(term);
originalQuery.Add(termQuery1, Occur.SHOULD);
Term term2 = new Term("_name", "value2");
TermQuery termQuery2 = new TermQuery(term2);
originalQuery.Add(termQuery2, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{DefaultChildrenOccur = Matches.Sometimes};
builder.Setup
(
x => x.Term("_name", "value1"),
x => x.Term("_name", "value2")
);
Query replacementQuery1 = builder.Build();
string newQueryString1 = replacementQuery1.ToString();
Assert.AreEqual(queryString, newQueryString1);
QueryBuilder builder2 = new QueryBuilder();
builder2.Setup
(
x => x.Term("_name", "value1", Matches.Sometimes),
x => x.Term("_name", "value2", Matches.Sometimes)
);
Query replacementQuery2 = builder2.Build();
string newQueryString2 = replacementQuery2.ToString();
Assert.AreEqual(queryString, newQueryString2);
QueryBuilder builder3 = new QueryBuilder();
builder3.Setup
(
x => x.Term("_name", "value1"),
x => x.Term("_name", "value2")
);
Query replacementQuery3 = builder3.Build();
string newQueryString3 = replacementQuery3.ToString();
Assert.AreNotEqual(queryString, newQueryString3);
Console.Write(queryString);
}
static void Test3()
{
string q = "hello world";
/*
Query query = LuceneQueryCreator.Parse(q, false);
Console.WriteLine(query.ToString());
Query q2 = (new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "Title", new PackageAnalyzer())).Parse(query.ToString());
QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "Title", new PackageAnalyzer());
Query q3 = parser.Parse("(a:x a:y) (b:x b:y)");
Query q4 = new TermQuery(new Lucene.Net.Index.Term("a", "x"));
var clause = new BooleanClause(new TermQuery(new Lucene.Net.Index.Term("a", "x")), Occur.SHOULD);
*/
BooleanQuery query = new BooleanQuery();
BooleanQuery sub1 = new BooleanQuery();
sub1.Add(new TermQuery(new Term("a", "x1 x2 x3")) { Boost = 1.0f }, Occur.MUST);
sub1.Add(new TermQuery(new Term("a", "y")) { Boost = 1.0f }, Occur.MUST);
sub1.Boost = 2.0f;
BooleanQuery sub2 = new BooleanQuery();
sub2.Add(new TermQuery(new Term("b", "x")) { Boost = 1.0f }, Occur.SHOULD);
sub2.Add(new TermQuery(new Term("b", "y")) { Boost = 1.0f }, Occur.SHOULD);
query.Add(sub1, Occur.SHOULD);
query.Add(sub2, Occur.SHOULD);
string s = query.ToString();
QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "Title", new PackageAnalyzer());
Query q2 = parser.Parse(s);
Console.WriteLine(s);
}
public void QueryCaseSensitiveMandatoryWildCard()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "Value*");
WildcardQuery wildcardQuery = new WildcardQuery(term);
originalQuery.Add(wildcardQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{CaseSensitive = true};
builder.Setup(x => x.WildCard("_name", "Value*"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public virtual void TestRandomQueries()
{
System.Random rnd = NewRandom();
System.String field = "data";
System.String[] vals = new System.String[] { "1", "2", "3", "4", "5", "6", "A", "Z", "B", "Y", "Z", "X", "foo" };
int maxLev = 4;
// callback object to set a random setMinimumNumberShouldMatch
TestBoolean2.Callback minNrCB = new AnonymousClassCallback(rnd, this);
// increase number of iterations for more complete testing
for (int i = 0; i < 1000; i++)
{
int lev = rnd.Next(maxLev);
long seed = rnd.Next(System.Int32.MaxValue);
BooleanQuery q1 = TestBoolean2.RandBoolQuery(new System.Random((System.Int32)seed), lev, field, vals, null);
// BooleanQuery q2 = TestBoolean2.randBoolQuery(new Random(seed), lev, field, vals, minNrCB);
BooleanQuery q2 = TestBoolean2.RandBoolQuery(new System.Random((System.Int32)seed), lev, field, vals, null);
// only set minimumNumberShouldMatch on the top level query since setting
// at a lower level can change the score.
minNrCB.PostCreate(q2);
// Can't use Hits because normalized scores will mess things
// up. The non-sorting version of search() that returns TopDocs
// will not normalize scores.
TopDocs top1 = s.Search(q1, null, 100);
TopDocs top2 = s.Search(q2, null, 100);
QueryUtils.Check(q1, s);
QueryUtils.Check(q2, s);
// The constrained query
// should be a superset to the unconstrained query.
if (top2.TotalHits > top1.TotalHits)
{
//TestCase.fail("Constrained results not a subset:\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
Assert.Fail("Constrained results not a subset:\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
}
for (int hit = 0; hit < top2.TotalHits; hit++)
{
int id = top2.ScoreDocs[hit].doc;
float score = top2.ScoreDocs[hit].score;
bool found = false;
// find this doc in other hits
for (int other = 0; other < top1.TotalHits; other++)
{
if (top1.ScoreDocs[other].doc == id)
{
found = true;
float otherScore = top1.ScoreDocs[other].score;
// check if scores match
if (System.Math.Abs(otherScore - score) > 1.0e-6f)
{
//TestCase.fail("Doc " + id + " scores don't match\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
Assert.Fail("Doc " + id + " scores don't match\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
}
}
}
// check if subset
if (!found)
{
//TestCase.fail("Doc " + id + " not found\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
Assert.Fail("Doc " + id + " not found\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
}
}
}
// System.out.println("Total hits:"+tot);
}
//Main search algorithm
public IEnumerable<Result> Search(string fieldName, string searchTerm)
{
DocType docType = DocType.SONG;
Query mainQuery;
switch(fieldName)
{
case F_ARTIST:
docType=DocType.ARTIST;
break;
case F_ALBUM:
docType=DocType.ALBUM;
break;
case F_GENRE:
docType=DocType.GENRE;
break;
}
IndexSearcher searcher = new IndexSearcher(luceneIndexDirectory);
BooleanQuery booleanQuery = new BooleanQuery();
QueryParser qp = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, fieldName, analyzer);
try
{
mainQuery = qp.Parse(searchTerm);
}
catch (ParseException e)
{
console.Log(e.Message);
return null;
}
Query DocTypeQuery = new TermQuery(new Term(F_DOCTYPE, docType.ToString()));
booleanQuery.Add(mainQuery, Occur.MUST);
booleanQuery.Add(DocTypeQuery, Occur.MUST);
console.Log("query: " + booleanQuery.ToString());
TopDocs hitsFound = searcher.Search(booleanQuery , Int32.MaxValue);
List<Result> results = new List<Result>();
Result sampleResult = null;
for (int i = 0; i < hitsFound.TotalHits; i++)
{
sampleResult = new Result();
Document doc = searcher.Doc(hitsFound.ScoreDocs[i].Doc);
//key moment
fillResult(sampleResult, fieldName, doc);
float score = hitsFound.ScoreDocs[i].Score;
sampleResult.Score = score;
results.Add(sampleResult);
}
return results.OrderByDescending(x => x.Score).ToList();
}
public void CaseSensitiveNonMandatoryKeyword()
{
QueryBuilder builder = new QueryBuilder();
BooleanQuery originalQuery = new BooleanQuery();
QueryParser rawQueryParser = new QueryParser(Version.LUCENE_29, "_name", builder.KeywordAnalyzer);
originalQuery.Add(rawQueryParser.Parse("Value"), Occur.SHOULD);
string queryString = originalQuery.ToString();
builder.Setup(x => x.Keyword("_name", "Value", Matches.Sometimes, caseSensitive: true));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public static IEnumerable<BaseItem> Search(string searchQuery, int maxHits)
{
var results = new List<BaseItem>();
lock (lockOb)
{
try
{
if (searcher == null)
{
searcher = new IndexSearcher(directory, true);
}
BooleanQuery finalQuery = new BooleanQuery();
MultiFieldQueryParser parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, new string[] { "Name", "Overview" }, analyzer, bonusTerms);
string[] terms = searchQuery.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string term in terms)
finalQuery.Add(parser.Parse(term.Replace("~", "") + "~0.75"), Occur.SHOULD);
foreach (string term in terms)
finalQuery.Add(parser.Parse(term.Replace("*", "") + "*"), Occur.SHOULD);
logger.Debug("Querying Lucene with query: " + finalQuery.ToString());
long start = DateTime.Now.Ticks;
var searchResult = searcher.Search(finalQuery, maxHits);
foreach (var searchHit in searchResult.ScoreDocs)
{
Document hit = searcher.Doc(searchHit.Doc);
results.Add(BaseItem.LibraryManager.GetItemById(Guid.Parse(hit.Get("Id"))));
}
long total = DateTime.Now.Ticks - start;
float msTotal = (float)total / TimeSpan.TicksPerMillisecond;
logger.Debug(searchResult.ScoreDocs.Length + " result" + (searchResult.ScoreDocs.Length == 1 ? "" : "s") + " in " + msTotal + " ms.");
}
catch (Exception e)
{
logger.ErrorException("Error while searching Lucene index", e);
}
}
return results;
}
public void CaseSensitiveNonMandatoryTerm()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "Value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.Term("_name", "Value", Matches.Sometimes, caseSensitive: true));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public virtual void TestBooleanOptionalWithTiebreakerAndBoost()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
q1.Add(Tq("hed", "albino", 1.5f));
q1.Add(Tq("dek", "albino"));
q.Add(q1, BooleanClause.Occur.SHOULD); //false,false);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
q2.Add(Tq("hed", "elephant", 1.5f));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, BooleanClause.Occur.SHOULD); //false,false);
}
QueryUtils.Check(q, s);
Hits h = s.Search(q);
try
{
Assert.AreEqual(4, h.Length(), "4 docs should match " + q.ToString());
float score0 = h.Score(0);
float score1 = h.Score(1);
float score2 = h.Score(2);
float score3 = h.Score(3);
System.String doc0 = h.Doc(0).Get("id");
System.String doc1 = h.Doc(1).Get("id");
System.String doc2 = h.Doc(2).Get("id");
System.String doc3 = h.Doc(3).Get("id");
Assert.AreEqual("d4", doc0, "doc0 should be d4: ");
Assert.AreEqual("d3", doc1, "doc1 should be d3: ");
Assert.AreEqual("d2", doc2, "doc2 should be d2: ");
Assert.AreEqual("d1", doc3, "doc3 should be d1: ");
Assert.IsTrue(score0 > score1, "d4 does not have a better score then d3: " + score0 + " >? " + score1);
Assert.IsTrue(score1 > score2, "d3 does not have a better score then d2: " + score1 + " >? " + score2);
Assert.IsTrue(score2 > score3, "d3 does not have a better score then d1: " + score2 + " >? " + score3);
}
catch (System.ApplicationException e)
{
PrintHits("testBooleanOptionalWithTiebreakerAndBoost", h);
throw e;
}
}
public virtual void TestBooleanRequiredEqualScores()
{
BooleanQuery q = new BooleanQuery();
{
DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
q1.Add(Tq("hed", "albino"));
q1.Add(Tq("dek", "albino"));
q.Add(q1, BooleanClause.Occur.MUST); // true,false);
QueryUtils.Check(Random(), q1, s, Similarity);
}
{
DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
q2.Add(Tq("hed", "elephant"));
q2.Add(Tq("dek", "elephant"));
q.Add(q2, BooleanClause.Occur.MUST); // true,false);
QueryUtils.Check(Random(), q2, s, Similarity);
}
QueryUtils.Check(Random(), q, s, Similarity);
ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
try
{
Assert.AreEqual(3, h.Length, "3 docs should match " + q.ToString());
float score = h[0].Score;
for (int i = 1; i < h.Length; i++)
{
Assert.AreEqual(score, h[i].Score, SCORE_COMP_THRESH, "score #" + i + " is not the same");
}
}
catch (Exception e)
{
PrintHits("testBooleanRequiredEqualScores1", h, s);
throw e;
}
}
private void btnSearch_Click(object sender, EventArgs e)
{
lstResults.Items.Clear();
searcher = new IndexSearcher(new RAMDirectory(_indexTarget));
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer());
analyzer.AddAnalyzer("ayat_arabic", new DiacriticAnalyzer(FilterData.stopWords));
//MyQueryParser parser = new MyQueryParser(new string[] { "ayat_desc", "ayat_urdu", "ayat_arabic" }, analyzer);
//parser.SetDefaultOperator(QueryParser.Operator.AND);
//Query q = parser.Parse(txtSearch.Text);
//Query q = new TermQuery(new Term("ayatno", NumberTools.LongToString(long.Parse(txtSearch.Text))));
BooleanQuery q = new BooleanQuery();
long l1 = 1; long l2 = 500; long l3 = 1; long l4 = 1;
//RangeQuery rq = new RangeQuery(new Term("ayatno", l1.ToString("00000")), new Term("ayatno", l2.ToString("00000")), true);
//q.Add(rq, true, false);
q.Add(new TermQuery(new Term("sid", l3.ToString("00000"))), true, false);
q.Add(new TermQuery(new Term("ayatno", l4.ToString("00000"))), true, false);
MessageBox.Show(q.ToString());
Sort sort = new Sort(new string[] { "pid", "sid", "ayatno" });
hits = searcher.Search(q, sort);
lblHits.Text = hits.Length() + " hit(s).";
Application.DoEvents();
for (int i = 0; i < hits.Length(); i++)
{
StringBuilder sb = new StringBuilder();
sb.Append("Para: ").Append(hits.Doc(i).Get("pid"));
sb.Append(", Surat: ").Append(hits.Doc(i).Get("sid"));
sb.Append(", Verse: ").Append(hits.Doc(i).Get("ayatno"));
lstResults.Items.Add(sb.ToString());
}
}
public void CaseInsensitiveNonMandatoryWildCard()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value*");
WildcardQuery wildcardQuery = new WildcardQuery(term);
originalQuery.Add(wildcardQuery, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.WildCard("_name", "Value*", Matches.Sometimes));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void CaseInsensitiveKeyword()
{
QueryBuilder builder = new QueryBuilder();
BooleanQuery originalQuery = new BooleanQuery();
QueryParser rawQueryParser = new QueryParser(Version.LUCENE_29, "_name", builder.KeywordAnalyzer);
originalQuery.Add(rawQueryParser.Parse("value"), Occur.MUST);
string queryString = originalQuery.ToString();
builder.Setup(x => x.Keyword("_name", "Value"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void QueryCaseSensitivePhrase()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "Value");
PhraseQuery phraseQuery = new PhraseQuery();
phraseQuery.SetSlop(2);
phraseQuery.Add(term);
originalQuery.Add(phraseQuery, BooleanClause.Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{CaseSensitive = true};
builder.Setup(x => x.Phrase(2).AddTerm(x, "_name", "Value"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
