public override Query Process(RangeQueryOptions options, AzureQueryMapper mapper)
{
string lowerTerm = (string)null;
string upperTerm = (string)null;
if (options.FieldFromValue != null)
lowerTerm = this.NormalizeValue(mapper.ValueFormatter.FormatValueForIndexStorage(options.FieldFromValue, options.FieldName).ToString(), mapper);
if (options.FieldToValue != null)
upperTerm = this.NormalizeValue(mapper.ValueFormatter.FormatValueForIndexStorage(options.FieldToValue, options.FieldName).ToString(), mapper);
TermRangeQuery termRangeQuery = new TermRangeQuery(options.FieldName, lowerTerm, upperTerm, options.IncludeLower, options.IncludeUpper);
termRangeQuery.Boost = options.Boost;
return (Query)termRangeQuery;
}
public BooleanQuery MakeQuery()
{
//Fill BooleanQeury with anonymous terms. term.Field=critList.Key term.Term=critList.Value
foreach (var pair in _searchCriterion)
{
string searchString = pair.Value.ToString();
if (!String.IsNullOrEmpty(searchString))
{
switch (pair.Key)
{
case "FindAll":
string[] searchFields = { "CardKind", "CardName", "CardEdition" };
var multiFieldQueryParser = new MultiFieldQueryParser(Version.LUCENE_30, searchFields,
_analyzer);
_finalQuery.Add(ParseQuery(searchString, multiFieldQueryParser),
searchString.Contains("+") ? Occur.MUST : Occur.SHOULD);
break;
case "CardAdoptionDateMin": //must be compile time constant!
string upperDate = DateTools.DateToString((DateTime)_kvpMax.Value, DateTools.Resolution.DAY);
var lowerRange = new TermRangeQuery("CardAdoptionDate", null, upperDate, true, true);
//{CardAdoptionDate:[* TO 20140718]}
_finalQuery.Add(new BooleanClause(lowerRange, Occur.MUST));
break;
case "CardAdoptionDateMax":
string lowerDate = DateTools.DateToString((DateTime)_kvpMin.Value, DateTools.Resolution.DAY);
var upperRange = new TermRangeQuery("CardAdoptionDate", lowerDate, null, true, true);
//{CardAdoptionDate:[20140718 TO *]}
_finalQuery.Add(new BooleanClause(upperRange, Occur.MUST));
break;
default:
_finalQuery.Add(new TermQuery(new Term(pair.Key, (string)pair.Value)), Occur.MUST);
break;
}
#region Source and links
//http://stackoverflow.com/questions/17503119/how-to-index-search-the-datetime-searchField-in-lucene-net
//http://stackoverflow.com/questions/3294772/storing-datetime-searchField-in-lucene-document
#endregion
}
}
return _finalQuery;
}
public void TestInclusive()
{
using (var dir = FSDirectory.Open(TestEnvironment.TestIndexDirectory))
using (var indexSearcher = new IndexSearcher(dir))
{
var termRangeQuery = new TermRangeQuery(field: "title2", lowerTerm: "d", upperTerm: "j", includeLower: true, includeUpper: true);
var topDocs = indexSearcher.Search(termRangeQuery, 100);
Assert.Equal(3, topDocs.TotalHits);
// foreach (var scoreDoc in topDocs.ScoreDocs)
// {
// Console.WriteLine(" match: {0}:{1}", indexSearcher.Doc(scoreDoc.Doc).Get("author"));
// }
}
}
public virtual void TestMultiValuedNRQ()
{
System.Random rnd = NewRandom();
RAMDirectory directory = new RAMDirectory();
IndexWriter writer = new IndexWriter(directory, new WhitespaceAnalyzer(), true, MaxFieldLength.UNLIMITED);
//DecimalFormat format = new DecimalFormat("00000000000", new System.Globalization.CultureInfo("en-US").NumberFormat);
for (int l = 0; l < 5000; l++)
{
Document doc = new Document();
for (int m = 0, c = rnd.Next(10); m <= c; m++)
{
int value_Renamed = rnd.Next(System.Int32.MaxValue);
doc.Add(new Field("asc", value_Renamed.ToString().PadLeft(11, '0'), Field.Store.NO, Field.Index.NOT_ANALYZED));
doc.Add(new NumericField("trie", Field.Store.NO, true).SetIntValue(value_Renamed));
}
writer.AddDocument(doc);
}
writer.Close();
Searcher searcher = new IndexSearcher(directory, true);
for (int i = 0; i < 50; i++)
{
int lower = rnd.Next(System.Int32.MaxValue);
int upper = rnd.Next(System.Int32.MaxValue);
if (lower > upper)
{
int a = lower; lower = upper; upper = a;
}
TermRangeQuery cq = new TermRangeQuery("asc", lower.ToString().PadLeft(11, '0'), upper.ToString().PadLeft(11, '0'), true, true);
System.Int32 tempAux = (System.Int32) lower;
System.Int32 tempAux2 = (System.Int32) upper;
NumericRangeQuery tq = NumericRangeQuery.NewIntRange("trie", tempAux, tempAux2, true, true);
TopDocs trTopDocs = searcher.Search(cq, 1);
TopDocs nrTopDocs = searcher.Search(tq, 1);
Assert.AreEqual(trTopDocs.totalHits, nrTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
}
searcher.Close();
directory.Close();
}
public virtual void TestAllDocs()
{
InitializeIndex(new string[] { "A", "B", "C", "D" });
IndexReader reader = DirectoryReader.Open(Dir);
IndexSearcher searcher = NewSearcher(reader);
TermRangeQuery query = new TermRangeQuery("content", null, null, true, true);
Terms terms = MultiFields.GetTerms(searcher.IndexReader, "content");
Assert.IsFalse(query.GetTermsEnum(terms) is TermRangeTermsEnum);
Assert.AreEqual(4, searcher.Search(query, null, 1000).ScoreDocs.Length);
query = new TermRangeQuery("content", null, null, false, false);
Assert.IsFalse(query.GetTermsEnum(terms) is TermRangeTermsEnum);
Assert.AreEqual(4, searcher.Search(query, null, 1000).ScoreDocs.Length);
query = TermRangeQuery.NewStringRange("content", "", null, true, false);
Assert.IsFalse(query.GetTermsEnum(terms) is TermRangeTermsEnum);
Assert.AreEqual(4, searcher.Search(query, null, 1000).ScoreDocs.Length);
// and now anothe one
query = TermRangeQuery.NewStringRange("content", "B", null, true, false);
Assert.IsTrue(query.GetTermsEnum(terms) is TermRangeTermsEnum);
Assert.AreEqual(3, searcher.Search(query, null, 1000).ScoreDocs.Length);
reader.Dispose();
}
public virtual void TestExclusive()
{
Query query = new TermRangeQuery("content", "A", "C", false, false);
InitializeIndex(new System.String[]{"A", "B", "C", "D"});
IndexSearcher searcher = new IndexSearcher(dir);
ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(1, hits.Length, "A,B,C,D, only B in range");
searcher.Close();
InitializeIndex(new System.String[]{"A", "B", "D"});
searcher = new IndexSearcher(dir);
hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(1, hits.Length, "A,B,D, only B in range");
searcher.Close();
AddDoc("C");
searcher = new IndexSearcher(dir);
hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(1, hits.Length, "C added, still only B in range");
searcher.Close();
}
public virtual void TestInclusive()
{
Query query = new TermRangeQuery("content", "A", "C", true, true);
InitializeIndex(new System.String[]{"A", "B", "C", "D"});
IndexSearcher searcher = new IndexSearcher(dir, true);
ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(3, hits.Length, "A,B,C,D - A,B,C in range");
searcher.Close();
InitializeIndex(new System.String[]{"A", "B", "D"});
searcher = new IndexSearcher(dir, true);
hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(2, hits.Length, "A,B,D - A and B in range");
searcher.Close();
AddDoc("C");
searcher = new IndexSearcher(dir, true);
hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(3, hits.Length, "C added - A, B, C in range");
searcher.Close();
}
/// <summary>
/// Adds the content sub query.
/// </summary>
/// <param name="query">The boolean query.</param>
/// <param name="key">The field key.</param>
/// <param name="value">The field value.</param>
/// <param name="matchVariant">The match variant.</param>
/// <param name="condition">The condition.</param>
/// <param name="isFirst">if set to <c>true</c> [is first].</param>
private void AddContentSubQuery(LuceneSearch.BooleanQuery query, string key, string value, MatchVariant matchVariant, QueryCondition condition)
{
if (matchVariant == MatchVariant.NotEquals)
{
query.Add(new LuceneSearch.TermQuery(new Term(key, value)), LuceneSearch.Occur.MUST_NOT);
return;
}
LuceneSearch.Occur occurrence = this.GetOccur(condition);
LuceneSearch.TermRangeQuery rangeQuery = this.GetRangeQuery(key, value, matchVariant);
if (rangeQuery != null)
{
query.Add(rangeQuery, occurrence);
return;
}
string[] keywords = value.Split(' ');
if (keywords.Length > 1)
{
LuceneSearch.PhraseQuery phraseQuery = new Lucene.Net.Search.PhraseQuery();
foreach (string keyword in keywords)
{
phraseQuery.Add(new Term(key, keyword));
}
query.Add(phraseQuery, occurrence);
}
else if (matchVariant == MatchVariant.Like)
{
query.Add(new LuceneSearch.WildcardQuery(new Term(key, value + "*")), occurrence);
}
else
{
query.Add(new LuceneSearch.TermQuery(new Term(key, value)), occurrence);
}
}
public virtual void TestRangeQuery()
{
TermRangeQuery rq = new TermRangeQuery("sorter", "b", "d", true, true);
Query filteredquery = new FilteredQuery(rq, filter);
ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
QueryUtils.Check(filteredquery, searcher);
}
public virtual void TestExclusiveLowerNull()
{
Analyzer analyzer = new SingleCharAnalyzer();
//http://issues.apache.org/jira/browse/LUCENE-38
Query query = new TermRangeQuery("content", null, "C", false, false);
InitializeIndex(new System.String[]{"A", "B", "", "C", "D"}, analyzer);
IndexSearcher searcher = new IndexSearcher(dir, true);
int numHits = searcher.Search(query, null, 1000).TotalHits;
// When Lucene-38 is fixed, use the assert on the next line:
Assert.AreEqual(3, numHits, "A,B,<empty string>,C,D => A, B & <empty string> are in range");
// until Lucene-38 is fixed, use this assert:
//Assert.AreEqual(2, hits.length(),"A,B,<empty string>,C,D => A, B & <empty string> are in range");
searcher.Close();
InitializeIndex(new System.String[]{"A", "B", "", "D"}, analyzer);
searcher = new IndexSearcher(dir, true);
numHits = searcher.Search(query, null, 1000).TotalHits;
// When Lucene-38 is fixed, use the assert on the next line:
Assert.AreEqual(3, numHits, "A,B,<empty string>,D => A, B & <empty string> are in range");
// until Lucene-38 is fixed, use this assert:
//Assert.AreEqual(2, hits.length(), "A,B,<empty string>,D => A, B & <empty string> are in range");
searcher.Close();
AddDoc("C");
searcher = new IndexSearcher(dir, true);
numHits = searcher.Search(query, null, 1000).TotalHits;
// When Lucene-38 is fixed, use the assert on the next line:
Assert.AreEqual(3, numHits, "C added, still A, B & <empty string> are in range");
// until Lucene-38 is fixed, use this assert
//Assert.AreEqual(2, hits.length(), "C added, still A, B & <empty string> are in range");
searcher.Close();
}
protected override ParameterizedSql BuildQuery(TermRangeQuery termRangeQuery)
{
// Not handling the TermRangeQuery. Discarding the search term.
return null;
}
private void TestRandomTrieAndClassicRangeQuery(int precisionStep)
{
string field = "field" + precisionStep;
int totalTermCountT = 0, totalTermCountC = 0, termCountT, termCountC;
int num = TestUtil.NextInt(Random(), 10, 20);
for (int i = 0; i < num; i++)
{
int lower = (int)(Random().NextDouble() * NoDocs * Distance) + StartOffset;
int upper = (int)(Random().NextDouble() * NoDocs * Distance) + StartOffset;
if (lower > upper)
{
int a = lower;
lower = upper;
upper = a;
}
BytesRef lowerBytes = new BytesRef(NumericUtils.BUF_SIZE_INT), upperBytes = new BytesRef(NumericUtils.BUF_SIZE_INT);
NumericUtils.IntToPrefixCodedBytes(lower, 0, lowerBytes);
NumericUtils.IntToPrefixCodedBytes(upper, 0, upperBytes);
// test inclusive range
NumericRangeQuery<int> tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, true);
TermRangeQuery cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
TopDocs cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test exclusive range
tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, false, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test left exclusive range
tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, false, true);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, true);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test right exclusive range
tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
}
CheckTermCounts(precisionStep, totalTermCountT, totalTermCountC);
if (VERBOSE && precisionStep != int.MaxValue)
{
Console.WriteLine("Average number of terms during random search on '" + field + "':");
Console.WriteLine(" Numeric query: " + (((double)totalTermCountT) / (num * 4)));
Console.WriteLine(" Classical query: " + (((double)totalTermCountC) / (num * 4)));
}
}
private void TestRandomTrieAndClassicRangeQuery(int precisionStep)
{
System.Random rnd = NewRandom();
System.String field = "field" + precisionStep;
int termCountT = 0, termCountC = 0;
for (int i = 0; i < 50; i++)
{
long lower = (long) (rnd.NextDouble() * noDocs * distance) + startOffset;
long upper = (long) (rnd.NextDouble() * noDocs * distance) + startOffset;
if (lower > upper)
{
long a = lower; lower = upper; upper = a;
}
// test inclusive range
System.Int64 tempAux = (long) lower;
System.Int64 tempAux2 = (long) upper;
NumericRangeQuery tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux, tempAux2, true, true);
TermRangeQuery cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), true, true);
TopDocs tTopDocs = searcher.Search(tq, 1);
TopDocs cTopDocs = searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
termCountT += tq.GetTotalNumberOfTerms();
termCountC += cq.GetTotalNumberOfTerms();
// test exclusive range
System.Int64 tempAux3 = (long) lower;
System.Int64 tempAux4 = (long) upper;
tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux3, tempAux4, false, false);
cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), false, false);
tTopDocs = searcher.Search(tq, 1);
cTopDocs = searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
termCountT += tq.GetTotalNumberOfTerms();
termCountC += cq.GetTotalNumberOfTerms();
// test left exclusive range
System.Int64 tempAux5 = (long) lower;
System.Int64 tempAux6 = (long) upper;
tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux5, tempAux6, false, true);
cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), false, true);
tTopDocs = searcher.Search(tq, 1);
cTopDocs = searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
termCountT += tq.GetTotalNumberOfTerms();
termCountC += cq.GetTotalNumberOfTerms();
// test right exclusive range
System.Int64 tempAux7 = (long) lower;
System.Int64 tempAux8 = (long) upper;
tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux7, tempAux8, true, false);
cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), true, false);
tTopDocs = searcher.Search(tq, 1);
cTopDocs = searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
termCountT += tq.GetTotalNumberOfTerms();
termCountC += cq.GetTotalNumberOfTerms();
}
if (precisionStep == System.Int32.MaxValue)
{
Assert.AreEqual(termCountT, termCountC, "Total number of terms should be equal for unlimited precStep");
}
else
{
System.Console.Out.WriteLine("Average number of terms during random search on '" + field + "':");
System.Console.Out.WriteLine(" Trie query: " + (((double) termCountT) / (50 * 4)));
System.Console.Out.WriteLine(" Classical query: " + (((double) termCountC) / (50 * 4)));
}
}
/// <summary>macro for readability </summary>
public static Query Csrq(System.String f, System.String l, System.String h, bool il, bool ih, System.Globalization.CompareInfo c)
{
TermRangeQuery query = new TermRangeQuery(f, l, h, il, ih, c);
query.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
return query;
}
public static IndexItemCollection Browse(
int siteId,
Guid featureGuid,
DateTime modifiedBeginDate,
DateTime modifiedEndDate,
int pageNumber,
int pageSize,
out int totalHits)
{
totalHits = 0;
IndexItemCollection results = new IndexItemCollection();
using (Lucene.Net.Store.Directory searchDirectory = GetDirectory(siteId))
{
Filter filter = null;
BooleanQuery filterQuery = null;
if ((modifiedBeginDate.Date > DateTime.MinValue.Date) || (modifiedEndDate.Date < DateTime.MaxValue.Date))
{
filterQuery = new BooleanQuery(); // won't be used to score the results
TermRangeQuery lastModifiedDateFilter = new TermRangeQuery(
"LastModUtc",
modifiedBeginDate.Date.ToString("s"),
modifiedEndDate.Date.ToString("s"),
true,
true);
filterQuery.Add(lastModifiedDateFilter, Occur.MUST);
}
if (featureGuid != Guid.Empty)
{
if (filterQuery == null) { filterQuery = new BooleanQuery(); }
BooleanQuery featureFilter = new BooleanQuery();
featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.MUST);
filterQuery.Add(featureFilter, Occur.MUST);
}
if (filterQuery != null)
{
filter = new QueryWrapperFilter(filterQuery); // filterQuery won't affect result scores
}
MatchAllDocsQuery matchAllQuery = new MatchAllDocsQuery();
using (IndexSearcher searcher = new IndexSearcher(searchDirectory))
{
int maxResults = int.MaxValue;
TopDocs hits = searcher.Search(matchAllQuery, filter, maxResults);
int startHit = 0;
if (pageNumber > 1)
{
startHit = ((pageNumber - 1) * pageSize);
}
totalHits = hits.TotalHits;
if (startHit > totalHits)
{
startHit = totalHits;
}
int end = startHit + pageSize;
if (totalHits <= end)
{
end = totalHits;
}
int itemsAdded = 0;
int itemsToAdd = end;
for (int i = startHit; i < itemsToAdd; i++)
{
Document doc = searcher.Doc(hits.ScoreDocs[i].Doc);
IndexItem indexItem = new IndexItem(doc, hits.ScoreDocs[i].Score);
results.Add(indexItem);
itemsAdded += 1;
}
results.ItemCount = itemsAdded;
results.PageIndex = pageNumber;
results.ExecutionTime = DateTime.Now.Ticks; // -0;
}
// using (IndexReader reader = IndexReader.Open(searchDirectory, false))
// {
// totalHits = reader.NumDocs();
// int startHit = 0;
// int itemsToAdd = pageSize;
// if (pageNumber > 1)
// {
// startHit = ((pageNumber - 1) * pageSize);
// int end = startHit + pageSize;
// if (totalHits <= end)
// {
// end = totalHits;
// }
// itemsToAdd = end;
// }
// for (int i = startHit; i < itemsToAdd; i++)
// {
// Document doc = reader.Document(i);
// IndexItem indexItem = new IndexItem(doc, 1);
// results.Add(indexItem);
// }
// }
}
return results;
}
public virtual void TestDanish()
{
System.Globalization.CompareInfo collator = new System.Globalization.CultureInfo("da" + "-" + "dk").CompareInfo;
// Danish collation orders the words below in the given order (example taken
// from TestSort.testInternationalSort() ).
System.String[] words = new System.String[]{"H\u00D8T", "H\u00C5T", "MAND"};
Query query = new TermRangeQuery("content", "H\u00D8T", "MAND", false, false, collator);
// Unicode order would not include "H\u00C5T" in [ "H\u00D8T", "MAND" ],
// but Danish collation does.
InitializeIndex(words);
IndexSearcher searcher = new IndexSearcher(dir);
ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(1, hits.Length, "The index Term should be included.");
query = new TermRangeQuery("content", "H\u00C5T", "MAND", false, false, collator);
hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(0, hits.Length, "The index Term should not be included.");
searcher.Close();
}
public virtual void TestEqualsHashcode()
{
Query query = new TermRangeQuery("content", "A", "C", true, true);
query.SetBoost(1.0f);
Query other = new TermRangeQuery("content", "A", "C", true, true);
other.SetBoost(1.0f);
Assert.AreEqual(query, query, "query equals itself is true");
Assert.AreEqual(query, other, "equivalent queries are equal");
Assert.AreEqual(query.GetHashCode(), other.GetHashCode(), "hashcode must return same value when equals is true");
other.SetBoost(2.0f);
Assert.IsFalse(query.Equals(other), "Different boost queries are not equal");
other = new TermRangeQuery("notcontent", "A", "C", true, true);
Assert.IsFalse(query.Equals(other), "Different fields are not equal");
other = new TermRangeQuery("content", "X", "C", true, true);
Assert.IsFalse(query.Equals(other), "Different lower terms are not equal");
other = new TermRangeQuery("content", "A", "Z", true, true);
Assert.IsFalse(query.Equals(other), "Different upper terms are not equal");
query = new TermRangeQuery("content", null, "C", true, true);
other = new TermRangeQuery("content", null, "C", true, true);
Assert.AreEqual(query, other, "equivalent queries with null lowerterms are equal()");
Assert.AreEqual(query.GetHashCode(), other.GetHashCode(), "hashcode must return same value when equals is true");
query = new TermRangeQuery("content", "C", null, true, true);
other = new TermRangeQuery("content", "C", null, true, true);
Assert.AreEqual(query, other, "equivalent queries with null upperterms are equal()");
Assert.AreEqual(query.GetHashCode(), other.GetHashCode(), "hashcode returns same value");
query = new TermRangeQuery("content", null, "C", true, true);
other = new TermRangeQuery("content", "C", null, true, true);
Assert.IsFalse(query.Equals(other), "queries with different upper and lower terms are not equal");
query = new TermRangeQuery("content", "A", "C", false, false);
other = new TermRangeQuery("content", "A", "C", true, true);
Assert.IsFalse(query.Equals(other), "queries with different inclusive are not equal");
query = new TermRangeQuery("content", "A", "C", false, false);
other = new TermRangeQuery("content", "A", "C", false, false, System.Globalization.CultureInfo.CurrentCulture.CompareInfo);
Assert.IsFalse(query.Equals(other), "a query with a collator is not equal to one without");
}
/// <summary>Constructs a query selecting all terms greater than
/// <c>lowerTerm</c> but less than <c>upperTerm</c>.
/// There must be at least one term and either term may be null,
/// in which case there is no bound on that side, but if there are
/// two terms, both terms <b>must</b> be for the same field.
/// <p/>
/// If <c>collator</c> is not null, it will be used to decide whether
/// index terms are within the given range, rather than using the Unicode code
/// point order in which index terms are stored.
/// <p/>
/// <strong>WARNING:</strong> Using this constructor and supplying a non-null
/// value in the <c>collator</c> parameter will cause every single
/// index Term in the Field referenced by lowerTerm and/or upperTerm to be
/// examined. Depending on the number of index Terms in this Field, the
/// operation could be very slow.
///
/// </summary>
/// <param name="lowerTerm">The Term at the lower end of the range
/// </param>
/// <param name="upperTerm">The Term at the upper end of the range
/// </param>
/// <param name="inclusive">If true, both <c>lowerTerm</c> and
/// <c>upperTerm</c> will themselves be included in the range.
/// </param>
/// <param name="collator">The collator to use to collate index Terms, to determine
/// their membership in the range bounded by <c>lowerTerm</c> and
/// <c>upperTerm</c>.
/// </param>
public RangeQuery(Term lowerTerm, Term upperTerm, bool inclusive, System.Globalization.CompareInfo collator)
{
if (lowerTerm == null && upperTerm == null)
throw new System.ArgumentException("At least one term must be non-null");
if (lowerTerm != null && upperTerm != null && (System.Object) lowerTerm.Field() != (System.Object) upperTerm.Field())
throw new System.ArgumentException("Both terms must have the same field");
delegate_Renamed = new TermRangeQuery((lowerTerm == null)?upperTerm.Field():lowerTerm.Field(), (lowerTerm == null)?null:lowerTerm.Text(), (upperTerm == null)?null:upperTerm.Text(), inclusive, inclusive, collator);
delegate_Renamed.SetRewriteMethod(TermRangeQuery.SCORING_BOOLEAN_QUERY_REWRITE);
}
/// <summary>
/// Builds the query.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
public override object BuildQuery(ISearchCriteria criteria)
{
var builder = base.BuildQuery(criteria) as QueryBuilder;
var query = builder.Query as BooleanQuery;
var analyzer = new StandardAnalyzer(u.Version.LUCENE_30);
if (criteria is CatalogIndexedSearchCriteria)
{
var c = criteria as CatalogIndexedSearchCriteria;
var datesFilterStart = new TermRangeQuery(
"startdate", c.StartDateFrom.HasValue ? DateTools.DateToString(c.StartDateFrom.Value, DateTools.Resolution.SECOND) : null, DateTools.DateToString(c.StartDate, DateTools.Resolution.SECOND), false, true);
query.Add(datesFilterStart, Occur.MUST);
if (c.EndDate.HasValue)
{
var datesFilterEnd = new TermRangeQuery(
"enddate",
DateTools.DateToString(c.EndDate.Value, DateTools.Resolution.SECOND),
null,
true,
false);
query.Add(datesFilterEnd, Occur.MUST);
}
if (c.Outlines != null && c.Outlines.Count > 0)
{
AddQuery("__outline", query, c.Outlines);
}
query.Add(new TermQuery(new Term("__hidden", "false")), Occur.MUST);
if (!String.IsNullOrEmpty(c.Catalog))
{
AddQuery("catalog", query, c.Catalog);
}
// Add search
if (!String.IsNullOrEmpty(c.SearchPhrase))
{
var searchPhrase = c.SearchPhrase;
if (c.IsFuzzySearch)
{
var keywords = c.SearchPhrase.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
searchPhrase = string.Empty;
searchPhrase = keywords.Aggregate(
searchPhrase,
(current, keyword) =>
current + String.Format("{0}~{1}", keyword.Replace("~", ""), c.FuzzyMinSimilarity.ToString(CultureInfo.InvariantCulture)));
}
var fields = new List<string> { "__content" };
if (c.Locale != null)
{
var contentField = string.Format("__content_{0}", c.Locale.ToLower());
fields.Add(contentField);
}
var parser = new MultiFieldQueryParser(u.Version.LUCENE_30, fields.ToArray(), analyzer)
{
DefaultOperator =
QueryParser
.Operator.OR
};
var searchQuery = parser.Parse(searchPhrase);
query.Add(searchQuery, Occur.MUST);
}
}
//else if (criteria is OrderSearchCriteria)
//{
// var c = criteria as OrderSearchCriteria;
// if (!String.IsNullOrEmpty(c.CustomerId))
// {
// AddQuery("customerid", query, c.CustomerId);
// }
//}
return builder;
}
public virtual void TestBooleanOrderUnAffected()
{
// NOTE: uses index build in *this* setUp
IndexReader reader = IndexReader.Open(small);
IndexSearcher search = new IndexSearcher(reader);
// first do a regular TermRangeQuery which uses term expansion so
// docs with more terms in range get higher scores
Query rq = new TermRangeQuery("data", "1", "4", T, T);
ScoreDoc[] expected = search.Search(rq, null, 1000).scoreDocs;
int numHits = expected.Length;
// now do a boolean where which also contains a
// ConstantScoreRangeQuery and make sure hte order is the same
BooleanQuery q = new BooleanQuery();
q.Add(rq, BooleanClause.Occur.MUST); // T, F);
q.Add(Csrq("data", "1", "6", T, T), BooleanClause.Occur.MUST); // T, F);
ScoreDoc[] actual = search.Search(q, null, 1000).scoreDocs;
AssertEquals("wrong numebr of hits", numHits, actual.Length);
for (int i = 0; i < numHits; i++)
{
AssertEquals("mismatch in docid for hit#" + i, expected[i].doc, actual[i].doc);
}
}
public virtual void TestFarsi()
{
// Neither Java 1.4.2 nor 1.5.0 has Farsi Locale collation available in
// RuleBasedCollator. However, the Arabic Locale seems to order the Farsi
// characters properly.
System.Globalization.CompareInfo collator = new System.Globalization.CultureInfo("ar").CompareInfo;
Query query = new TermRangeQuery("content", "\u062F", "\u0698", true, true, collator);
// Unicode order would include U+0633 in [ U+062F - U+0698 ], but Farsi
// orders the U+0698 character before the U+0633 character, so the single
// index Term below should NOT be returned by a TermRangeQuery with a Farsi
// Collator (or an Arabic one for the case when Farsi is not supported).
InitializeIndex(new System.String[]{"\u0633\u0627\u0628"});
IndexSearcher searcher = new IndexSearcher(dir);
ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(0, hits.Length, "The index Term should not be included.");
query = new TermRangeQuery("content", "\u0633", "\u0638", true, true, collator);
hits = searcher.Search(query, null, 1000).ScoreDocs;
Assert.AreEqual(1, hits.Length, "The index Term should be included.");
searcher.Close();
}
/// <summary>
/// 添加字符串类型的RangeQuery.
/// </summary>
/// <param name="fieldName">字段名称</param>
/// <param name="min">最小值</param>
/// <param name="max">最大值 </param>
/// <returns>LuceneSearchBuilder</returns>
public LuceneSearchBuilder WithinRange(string fieldName, string min, string max, bool asFilter = false)
{
Query query = new TermRangeQuery(fieldName, min, max, true, true);
if (asFilter)
filters.Add(new BooleanClause(query, BooleanClause.Occur.MUST));
else
clauses.Add(new BooleanClause(query, BooleanClause.Occur.MUST));
return this;
}
public virtual void TestInclusiveLowerNull()
{
//http://issues.apache.org/jira/browse/LUCENE-38
Analyzer analyzer = new SingleCharAnalyzer();
Query query = new TermRangeQuery("content", null, "C", true, true);
InitializeIndex(new System.String[]{"A", "B", "", "C", "D"}, analyzer);
IndexSearcher searcher = new IndexSearcher(dir);
Hits hits = searcher.Search(query);
// When Lucene-38 is fixed, use the assert on the next line:
Assert.AreEqual(4, hits.Length(), "A,B,<empty string>,C,D => A,B,<empty string>,C in range");
// until Lucene-38 is fixed, use this assert
//Assert.AreEqual(3, hits.length(), "A,B,<empty string>,C,D => A,B,<empty string>,C in range");
searcher.Close();
InitializeIndex(new System.String[]{"A", "B", "", "D"}, analyzer);
searcher = new IndexSearcher(dir);
hits = searcher.Search(query);
// When Lucene-38 is fixed, use the assert on the next line:
Assert.AreEqual(3, hits.Length(), "A,B,<empty string>,D - A, B and <empty string> in range");
// until Lucene-38 is fixed, use this assert
//Assert.AreEqual(2, hits.length(), "A,B,<empty string>,D => A, B and <empty string> in range");
searcher.Close();
AddDoc("C");
searcher = new IndexSearcher(dir);
hits = searcher.Search(query);
// When Lucene-38 is fixed, use the assert on the next line:
Assert.AreEqual(4, hits.Length(), "C added => A,B,<empty string>,C in range");
// until Lucene-38 is fixed, use this assert
//Assert.AreEqual(3, hits.length(), "C added => A,B,<empty string>,C in range");
searcher.Close();
}
private static void MultiTermQuery(TermRangeQuery query, AzureQueryLogger.IndentedTextWriter writer)
{
writer.WriteLine("Field: {0}", (object)query.Field);
writer.WriteLine("Collator: {0}", (object)query.Collator);
writer.WriteLine("IncludesLower: {0}", (query.IncludesLower ? 1 : 0));
writer.WriteLine("IncludesUpper: {0}", (query.IncludesUpper ? 1 : 0));
writer.WriteLine("LowerTerm: {0}", (object)query.LowerTerm);
writer.WriteLine("UpperTerm: {0}", (object)query.UpperTerm);
}
public static List<IndexItem> GetRecentModifiedContent(
int siteId,
Guid[] featureGuids,
DateTime modifiedSinceDate,
int maxItems)
{
int totalHits = 0;
List<IndexItem> results = new List<IndexItem>();
using (Lucene.Net.Store.Directory searchDirectory = GetDirectory(siteId))
{
Filter filter = null;
BooleanQuery filterQuery = new BooleanQuery(); // won't be used to score the results
BooleanQuery excludeFilter = new BooleanQuery();
excludeFilter.Add(new TermQuery(new Term("ExcludeFromRecentContent", "false")), Occur.MUST);
filterQuery.Add(excludeFilter, Occur.MUST);
TermRangeQuery lastModifiedDateFilter = new TermRangeQuery(
"LastModUtc",
modifiedSinceDate.Date.ToString("s"),
DateTime.MaxValue.ToString("s"),
true,
true);
filterQuery.Add(lastModifiedDateFilter, Occur.MUST);
// we only want public content, that is both page and module roles must have "All Users"
// which means even unauthenticated users
Term pageRole = new Term("Role", "All Users");
TermQuery pageRoleFilter = new TermQuery(pageRole);
filterQuery.Add(pageRoleFilter, Occur.MUST);
Term moduleRole = new Term("ModuleRole", "All Users");
TermQuery moduleRoleFilter = new TermQuery(moduleRole);
filterQuery.Add(moduleRoleFilter, Occur.MUST);
if ((featureGuids != null)&&(featureGuids.Length > 0))
{
BooleanQuery featureFilter = new BooleanQuery();
foreach (Guid featureGuid in featureGuids)
{
featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.SHOULD);
}
filterQuery.Add(featureFilter, Occur.MUST);
}
filter = new QueryWrapperFilter(filterQuery); // filterQuery won't affect result scores
MatchAllDocsQuery matchAllQuery = new MatchAllDocsQuery();
using (IndexSearcher searcher = new IndexSearcher(searchDirectory))
{
int maxResults = int.MaxValue;
TopDocs hits = searcher.Search(matchAllQuery, filter, maxResults);
totalHits = hits.TotalHits;
for (int i = 0; i < totalHits; i++)
{
Document doc = searcher.Doc(hits.ScoreDocs[i].Doc);
IndexItem indexItem = new IndexItem(doc, hits.ScoreDocs[i].Score);
results.Add(indexItem);
}
}
}
// sort all descending on lastmodutc
results.Sort();
if (results.Count <= maxItems)
{
return results;
}
else
{
List<IndexItem> finalResults = new List<IndexItem>();
for (int i = 0; i < maxItems; i++)
{
finalResults.Add(results[i]);
}
return finalResults;
}
}
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 static IndexItemCollection Search(
int siteId,
bool isAdminContentAdminOrSiteEditor,
List<string> userRoles,
Guid[] featureGuids,
DateTime modifiedBeginDate,
DateTime modifiedEndDate,
string queryText,
bool highlightResults,
int highlightedFragmentSize,
int pageNumber,
int pageSize,
int maxClauseCount,
out int totalHits,
out bool invalidQuery)
{
invalidQuery = false;
totalHits = 0;
IndexItemCollection results = new IndexItemCollection();
if (string.IsNullOrEmpty(queryText))
{
return results;
}
using (Lucene.Net.Store.Directory searchDirectory = GetDirectory(siteId))
{
if (!IndexReader.IndexExists(searchDirectory)) { return results; }
long startTicks = DateTime.Now.Ticks;
try
{
if (maxClauseCount != 1024)
{
BooleanQuery.MaxClauseCount = maxClauseCount;
}
// there are different analyzers for different languages
// see LuceneSettings.config in the root of the web
LuceneSettingsProvider provider = LuceneSettingsManager.Providers[GetSiteProviderName(siteId)];
Analyzer analyzer = provider.GetAnalyzer();
Query searchQuery = MultiFieldQueryParser.Parse(
Lucene.Net.Util.Version.LUCENE_30,
new string[] { queryText, queryText, queryText, queryText, queryText, queryText.Replace("*", string.Empty) },
new string[] { "Title", "ModuleTitle", "contents", "PageName", "PageMetaDesc", "Keyword" },
analyzer);
BooleanQuery filterQuery = new BooleanQuery(); // won't be used to score the results
if (!isAdminContentAdminOrSiteEditor) // skip role filters for these users
{
AddRoleFilters(userRoles, filterQuery);
AddModuleRoleFilters(userRoles, filterQuery);
}
TermRangeQuery beginDateFilter = new TermRangeQuery(
"PublishBeginDate",
DateTime.MinValue.ToString("s"),
DateTime.UtcNow.ToString("s"),
true,
true);
filterQuery.Add(beginDateFilter, Occur.MUST);
TermRangeQuery endDateFilter = new TermRangeQuery(
"PublishEndDate",
DateTime.UtcNow.ToString("s"),
DateTime.MaxValue.ToString("s"),
true,
true);
filterQuery.Add(endDateFilter, Occur.MUST);
if ((modifiedBeginDate.Date > DateTime.MinValue.Date) || (modifiedEndDate.Date < DateTime.MaxValue.Date))
{
TermRangeQuery lastModifiedDateFilter = new TermRangeQuery(
"LastModUtc",
modifiedBeginDate.Date.ToString("s"),
modifiedEndDate.Date.ToString("s"),
true,
true);
filterQuery.Add(lastModifiedDateFilter, Occur.MUST);
}
//if ((!DisableSearchFeatureFilters) && (featureGuid != Guid.Empty))
//{
// BooleanQuery featureFilter = new BooleanQuery();
// featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.MUST);
// filterQuery.Add(featureFilter, Occur.MUST);
//}
if ((featureGuids != null) && (featureGuids.Length > 0))
{
BooleanQuery featureFilter = new BooleanQuery();
foreach (Guid featureGuid in featureGuids)
{
featureFilter.Add(new TermQuery(new Term("FeatureId", featureGuid.ToString())), Occur.SHOULD);
}
filterQuery.Add(featureFilter, Occur.MUST);
}
Filter filter = new QueryWrapperFilter(filterQuery); // filterQuery won't affect result scores
using (IndexSearcher searcher = new IndexSearcher(searchDirectory))
{
//http://stackoverflow.com/questions/9872933/migrating-lucene-hitcollector-2-x-to-collector-3-x
//TopScoreDocCollector collector = TopScoreDocCollector.Create(maxResults, true);
int maxResults = int.MaxValue;
TopDocs hits = searcher.Search(searchQuery, filter, maxResults);
int startHit = 0;
if (pageNumber > 1)
{
startHit = ((pageNumber - 1) * pageSize);
}
totalHits = hits.TotalHits;
int end = startHit + pageSize;
if (totalHits <= end)
{
end = totalHits;
}
int itemsAdded = 0;
int itemsToAdd = end;
QueryScorer scorer = new QueryScorer(searchQuery);
SimpleHTMLFormatter formatter = new SimpleHTMLFormatter("<span class='searchterm'>", "</span>");
Highlighter highlighter = new Highlighter(formatter, scorer);
highlighter.TextFragmenter = new SimpleFragmenter(highlightedFragmentSize);
for (int i = startHit; i < itemsToAdd; i++)
{
Document doc = searcher.Doc(hits.ScoreDocs[i].Doc);
IndexItem indexItem = new IndexItem(doc, hits.ScoreDocs[i].Score);
if (highlightResults)
{
try
{
TokenStream stream = analyzer.TokenStream("contents", new StringReader(doc.Get("contents")));
string highlightedResult = highlighter.GetBestFragment(stream, doc.Get("contents"));
if (highlightedResult != null) { indexItem.Intro = highlightedResult; }
}
catch (NullReferenceException) { }
}
results.Add(indexItem);
itemsAdded += 1;
}
results.ItemCount = itemsAdded;
results.PageIndex = pageNumber;
results.ExecutionTime = DateTime.Now.Ticks - startTicks;
}
}
catch (ParseException ex)
{
invalidQuery = true;
log.Error("handled error for search terms " + queryText, ex);
// these parser exceptions are generally caused by
// spambots posting too much junk into the search form
// heres an option to automatically ban the ip address
HandleSpam(queryText, ex);
return results;
}
catch (BooleanQuery.TooManyClauses ex)
{
invalidQuery = true;
log.Error("handled error for search terms " + queryText, ex);
return results;
}
catch (System.IO.IOException ex)
{
invalidQuery = true;
log.Error("handled error for search terms " + queryText, ex);
return results;
}
return results;
}
}
public virtual TermRangeQuery TermRange(string fieldName, string rangeStart, string rangeEnd, bool includeLower = true, bool includeUpper = true,
BooleanClause.Occur occur = null, float? boost = null, string key = null, bool? caseSensitive = null)
{
if (caseSensitive.HasValue)
{
if (!caseSensitive.Value)
{
rangeStart = rangeStart.ToLowerInvariant();
rangeEnd = rangeEnd.ToLowerInvariant();
}
}
else if(!CaseSensitive)
{
rangeStart = rangeStart.ToLowerInvariant();
rangeEnd = rangeEnd.ToLowerInvariant();
}
TermRangeQuery query = new TermRangeQuery(QueryParser.Escape(fieldName), rangeStart, rangeEnd, includeLower, includeUpper);
SetBoostValue(query, boost);
Add(query, occur, key);
return query;
}
public virtual void TestRewrite()
{
IndexReader r = DirectoryReader.Open(dir);
IndexSearcher s = NewSearcher(r);
Query q = new TermQuery(new Term(TEXT_FIELD, "first"));
CustomScoreQuery original = new CustomScoreQuery(q);
CustomScoreQuery rewritten = (CustomScoreQuery)original.Rewrite(s.IndexReader);
assertTrue("rewritten query should be identical, as TermQuery does not rewrite", original == rewritten);
assertTrue("no hits for query", s.Search(rewritten, 1).TotalHits > 0);
assertEquals(s.Search(q, 1).TotalHits, s.Search(rewritten, 1).TotalHits);
q = new TermRangeQuery(TEXT_FIELD, null, null, true, true); // everything
original = new CustomScoreQuery(q);
rewritten = (CustomScoreQuery)original.Rewrite(s.IndexReader);
assertTrue("rewritten query should not be identical, as TermRangeQuery rewrites", original != rewritten);
assertTrue("no hits for query", s.Search(rewritten, 1).TotalHits > 0);
assertEquals(s.Search(q, 1).TotalHits, s.Search(original, 1).TotalHits);
assertEquals(s.Search(q, 1).TotalHits, s.Search(rewritten, 1).TotalHits);
r.Dispose();
}
/// <summary>
/// check that the # of hits is the same as if the query
/// is run against the inverted index
/// </summary>
protected internal virtual void AssertSame(BytesRef lowerVal, BytesRef upperVal, bool includeLower, bool includeUpper)
{
Query docValues = new ConstantScoreQuery(DocTermOrdsRangeFilter.NewBytesRefRange(FieldName, lowerVal, upperVal, includeLower, includeUpper));
MultiTermQuery inverted = new TermRangeQuery(FieldName, lowerVal, upperVal, includeLower, includeUpper);
inverted.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
TopDocs invertedDocs = Searcher1.Search(inverted, 25);
TopDocs docValuesDocs = Searcher2.Search(docValues, 25);
CheckHits.CheckEqual(inverted, invertedDocs.ScoreDocs, docValuesDocs.ScoreDocs);
}
public virtual void TestDanish()
{
/* build an index */
RAMDirectory danishIndex = new RAMDirectory();
IndexWriter writer = new IndexWriter(danishIndex, new SimpleAnalyzer(), T, IndexWriter.MaxFieldLength.LIMITED);
// Danish collation orders the words below in the given order
// (example taken from TestSort.testInternationalSort() ).
System.String[] words = new System.String[]{"H\u00D8T", "H\u00C5T", "MAND"};
for (int docnum = 0; docnum < words.Length; ++docnum)
{
Document doc = new Document();
doc.Add(new Field("content", words[docnum], Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("body", "body", Field.Store.YES, Field.Index.NOT_ANALYZED));
writer.AddDocument(doc);
}
writer.Optimize();
writer.Close();
IndexReader reader = IndexReader.Open(danishIndex, true);
IndexSearcher search = new IndexSearcher(reader);
Query q = new TermQuery(new Term("body", "body"));
System.Globalization.CompareInfo collator = new System.Globalization.CultureInfo("da" + "-" + "dk").CompareInfo;
Query query = new TermRangeQuery("content", "H\u00D8T", "MAND", false, false, collator);
// Unicode order would not include "H\u00C5T" in [ "H\u00D8T", "MAND" ],
// but Danish collation does.
int numHits =
search.Search(q, new TermRangeFilter("content", "H\u00D8T", "MAND", F, F, collator), 1000).TotalHits;
Assert.AreEqual(1, numHits, "The index Term should be included.");
numHits = search.Search(q, new TermRangeFilter("content", "H\u00C5T", "MAND", F, F, collator), 1000).TotalHits;
Assert.AreEqual(0, numHits, "The index Term should not be included.");
search.Close();
}
private void TestRandomTrieAndClassicRangeQuery(int precisionStep)
{
string field = "field" + precisionStep;
int totalTermCountT = 0, totalTermCountC = 0, termCountT, termCountC;
int num = TestUtil.NextInt(Random(), 10, 20);
for (int i = 0; i < num; i++)
{
long lower = (long)(Random().NextDouble() * NoDocs * Distance) + StartOffset;
long upper = (long)(Random().NextDouble() * NoDocs * Distance) + StartOffset;
if (lower > upper)
{
long a = lower;
lower = upper;
upper = a;
}
BytesRef lowerBytes = new BytesRef(NumericUtils.BUF_SIZE_INT64), upperBytes = new BytesRef(NumericUtils.BUF_SIZE_INT64);
NumericUtils.Int64ToPrefixCodedBytes(lower, 0, lowerBytes);
NumericUtils.Int64ToPrefixCodedBytes(upper, 0, upperBytes);
// test inclusive range
NumericRangeQuery <long> tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, true);
TermRangeQuery cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
TopDocs cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test exclusive range
tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, false, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test left exclusive range
tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, false, true);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, true);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test right exclusive range
tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
totalTermCountT += termCountT = CountTerms(tq);
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
}
CheckTermCounts(precisionStep, totalTermCountT, totalTermCountC);
if (VERBOSE && precisionStep != int.MaxValue)
{
Console.WriteLine("Average number of terms during random search on '" + field + "':");
Console.WriteLine(" Numeric query: " + (((double)totalTermCountT) / (num * 4)));
Console.WriteLine(" Classical query: " + (((double)totalTermCountC) / (num * 4)));
}
}