public virtual void TestRangeFilterRand()
{
IndexReader reader = signedIndexReader;
IndexSearcher search = NewSearcher(reader);
string minRP = Pad(signedIndexDir.minR);
string maxRP = Pad(signedIndexDir.maxR);
int numDocs = reader.NumDocs;
Assert.AreEqual(numDocs, 1 + maxId - minId, "num of docs");
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
// test extremes, bounded on both ends
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, maxRP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, maxRP, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but biggest");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, maxRP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but smallest");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, maxRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but extremes");
// unbounded
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "smallest and up");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", null, maxRP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "biggest and down");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not smallest, but up");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", null, maxRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not biggest, but down");
// very small sets
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, minRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", maxRP, maxRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", minRP, minRP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", null, minRP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", maxRP, maxRP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
result = search.Search(q, TermRangeFilter.NewStringRange("rand", maxRP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
}
public override void BeforeClass() // LUCENENET specific - renamed from TestBefore() to ensure calling order vs base class
{
base.BeforeClass();
// create an index
Directory indexStore = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random, indexStore);
long now = J2N.Time.CurrentTimeMilliseconds();
Document doc = new Document();
// add time that is in the past
doc.Add(NewStringField("datefield", DateTools.TimeToString(now - 1000, DateResolution.MILLISECOND), Field.Store.YES));
doc.Add(NewTextField("body", "Today is a very sunny day in New York City", Field.Store.YES));
writer.AddDocument(doc);
IndexReader reader = writer.GetReader();
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
// filter that should preserve matches
// DateFilter df1 = DateFilter.Before("datefield", now);
TermRangeFilter df1 = TermRangeFilter.NewStringRange("datefield", DateTools.TimeToString(now - 2000, DateResolution.MILLISECOND), DateTools.TimeToString(now, DateResolution.MILLISECOND), false, true);
// filter that should discard matches
// DateFilter df2 = DateFilter.Before("datefield", now - 999999);
TermRangeFilter df2 = TermRangeFilter.NewStringRange("datefield", DateTools.TimeToString(0, DateResolution.MILLISECOND), DateTools.TimeToString(now - 2000, DateResolution.MILLISECOND), true, false);
// search something that doesn't exist with DateFilter
Query query1 = new TermQuery(new Term("body", "NoMatchForthis"));
// search for something that does exists
Query query2 = new TermQuery(new Term("body", "sunny"));
ScoreDoc[] result;
// ensure that queries return expected results without DateFilter first
result = searcher.Search(query1, null, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, null, 1000).ScoreDocs;
Assert.AreEqual(1, result.Length);
// run queries with DateFilter
result = searcher.Search(query1, df1, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query1, df2, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, df1, 1000).ScoreDocs;
Assert.AreEqual(1, result.Length);
result = searcher.Search(query2, df2, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
reader.Dispose();
indexStore.Dispose();
}
public virtual void TestBefore()
{
// create an index
Directory indexStore = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), indexStore, Similarity, TimeZone);
long now = DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond;
Document doc = new Document();
// add time that is in the past
doc.Add(NewStringField("datefield", DateTools.TimeToString(now - 1000, DateTools.Resolution.MILLISECOND), Field.Store.YES));
doc.Add(NewTextField("body", "Today is a very sunny day in New York City", Field.Store.YES));
writer.AddDocument(doc);
IndexReader reader = writer.Reader;
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
// filter that should preserve matches
// DateFilter df1 = DateFilter.Before("datefield", now);
TermRangeFilter df1 = TermRangeFilter.NewStringRange("datefield", DateTools.TimeToString(now - 2000, DateTools.Resolution.MILLISECOND), DateTools.TimeToString(now, DateTools.Resolution.MILLISECOND), false, true);
// filter that should discard matches
// DateFilter df2 = DateFilter.Before("datefield", now - 999999);
TermRangeFilter df2 = TermRangeFilter.NewStringRange("datefield", DateTools.TimeToString(0, DateTools.Resolution.MILLISECOND), DateTools.TimeToString(now - 2000, DateTools.Resolution.MILLISECOND), true, false);
// search something that doesn't exist with DateFilter
Query query1 = new TermQuery(new Term("body", "NoMatchForthis"));
// search for something that does exists
Query query2 = new TermQuery(new Term("body", "sunny"));
ScoreDoc[] result;
// ensure that queries return expected results without DateFilter first
result = searcher.Search(query1, null, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, null, 1000).ScoreDocs;
Assert.AreEqual(1, result.Length);
// run queries with DateFilter
result = searcher.Search(query1, df1, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query1, df2, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, df1, 1000).ScoreDocs;
Assert.AreEqual(1, result.Length);
result = searcher.Search(query2, df2, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
reader.Dispose();
indexStore.Dispose();
}
public virtual void TestBefore()
{
// create an index
RAMDirectory indexStore = new RAMDirectory();
IndexWriter writer = new IndexWriter(indexStore, new SimpleAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED, null);
long now = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
Document doc = new Document();
// add time that is in the past
doc.Add(new Field("datefield", DateTools.TimeToString(now - 1000, DateTools.Resolution.MILLISECOND), Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("body", "Today is a very sunny day in New York City", Field.Store.YES, Field.Index.ANALYZED));
writer.AddDocument(doc, null);
writer.Optimize(null);
writer.Close();
IndexSearcher searcher = new IndexSearcher(indexStore, true, null);
// filter that should preserve matches
//DateFilter df1 = DateFilter.Before("datefield", now);
TermRangeFilter df1 = new TermRangeFilter("datefield", DateTools.TimeToString(now - 2000, DateTools.Resolution.MILLISECOND), DateTools.TimeToString(now, DateTools.Resolution.MILLISECOND), false, true);
// filter that should discard matches
//DateFilter df2 = DateFilter.Before("datefield", now - 999999);
TermRangeFilter df2 = new TermRangeFilter("datefield", DateTools.TimeToString(0, DateTools.Resolution.MILLISECOND), DateTools.TimeToString(now - 2000, DateTools.Resolution.MILLISECOND), true, false);
// search something that doesn't exist with DateFilter
Query query1 = new TermQuery(new Term("body", "NoMatchForThis"));
// search for something that does exists
Query query2 = new TermQuery(new Term("body", "sunny"));
ScoreDoc[] result;
// ensure that queries return expected results without DateFilter first
result = searcher.Search(query1, null, 1000, null).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, null, 1000, null).ScoreDocs;
Assert.AreEqual(1, result.Length);
// run queries with DateFilter
result = searcher.Search(query1, df1, 1000, null).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query1, df2, 1000, null).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, df1, 1000, null).ScoreDocs;
Assert.AreEqual(1, result.Length);
result = searcher.Search(query2, df2, 1000, null).ScoreDocs;
Assert.AreEqual(0, result.Length);
}
public virtual void TestBefore()
{
// create an index
RAMDirectory indexStore = new RAMDirectory();
IndexWriter writer = new IndexWriter(indexStore, new SimpleAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
long now = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
Document doc = new Document();
// add time that is in the past
doc.Add(new Field("datefield", DateTools.TimeToString(now - 1000, DateTools.Resolution.MILLISECOND), Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("body", "Today is a very sunny day in New York City", Field.Store.YES, Field.Index.ANALYZED));
writer.AddDocument(doc);
writer.Optimize();
writer.Close();
IndexSearcher searcher = new IndexSearcher(indexStore, true);
// filter that should preserve matches
//DateFilter df1 = DateFilter.Before("datefield", now);
TermRangeFilter df1 = new TermRangeFilter("datefield", DateTools.TimeToString(now - 2000, DateTools.Resolution.MILLISECOND), DateTools.TimeToString(now, DateTools.Resolution.MILLISECOND), false, true);
// filter that should discard matches
//DateFilter df2 = DateFilter.Before("datefield", now - 999999);
TermRangeFilter df2 = new TermRangeFilter("datefield", DateTools.TimeToString(0, DateTools.Resolution.MILLISECOND), DateTools.TimeToString(now - 2000, DateTools.Resolution.MILLISECOND), true, false);
// search something that doesn't exist with DateFilter
Query query1 = new TermQuery(new Term("body", "NoMatchForThis"));
// search for something that does exists
Query query2 = new TermQuery(new Term("body", "sunny"));
ScoreDoc[] result;
// ensure that queries return expected results without DateFilter first
result = searcher.Search(query1, null, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, null, 1000).ScoreDocs;
Assert.AreEqual(1, result.Length);
// run queries with DateFilter
result = searcher.Search(query1, df1, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query1, df2, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
result = searcher.Search(query2, df1, 1000).ScoreDocs;
Assert.AreEqual(1, result.Length);
result = searcher.Search(query2, df2, 1000).ScoreDocs;
Assert.AreEqual(0, result.Length);
}
private Filter GetRangeFilter(String field, String lowerPrice, String upperPrice, bool old)
{
Filter f = new TermRangeFilter(field, lowerPrice, upperPrice, true, true);
if (old)
{
return(GetOldBitSetFilter(f));
}
return(f);
}
public virtual void TestCSQ()
{
Query q1 = new ConstantScoreQuery(new TermQuery(new Term("a", "b")));
Query q2 = new ConstantScoreQuery(new TermQuery(new Term("a", "c")));
Query q3 = new ConstantScoreQuery(TermRangeFilter.NewStringRange("a", "b", "c", true, true));
QueryUtils.Check(q1);
QueryUtils.Check(q2);
QueryUtils.CheckEqual(q1, q1);
QueryUtils.CheckEqual(q2, q2);
QueryUtils.CheckEqual(q3, q3);
QueryUtils.CheckUnequal(q1, q2);
QueryUtils.CheckUnequal(q2, q3);
QueryUtils.CheckUnequal(q1, q3);
QueryUtils.CheckUnequal(q1, new TermQuery(new Term("a", "b")));
}
public void SetUp()
{
directory = new RAMDirectory();
IndexWriter writer =
new IndexWriter(directory, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.UNLIMITED);
DateTime cal = new DateTime(1041397200000L * TimeSpan.TicksPerMillisecond); // 2003 January 01
for (int i = 0; i < MAX; i++)
{
Document doc = new Document();
doc.Add(new Field("key", "" + (i + 1), Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("owner", (i < MAX / 2) ? "bob" : "sue", Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("date", (cal.Ticks / TimeSpan.TicksPerMillisecond).ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED));
writer.AddDocument(doc);
cal.AddMilliseconds(1);
}
writer.Close();
searcher = new IndexSearcher(directory, true);
// query for everything to make life easier
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("owner", "bob")), BooleanClause.Occur.SHOULD);
bq.Add(new TermQuery(new Term("owner", "sue")), BooleanClause.Occur.SHOULD);
query = bq;
// date filter matches everything too
//Date pastTheEnd = parseDate("2099 Jan 1");
// dateFilter = DateFilter.Before("date", pastTheEnd);
// just treat dates as strings and select the whole range for now...
dateFilter = new TermRangeFilter("date", "", "ZZZZ", true, true);
bobFilter = new QueryWrapperFilter(
new TermQuery(new Term("owner", "bob")));
sueFilter = new QueryWrapperFilter(
new TermQuery(new Term("owner", "sue")));
}
public override void SetUp()
{
base.SetUp();
directory = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), directory);
// we use the default Locale/TZ since LuceneTestCase randomizes it
var cal = new DateTime(1970, 1, 1, 0, 0, 0, (int)TestUtil.NextLong(Random(), 0, long.MaxValue), new GregorianCalendar());
for (int i = 0; i < Max; i++)
{
Document doc = new Document();
doc.Add(NewStringField("key", "" + (i + 1), Field.Store.YES));
doc.Add(NewStringField("owner", (i < Max / 2) ? "bob" : "sue", Field.Store.YES));
doc.Add(NewStringField("date", cal.ToString(CultureInfo.InvariantCulture), Field.Store.YES));
writer.AddDocument(doc);
cal = cal.AddDays(1);
}
reader = writer.Reader;
writer.Dispose();
searcher = NewSearcher(reader);
// query for everything to make life easier
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("owner", "bob")), BooleanClause.Occur.SHOULD);
bq.Add(new TermQuery(new Term("owner", "sue")), BooleanClause.Occur.SHOULD);
query = bq;
// date filter matches everything too
//Date pastTheEnd = parseDate("2099 Jan 1");
// dateFilter = DateFilter.Before("date", pastTheEnd);
// just treat dates as strings and select the whole range for now...
dateFilter = TermRangeFilter.NewStringRange("date", "", "ZZZZ", true, true);
bobFilter = new QueryWrapperFilter(new TermQuery(new Term("owner", "bob")));
sueFilter = new QueryWrapperFilter(new TermQuery(new Term("owner", "sue")));
}
public virtual void TestRangeFilterId()
{
IndexReader reader = signedIndexReader;
IndexSearcher search = NewSearcher(reader);
int medId = ((maxId - minId) / 2);
string minIP = Pad(minId);
string maxIP = Pad(maxId);
string medIP = Pad(medId);
int numDocs = reader.NumDocs;
Assert.AreEqual(numDocs, 1 + maxId - minId, "num of docs");
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
// test id, bounded on both ends
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, maxIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, maxIP, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but last");
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, maxIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but first");
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, maxIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
result = search.Search(q, TermRangeFilter.NewStringRange("id", medIP, maxIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, medIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
// unbounded id
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "min and up");
result = search.Search(q, TermRangeFilter.NewStringRange("id", null, maxIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "max and down");
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
result = search.Search(q, TermRangeFilter.NewStringRange("id", null, maxIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
result = search.Search(q, TermRangeFilter.NewStringRange("id", medIP, maxIP, T, F), numDocs).ScoreDocs;
Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, medIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
// very small sets
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, minIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
result = search.Search(q, TermRangeFilter.NewStringRange("id", medIP, medIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "med,med,F,F");
result = search.Search(q, TermRangeFilter.NewStringRange("id", maxIP, maxIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
result = search.Search(q, TermRangeFilter.NewStringRange("id", minIP, minIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
result = search.Search(q, TermRangeFilter.NewStringRange("id", null, minIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
result = search.Search(q, TermRangeFilter.NewStringRange("id", maxIP, maxIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
result = search.Search(q, TermRangeFilter.NewStringRange("id", maxIP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
result = search.Search(q, TermRangeFilter.NewStringRange("id", medIP, medIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
}
//private Filter GetOldBitSetFilter(Filter filter)
//{
// return new MockBooleanFilter(filter);
//}
private Filter GetRangeFilter(String field, String lowerPrice, String upperPrice, bool old)
{
Filter f = new TermRangeFilter(field, lowerPrice, upperPrice, true, true);
return f;
}
/// <summary>
/// Creates the price range query.
/// </summary>
/// <param name="priceLists">The price lists.</param>
/// <param name="index">The index.</param>
/// <param name="field">The field.</param>
/// <param name="currency">The currency.</param>
/// <param name="lowerbound">The lowerbound.</param>
/// <param name="upperbound">The upperbound.</param>
/// <param name="lowerboundincluded">
/// if set to <c>true</c> [lowerboundincluded].
/// </param>
/// <param name="upperboundincluded">
/// if set to <c>true</c> [upperboundincluded].
/// </param>
/// <returns></returns>
private static BooleanFilter CreatePriceRangeQuery(
string[] priceLists,
int index,
string field,
string currency,
string lowerbound,
string upperbound,
bool lowerboundincluded,
bool upperboundincluded)
{
var query = new BooleanFilter();
// create left part
var filter =
new TermRangeFilter(
string.Format(CultureInfo.InvariantCulture, "{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
"*",
"*",
true,
false);
var leftClause = new FilterClause(filter, Occur.MUST_NOT);
query.Add(leftClause);
// create right part
if (index == priceLists.Length) // last element
{
//var rangefilter = NumericRangeFilter.;
var filter2 =
new TermRangeFilter(
string.Format(CultureInfo.InvariantCulture, "{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded);
var rightClause = new FilterClause(filter2, Occur.MUST);
query.Add(rightClause);
}
else
{
query.Add(new FilterClause(
CreatePriceRangeQuery(
priceLists,
index + 1,
field,
currency,
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded),
Occur.SHOULD));
}
return query;
}
/// <summary>
/// Creates the query.
/// </summary>
/// <param name="criteria">The search criteria.</param>
/// <param name="field">The field.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public static Filter CreateQuery(ISearchCriteria criteria, string field, RangeFilterValue value)
{
var query = new BooleanFilter();
object lowerbound = value.Lower;
object upperbound = value.Upper;
const bool lowerboundincluded = true;
const bool upperboundincluded = false;
var currency = criteria.Currency.ToLower();
var upper = upperbound == null ? NumericUtils.LongToPrefixCoded(long.MaxValue) : ConvertToSearchable(upperbound);
// format is "fieldname_store_currency_pricelist"
string[] pls = null;
var searchCriteria = criteria as CatalogIndexedSearchCriteria;
if (searchCriteria != null)
{
pls = searchCriteria.Pricelists;
}
// Create filter of type
// price_USD_pricelist1:[100 TO 200} (-price_USD_pricelist1:[* TO *} +(price_USD_pricelist2:[100 TO 200} (-price_USD_pricelist2:[* TO *} (+price_USD_pricelist3[100 TO 200}))))
if (pls == null || !pls.Any())
{
return null;
}
var priceListId = pls[0].ToLower();
var filter = new TermRangeFilter(
string.Format(CultureInfo.InvariantCulture, "{0}_{1}_{2}", field, currency, priceListId),
ConvertToSearchable(lowerbound),
upper,
lowerboundincluded,
upperboundincluded);
query.Add(new FilterClause(filter, Occur.SHOULD));
if (pls.Length > 1)
{
var q = CreatePriceRangeQuery(
pls,
1,
field,
currency,
ConvertToSearchable(lowerbound),
upper,
lowerboundincluded,
upperboundincluded);
query.Add(new FilterClause(q, Occur.SHOULD));
}
return query;
}
/// <summary>
/// Creates the query.
/// </summary>
/// <param name="field">The field.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public static Filter CreateTermRangeFilter(string field, RangeFilterValue value)
{
object lowerbound = value.Lower;
object upperbound = value.Upper;
var query = new TermRangeFilter(field, ConvertToSearchable(lowerbound), ConvertToSearchable(upperbound), true, false);
return query;
}
private Filter GetRangeFilter(String field, String lowerPrice, String upperPrice)
{
Filter f = new TermRangeFilter(field, lowerPrice, upperPrice, true, true);
return(f);
}
private Filter GetRangeFilter(String field, String lowerPrice, String upperPrice, bool old)
{
Filter f = new TermRangeFilter(field, lowerPrice, upperPrice, true, true);
if (old)
{
return GetOldBitSetFilter(f);
}
return f;
}