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 void Enumerable(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Term(BBCFields.Title, "africa");
var result = luceneSearch.Execute(queryBuilder);
WriteDocuments(result);
Assert.AreEqual(8, result.Count());
}
public void EnumerableWithWhere(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Term(BBCFields.Title, "africa");
var result = luceneSearch.Execute(queryBuilder).Where(doc => doc.GetField(BBCFields.Title).StringValue.IndexOf("your", StringComparison.OrdinalIgnoreCase) >= 0);
WriteDocuments(result);
Assert.AreEqual(1, result.Count());
}
public void ChainedTerms(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Description, "a*"),
x => x.Term(BBCFields.Description, "police")
);
ExecuteAndAssert(luceneSearch, queryBuilder, 17);
}
public void Group(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Title, "africa"),
x => x.Group().Setup
(
y => y.Term(BBCFields.Description, "africa", BooleanClause.Occur.SHOULD),
y => y.Term(BBCFields.Description, "amazing", BooleanClause.Occur.SHOULD)
)
);
ExecuteAndAssert(luceneSearch, queryBuilder, 5);
}
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 void CollectDailyCount(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.PublishDate, "*")
);
DateCollector collector = new DateCollector();
luceneSearch.Collect(queryBuilder.Build(), collector);
foreach (String day in collector.DailyCount.Keys)
{
Console.Error.WriteLine("Day: {0} had {1} documents", day, collector.DailyCount[day]);
}
Console.WriteLine();
}
public void GetByFieldValue()
{
QueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.Field("title", "contact us"));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
Assert.Greater(sitecoreSearchResult.TotalHits, 0);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 10);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
Assert.IsTrue(item["title"].IndexOf("contact us", StringComparison.InvariantCultureIgnoreCase) >= 0);
});
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
public void GetByLanguage()
{
QueryBuilder queryBuilder = new QueryBuilder();
Language language = Language.Parse("en");
queryBuilder.Setup(x => x.Language(language));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
Assert.Greater(sitecoreSearchResult.TotalHits, 0);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 100);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
Assert.AreEqual(language, item.Language);
});
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
public void GetById()
{
QueryBuilder queryBuilder = new QueryBuilder();
ID itemId = new ID(Constants.HomeItemId);
queryBuilder.Setup(x => x.Id(itemId));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
Assert.Greater(sitecoreSearchResult.TotalHits, 0);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 10);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
Assert.AreEqual(itemId, item.ID);
});
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
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 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 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 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 void Term(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Term(BBCFields.Title, "africa");
var results = ExecuteAndAssert(luceneSearch, queryBuilder, 8);
Assert.AreEqual(8, results.TotalHits);
IQueryBuilder alternative = new QueryBuilder();
alternative.Where(x => x.Term("_name", "work"));
var results2 = luceneSearch.Execute(queryBuilder);
Assert.AreEqual(results.TotalHits, results2.TotalHits);
}
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 TermRange(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
DateTime startDate = new DateTime(2012, 12, 1);
DateTime endDate = new DateTime(2013, 1, 1);
queryBuilder.TermRange(BBCFields.PublishDate, TestHelpers.GetDateString(startDate), TestHelpers.GetDateString(endDate));
ExecuteAndAssert(luceneSearch, queryBuilder, 60);
}
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 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);
}
public void WildCard(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.WildCard(BBCFields.Description, "a*"));
ExecuteAndAssert(luceneSearch, queryBuilder, 902);
}
public void EasyOr(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Terms(BBCFields.Title, new[] {"europe", "africa"}, Matches.Sometimes);
ExecuteAndAssert(luceneSearch, queryBuilder, 12);
}
public void EasyAnd(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Terms(BBCFields.Title, new[] { "africa", "road" }, occur: Matches.Always);
ExecuteAndAssert(luceneSearch, queryBuilder, 1);
}
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 void Fuzzy(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Fuzzy(BBCFields.Title, "afric");
var results = ExecuteAndAssert(luceneSearch, queryBuilder, 16);
}
public void SetupConstructorTest()
{
QueryBuilder setupBuilder = new QueryBuilder();
setupBuilder.Setup(x => x.Term("_name", "Value"));
Query setupQuery = setupBuilder.Build();
string setupQueryString = setupQuery.ToString();
QueryBuilder constructorBuilder = new QueryBuilder(x => x.Term("_name", "Value"));
Query constructorQuery = constructorBuilder.Build();
string constructorQueryString = constructorQuery.ToString();
Assert.AreEqual(setupQueryString, constructorQueryString);
}
public void Group(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Title, "africa"),
x => x.Group().Setup
(
y => y.Term(BBCFields.Description, "africa", Matches.Sometimes),
y => y.Term(BBCFields.Description, "amazing", Matches.Sometimes)
)
);
ExecuteAndAssert(luceneSearch, queryBuilder, 5);
}
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 void Term()
{
IQueryBuilder queryBuilder = new QueryBuilder();
throw new NotImplementedException("Needs writing");
}
