/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="searchCriteria"></param>
/// <return></return>
private void getQueryFromCriteria(SearchCriteria searchCriteria)
{
if (searchCriteria.SearchCriteriaList.Count() > 0)
{
bexisSearching = new BooleanQuery();
foreach (SearchCriterion sco in searchCriteria.SearchCriteriaList)
{
if (sco.Values.Count > 0)
{
if (sco.SearchComponent.Type.Equals(SearchComponentBaseType.General))
{
String fieldName = sco.SearchComponent.Name;
BooleanQuery bexisSearchingGeneral = new BooleanQuery();
foreach (String value in sco.Values)
{
String encodedValue = value;
Query query = new TermQuery(new Term(fieldName, encodedValue));
bexisSearchingGeneral.Add(query, Occur.SHOULD);
}
((BooleanQuery)bexisSearching).Add(bexisSearchingGeneral, Occur.MUST);
}
else if (sco.SearchComponent.Type.Equals(SearchComponentBaseType.Category))
{
BooleanQuery bexisSearchingCategory = new BooleanQuery();
String fieldName = "category_" + sco.SearchComponent.Name;
QueryParser parser;
if (fieldName.ToLower().Equals("category_all"))
{
List <string> temp2 = BexisIndexSearcher.getCategoryFields().ToList();
temp2.AddRange(BexisIndexSearcher.getStoredFields().ToList());
temp2.Add("ng_all");
parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, temp2.ToArray(), new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
}
else
{
parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, fieldName, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
}
foreach (String value in sco.Values)
{
String encodedValue = EncoderHelper.Encode(value);
String newString = null;
//string value = val.Replace(")", "").Replace("(", "");
char[] delimiter = new char[] { ';', ' ', ',', '!', '.' };
string[] parts = encodedValue.ToLower().Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < parts.Length; i++)
{
newString = newString + " " + parts[i] + "~0.6";
}
parser.PhraseSlop = 5;
parser.DefaultOperator = QueryParser.AND_OPERATOR;
string query_value = encodedValue;
if (encodedValue.Equals(""))
{
query_value = "*:*";
}
Query query = parser.Parse(query_value);
bexisSearchingCategory.Add(query, Occur.SHOULD);
}
((BooleanQuery)bexisSearching).Add(bexisSearchingCategory, Occur.MUST);
}
else if (sco.SearchComponent.Type.Equals(SearchComponentBaseType.Facet))
{
String fieldName = "facet_" + sco.SearchComponent.Name;
BooleanQuery bexisSearchingFacet = new BooleanQuery();
foreach (String value in sco.Values)
{
String encodedValue = value;
Query query = new TermQuery(new Term(fieldName, encodedValue));
bexisSearchingFacet.Add(query, Occur.SHOULD);
}
((BooleanQuery)bexisSearching).Add(bexisSearchingFacet, Occur.MUST);
}
else if (sco.SearchComponent.Type.Equals(SearchComponentBaseType.Property))
{
String fieldName = "property_" + sco.SearchComponent.Name;
Property pp = (Property)sco.SearchComponent;
if (pp.UIComponent.ToLower().Equals("range"))
{
fieldName = "property_numeric_" + sco.SearchComponent.Name;
DateTime dd = new DateTime(Int32.Parse(sco.Values[0]), 1, 1, 1, 1, 1);
if (pp.Direction == Direction.increase)
{
NumericRangeQuery <long> dateRangeQuery = NumericRangeQuery.NewLongRange(fieldName, dd.Ticks, long.MaxValue, true, true);
((BooleanQuery)bexisSearching).Add(dateRangeQuery, Occur.MUST);
}
else
{
NumericRangeQuery <long> dateRangeQuery = NumericRangeQuery.NewLongRange(fieldName, long.MinValue, dd.Ticks, true, true);
((BooleanQuery)bexisSearching).Add(dateRangeQuery, Occur.MUST);
}
}
else
{
BooleanQuery bexisSearchingProperty = new BooleanQuery();
foreach (String value in sco.Values)
{
if (value.ToLower().Equals("all"))
{
Query query = new MatchAllDocsQuery();
bexisSearchingProperty.Add(query, Occur.SHOULD);
}
else
{
String encodedValue = value;
if (SearchConfig.getNumericProperties().Contains(sco.SearchComponent.Name.ToLower()))
{
}
else
{
Query query = new TermQuery(new Term(fieldName, encodedValue));
bexisSearchingProperty.Add(query, Occur.SHOULD);
}
}
}
((BooleanQuery)bexisSearching).Add(bexisSearchingProperty, Occur.MUST);
}
}
}
else
{
//do nothing yet
}
}
}
else
{
using (var sa = new SimpleAnalyzer())
{
QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "id", sa);
bexisSearching = parser.Parse("*:*");
}
}
}
public async Task <SearchResults <PublicScheme> > SearchSchemesAsync(SearchOptions options, CancellationToken cancellationToken = default)
{
var shoulds = new List <QueryBase>();
if (!string.IsNullOrWhiteSpace(options.Query))
{
shoulds.Add(new SimpleQueryStringQuery
{
Query = options.Query,
Fields = new[] {
nameof(PublicScheme.Name).ToUpper() + "^3",
nameof(PublicScheme.Description).ToUpper() + "^2",
nameof(PublicScheme.PublisherName).ToUpper()
},
Boost = 1.5
});
}
var filters = new List <QueryBase>();
if (options.Side != SchemeSide.any)
{
var rangeQuery = new NumericRangeQuery
{
Field = $"{nameof(PublicScheme.ColorScheme)}.{nameof(ColorScheme.backgroundLightnessLimit)}".ToUpper(),
};
switch (options.Side)
{
case SchemeSide.dark:
rangeQuery.LessThan = 30;
break;
case SchemeSide.light:
rangeQuery.GreaterThan = 70;
break;
}
filters.Add(rangeQuery);
}
if (options.Bg != HueFilter.any)
{
var bgSatField = $"{nameof(PublicScheme.ColorScheme)}.{nameof(ColorScheme.backgroundGraySaturation)}".ToUpper();
if (options.Bg == HueFilter.gray)
{
var grayFilter = new NumericRangeQuery
{
Field = bgSatField,
LessThan = 10
};
filters.Add(grayFilter);
var noBlueFilter = new NumericRangeQuery
{
Field = $"{nameof(PublicScheme.ColorScheme)}.{nameof(ColorScheme.blueFilter)}".ToUpper(),
LessThan = 5
};
filters.Add(noBlueFilter);
}
else
{
var notGrayFilter = new NumericRangeQuery
{
Field = bgSatField,
GreaterThan = 1
};
filters.Add(notGrayFilter);
if (options.Bg == HueFilter.red)
{
var field = $"{nameof(PublicScheme.ColorScheme)}.{nameof(ColorScheme.backgroundGrayHue)}".ToUpper();
var redFilter = new BoolQuery
{
MinimumShouldMatch = 1,
Should = new[] {
new QueryContainer(new NumericRangeQuery {
Field = field,
GreaterThanOrEqualTo = 330
}),
new QueryContainer(new NumericRangeQuery {
Field = field,
LessThanOrEqualTo = 30
})
}
};
filters.Add(redFilter);
}
else
{
var rangeQuery = new NumericRangeQuery
{
Field = $"{nameof(PublicScheme.ColorScheme)}.{nameof(ColorScheme.backgroundGrayHue)}".ToUpper(),
};
switch (options.Bg)
{
case HueFilter.yellow:
rangeQuery.GreaterThanOrEqualTo = 30;
rangeQuery.LessThanOrEqualTo = 90;
break;
case HueFilter.green:
rangeQuery.GreaterThanOrEqualTo = 90;
rangeQuery.LessThanOrEqualTo = 150;
break;
case HueFilter.cyan:
rangeQuery.GreaterThanOrEqualTo = 150;
rangeQuery.LessThanOrEqualTo = 210;
break;
case HueFilter.blue:
rangeQuery.GreaterThanOrEqualTo = 210;
rangeQuery.LessThanOrEqualTo = 270;
break;
case HueFilter.purple:
rangeQuery.GreaterThanOrEqualTo = 270;
rangeQuery.LessThanOrEqualTo = 330;
break;
default:
break;
}
filters.Add(rangeQuery);
}
}
}
if (!string.IsNullOrWhiteSpace(options.CurrentUserId))
{
switch (options.List)
{
case SchemeList.my:
filters.Add(new MatchPhraseQuery
{
Field = nameof(PublicScheme.PublisherId).ToUpper(),
Query = options.CurrentUserId
});
break;
case SchemeList.fav:
filters.Add(new MatchPhraseQuery
{
Field = nameof(PublicScheme.FavoritedBy).ToUpper(),
Query = options.CurrentUserId
});
break;
case SchemeList.liked:
filters.Add(new MatchPhraseQuery
{
Field = nameof(PublicScheme.LikedBy).ToUpper(),
Query = options.CurrentUserId
});
break;
default:
break;
}
}
else if (new[] { SchemeList.my, SchemeList.fav, SchemeList.liked }.Contains(options.List))
{
filters.Add(new MatchNoneQuery());
}
if (new[] { SchemeList.com, SchemeList.ml }.Contains(options.List))
{
filters.Add(new TermQuery
{
Field = nameof(PublicScheme.PublisherCommunity).ToUpper(),
Value = options.List == SchemeList.com
});
}
var results = await this.elasticClient.SearchAsync <PublicScheme>(s =>
{
var query = s.Query(q => filters.Count > 0 || shoulds.Count > 0
? q.Bool(cs =>
{
var boolQuery = cs;
if (filters.Count > 0)
{
boolQuery = boolQuery
.Filter(filters.Select(f => new QueryContainer(f)).ToArray());
}
if (shoulds.Count > 0)
{
boolQuery = boolQuery
.Should(shoulds.Select(f => new QueryContainer(f)).ToArray())
.MinimumShouldMatch(MinimumShouldMatch.Fixed(1));
}
return(boolQuery);
})
: q.MatchAll());
if (!string.IsNullOrWhiteSpace(options.Cursor))
{
query = query.SearchAfter(Encoding.UTF8
.GetString(Convert
.FromBase64String(options.Cursor))
.Split(',')
.ToArray());
}
return(query
.Sort(ss => ss
.Descending(SortSpecialField.Score)
.Field(f => f
.Field(nameof(PublicScheme.Likes).ToUpper())
.Order(SortOrder.Descending)
.UnmappedType(FieldType.Integer)
.MissingLast())
.Field(f => f
.Field(nameof(PublicScheme.Favorites).ToUpper())
.Order(SortOrder.Descending)
.UnmappedType(FieldType.Integer)
.MissingLast())
.Ascending(SortSpecialField.DocumentIndexOrder))
.Size(options.PageSize));
}, cancellationToken);
if (results.IsValid)
{
return(new SearchResults <PublicScheme>
{
Done = results.Documents.Count() < options.PageSize,
Results = results.Documents,
Cursor = Convert
.ToBase64String(Encoding.UTF8
.GetBytes(string
.Join(',', results.Hits.LastOrDefault()?.Sorts ?? new object[] { })))
});
}
throw new ApplicationException("Failed to query color schemes.",
results.OriginalException ?? new Exception(results.ServerError.Error.Reason));
}
public virtual void TestRandomDoubles()
{
Directory dir = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
int numDocs = AtLeast(1000);
double[] values = new double[numDocs];
double minValue = double.PositiveInfinity;
double maxValue = double.NegativeInfinity;
for (int i = 0; i < numDocs; i++)
{
Document doc = new Document();
double v = Random().NextDouble();
values[i] = v;
doc.Add(new DoubleDocValuesField("field", v));
doc.Add(new DoubleField("field", v, Field.Store.NO));
w.AddDocument(doc);
minValue = Math.Min(minValue, v);
maxValue = Math.Max(maxValue, v);
}
IndexReader r = w.Reader;
IndexSearcher s = NewSearcher(r);
FacetsConfig config = new FacetsConfig();
int numIters = AtLeast(10);
for (int iter = 0; iter < numIters; iter++)
{
if (VERBOSE)
{
Console.WriteLine("TEST: iter=" + iter);
}
int numRange = TestUtil.NextInt(Random(), 1, 5);
DoubleRange[] ranges = new DoubleRange[numRange];
int[] expectedCounts = new int[numRange];
double minAcceptedValue = double.PositiveInfinity;
double maxAcceptedValue = double.NegativeInfinity;
for (int rangeID = 0; rangeID < numRange; rangeID++)
{
double min;
if (rangeID > 0 && Random().Next(10) == 7)
{
// Use an existing boundary:
DoubleRange prevRange = ranges[Random().Next(rangeID)];
if (Random().NextBoolean())
{
min = prevRange.Min;
}
else
{
min = prevRange.Max;
}
}
else
{
min = Random().NextDouble();
}
double max;
if (rangeID > 0 && Random().Next(10) == 7)
{
// Use an existing boundary:
DoubleRange prevRange = ranges[Random().Next(rangeID)];
if (Random().NextBoolean())
{
max = prevRange.Min;
}
else
{
max = prevRange.Max;
}
}
else
{
max = Random().NextDouble();
}
if (min > max)
{
double x = min;
min = max;
max = x;
}
bool minIncl;
bool maxIncl;
if (min == max)
{
minIncl = true;
maxIncl = true;
}
else
{
minIncl = Random().NextBoolean();
maxIncl = Random().NextBoolean();
}
ranges[rangeID] = new DoubleRange("r" + rangeID, min, minIncl, max, maxIncl);
// Do "slow but hopefully correct" computation of
// expected count:
for (int i = 0; i < numDocs; i++)
{
bool accept = true;
if (minIncl)
{
accept &= values[i] >= min;
}
else
{
accept &= values[i] > min;
}
if (maxIncl)
{
accept &= values[i] <= max;
}
else
{
accept &= values[i] < max;
}
if (accept)
{
expectedCounts[rangeID]++;
minAcceptedValue = Math.Min(minAcceptedValue, values[i]);
maxAcceptedValue = Math.Max(maxAcceptedValue, values[i]);
}
}
}
FacetsCollector sfc = new FacetsCollector();
s.Search(new MatchAllDocsQuery(), sfc);
Filter fastMatchFilter;
if (Random().NextBoolean())
{
if (Random().NextBoolean())
{
fastMatchFilter = NumericRangeFilter.NewDoubleRange("field", minValue, maxValue, true, true);
}
else
{
fastMatchFilter = NumericRangeFilter.NewDoubleRange("field", minAcceptedValue, maxAcceptedValue, true, true);
}
}
else
{
fastMatchFilter = null;
}
ValueSource vs = new DoubleFieldSource("field");
Facets facets = new DoubleRangeFacetCounts("field", vs, sfc, fastMatchFilter, ranges);
FacetResult result = facets.GetTopChildren(10, "field");
Assert.AreEqual(numRange, result.LabelValues.Length);
for (int rangeID = 0; rangeID < numRange; rangeID++)
{
if (VERBOSE)
{
Console.WriteLine(" range " + rangeID + " expectedCount=" + expectedCounts[rangeID]);
}
LabelAndValue subNode = result.LabelValues[rangeID];
Assert.AreEqual("r" + rangeID, subNode.Label);
Assert.AreEqual(expectedCounts[rangeID], (int)subNode.Value);
DoubleRange range = ranges[rangeID];
// Test drill-down:
DrillDownQuery ddq = new DrillDownQuery(config);
if (Random().NextBoolean())
{
if (Random().NextBoolean())
{
ddq.Add("field", NumericRangeFilter.NewDoubleRange("field", range.Min, range.Max, range.MinInclusive, range.MaxInclusive));
}
else
{
ddq.Add("field", NumericRangeQuery.NewDoubleRange("field", range.Min, range.Max, range.MinInclusive, range.MaxInclusive));
}
}
else
{
ddq.Add("field", range.GetFilter(fastMatchFilter, vs));
}
Assert.AreEqual(expectedCounts[rangeID], s.Search(ddq, 10).TotalHits);
}
}
IOUtils.Close(w, r, dir);
}
public ISearchBuilder WithField(string field, double value)
{
CreatePendingClause();
_query = NumericRangeQuery.NewDoubleRange(field, value, value, true, true);
return(this);
}
private void AddRulles(BooleanQuery q, List <FilterRule> filterRules, Occur cond)
{
foreach (var rule in filterRules)
{
string fieldName = rule.Field;
if (fieldName == "id")
{
fieldName = "$id";
}
if (fieldName == "userid")
{
fieldName = "$userid";
}
if (rule.FieldOperator == OperatorEnum.EQUAL)
{
if (rule.FieldType == FieldTypeEnum.BOOLEAN)
{
int ival = rule.Value.AsBoolean ? 1 : 0;
q.Add(NumericRangeQuery.NewIntRange(fieldName, ival, ival, true, true), cond);
}
else if (rule.FieldType == FieldTypeEnum.FLOAT)
{
float fval = rule.Value.AsFloat;
q.Add(NumericRangeQuery.NewFloatRange(fieldName, fval, fval, true, true), cond);
}
else if (rule.FieldType == FieldTypeEnum.STRING || rule.FieldType == FieldTypeEnum.TEXT || rule.FieldType == FieldTypeEnum.HTML)
{
q.Add(LuceneController.ParseQuery(rule.Value.AsString + "*", fieldName), cond);
}
else
{
string searchstring = QueryParser.Escape(rule.Value.AsString);
q.Add(new TermQuery(new Term(fieldName, searchstring)), cond);
}
}
else if (rule.FieldOperator == OperatorEnum.NOT_EQUAL)
{
q.Add(new TermQuery(new Term(fieldName, rule.Value.AsString)), Occur.MUST_NOT);
}
else if (rule.FieldOperator == OperatorEnum.START_WITH)
{
if (rule.FieldType == FieldTypeEnum.STRING || rule.FieldType == FieldTypeEnum.TEXT || rule.FieldType == FieldTypeEnum.HTML)
{
q.Add(LuceneController.ParseQuery(rule.Value.AsString + "*", fieldName), cond);
}
else
{
q.Add(new WildcardQuery(new Term(fieldName, rule.Value.AsString + "*")), cond);
}
}
else if (rule.FieldOperator == OperatorEnum.IN)
{
BooleanQuery arrQ = new BooleanQuery();
foreach (var arrItem in rule.MultiValue)
{
arrQ.Add(new TermQuery(new Term(fieldName, QueryParser.Escape(arrItem.AsString))), Occur.SHOULD); // OR
/*
* var phraseQ = new PhraseQuery();
* phraseQ.Add(new Term(fieldName, arrItem.AsString));
* arrQ.Add(phraseQ, Occur.SHOULD); // OR
*/
}
q.Add(arrQ, cond);
}
else if (rule.FieldOperator == OperatorEnum.BETWEEN)
{
if (rule.FieldType == FieldTypeEnum.DATETIME)
{
var startDate = rule.LowerValue.AsDateTime;
var endDate = rule.UpperValue.AsDateTime;
q.Add(NumericRangeQuery.NewLongRange(fieldName, startDate.Ticks, endDate.Ticks, true, true), cond);
}
}
else if (rule.FieldOperator == OperatorEnum.GREATER_THEN_OR_EQUALS)
{
DateTime startDate = rule.Value.AsDateTime;
DateTime endDate = DateTime.MaxValue;
q.Add(NumericRangeQuery.NewLongRange(fieldName, startDate.Ticks, endDate.Ticks, true, true), cond);
}
else if (rule.FieldOperator == OperatorEnum.LESS_THEN_OR_EQUALS)
{
if (rule.FieldType == FieldTypeEnum.DATETIME)
{
DateTime startDate = DateTime.MinValue;
DateTime endDate = rule.Value.AsDateTime;
q.Add(NumericRangeQuery.NewLongRange(fieldName, startDate.Ticks, endDate.Ticks, true, true), cond);
}
}
else if (rule.FieldOperator == OperatorEnum.GREATER_THEN)
{
}
else if (rule.FieldOperator == OperatorEnum.LESS_THEN)
{
}
}
}
/// <summary>
/// 构建查询条件
/// </summary>
/// <param name="fields"></param>
/// <returns>{item1:must,item2:should}</returns>
public ESConditionModel BuildQueryContainer(List <ESField> fields, string analyzer)
{
List <QueryContainer> must = new List <QueryContainer>(),
should = new List <QueryContainer>(),
mustNot = new List <QueryContainer>();
if (fields != null && fields.Count > 0)
{
foreach (var item in fields)
{
QueryContainer container = null;
//1.数据类型辨析（暂时不做实现）
if (item.DataType == ESDataType.GeoPoint)
{
//switch (item.QueryType)
//{
// case ESQueryType.Geo_Distance:
// container = new GeoDistanceQuery()
// {
// Location = new GeoLocation(0.1, 0.2),
// Distance =new Distance(),
// };
// break;
// case ESQueryType.Geo_Polygon:
// container = new GeoPolygonQuery(){
// Points=,
// };
// break;
// case ESQueryType.Geo_Bounding_Box:
// container = new GeoBoundingBoxQuery()
// {
// BoundingBox = new BoundingBox()
// {
// BottomRight =,
// TopLeft =,
// }
// };
// break;
//}
}
else
{
switch (item.QueryType)
{
case ESQueryType.Match:
container = new MatchQuery()
{
Analyzer = analyzer,
Field = item.Key,
Query = item.Value.Item1.ToString(),
};
break;
case ESQueryType.All:
container = new MatchAllQuery()
{
};
break;
case ESQueryType.Match_Phrase:
container = new MatchPhraseQuery()
{
Field = item.Key,
Analyzer = analyzer,
Query = item.Value.Item1.ToString()
};
break;
case ESQueryType.Match_Phrase_Prefix:
container = new MatchPhrasePrefixQuery()
{
Field = item.Key,
Analyzer = analyzer,
Query = item.Value.ToString()
};
break;
case ESQueryType.Term:
container = new TermQuery()
{
Field = item.Key,
Value = item.Value.Item1
};
break;
case ESQueryType.Range:
switch (item.DataType)
{
case ESDataType.Text:
break;
case ESDataType.Number:
container = new NumericRangeQuery()
{
Field = item.Key,
GreaterThanOrEqualTo = Convert.ToDouble(item.Value.Item1),
LessThanOrEqualTo = Convert.ToDouble(item.Value.Item2),
};
break;
case ESDataType.Date:
container = new DateRangeQuery()
{
Field = item.Key,
GreaterThanOrEqualTo = DateMath.FromString(item.Value.Item1.ToString()),
LessThanOrEqualTo = DateMath.FromString(item.Value.Item2.ToString())
};
break;
default:
break;
}
break;
}
}
//2.条件类型解析
if (container != null)
{
switch (item.ConditionType)
{
case ESConditionType.Must:
must.Add(container);
break;
case ESConditionType.Should:
should.Add(container);
break;
case ESConditionType.MustNot:
mustNot.Add(container);
break;
default:
break;
}
}
}
}
return(new ESConditionModel()
{
Must = must,
Should = should,
MustNot = mustNot
});
}
private List <string> SendSearchRequest(FilterModel sc)
{
//bool
QueryContainer boolQuery = new BoolQuery()
{
};
//must
List <QueryContainer> mustquerys = new List <QueryContainer>();
//should
List <QueryContainer> shouldquerys = new List <QueryContainer>();
int lastCommand = 0;
// create Query
foreach (var searchModel in sc.SearchModels)
{
QueryContainer qc = new QueryContainer();
if (searchModel.Field.ToLower() == "any")
{
searchModel.Field = "_all";
}
// if Contains => search Text
if (searchModel.Oper == (int)Oper.Contains)
{
qc = new TermQuery()
{
Field = searchModel.Field, Value = searchModel.Text.ToLower()
};
}
// if Less,Equal,Greater => search Number
if (Enum.IsDefined(typeof(Oper), searchModel.Oper) && searchModel.Oper != (int)Oper.Contains)
{
double d = 0;
Double.TryParse(searchModel.Text, out d);
if (searchModel.Oper == (int)Oper.Equal)
{
qc = new NumericRangeQuery()
{
Field = searchModel.Field, GreaterThanOrEqualTo = d, LessThanOrEqualTo = d
};
}
if (searchModel.Oper == (int)Oper.Less)
{
qc = new NumericRangeQuery()
{
Field = searchModel.Field, LessThan = d
};
}
if (searchModel.Oper == (int)Oper.Greater)
{
qc = new NumericRangeQuery()
{
Field = searchModel.Field, GreaterThan = d
};
}
}
if (lastCommand == 0 && searchModel.NextOper == (int)OperForNext.And)
{
mustquerys.Add(qc);
}
if (lastCommand == 0 && searchModel.NextOper == (int)OperForNext.Or)
{
shouldquerys.Add(qc);
}
// if And => Must
if (lastCommand == (int)OperForNext.And)
{
mustquerys.Add(qc);
}
// if Or => Should
if (lastCommand == (int)OperForNext.Or)
{
shouldquerys.Add(qc);
}
lastCommand = searchModel.NextOper;
}
// ALL quries
boolQuery = new BoolQuery()
{
Must = mustquerys, Should = shouldquerys
};
var r = new SearchRequest()
{
Size = 100,
//MinScore = 0.5,
Query = boolQuery
};
// send request
var resultPaths = GetPaths(sc.Category, r);
return(resultPaths);
}
private Tuple <int, IList <SearchResult> > GetResults(SearchQuery searchQuery)
{
Requires.NotNull("Query", searchQuery);
Requires.PropertyNotEqualTo("searchQuery", "SearchTypeIds", searchQuery.SearchTypeIds.Count(), 0);
if ((searchQuery.ModuleId > 0) && (searchQuery.SearchTypeIds.Count() > 1 || !searchQuery.SearchTypeIds.Contains(_moduleSearchTypeId)))
{
throw new ArgumentException(Localization.Localization.GetExceptionMessage("ModuleIdMustHaveSearchTypeIdForModule", "ModuleId based search must have SearchTypeId for a module only"));
}
if (searchQuery.SortField == SortFields.CustomStringField || searchQuery.SortField == SortFields.CustomNumericField ||
searchQuery.SortField == SortFields.NumericKey || searchQuery.SortField == SortFields.Keyword)
{
Requires.NotNullOrEmpty("CustomSortField", searchQuery.CustomSortField);
}
//TODO - Explore Slop factor for Phrase query
var query = new BooleanQuery();
if (!string.IsNullOrEmpty(searchQuery.KeyWords))
{
try
{
var keywords = SearchHelper.Instance.RephraseSearchText(searchQuery.KeyWords, searchQuery.WildCardSearch);
// don't use stemming analyzer for exact matches or non-analyzed fields (e.g. Tags)
var analyzer = LuceneController.Instance.GetCustomAnalyzer() ?? new SearchQueryAnalyzer(true);
var nonStemmerAnalyzer = new SearchQueryAnalyzer(false);
var keywordQuery = new BooleanQuery();
foreach (var fieldToSearch in Constants.KeyWordSearchFields)
{
var parserContent = new QueryParser(Constants.LuceneVersion, fieldToSearch,
fieldToSearch == Constants.Tag ? nonStemmerAnalyzer : analyzer);
var parsedQueryContent = parserContent.Parse(keywords);
keywordQuery.Add(parsedQueryContent, Occur.SHOULD);
}
query.Add(keywordQuery, Occur.MUST);
}
catch (Exception)
{
foreach (var word in searchQuery.KeyWords.Split(' '))
{
query.Add(new TermQuery(new Term(Constants.ContentTag, word.ToLower())), Occur.SHOULD);
}
}
}
var portalIdQuery = new BooleanQuery();
foreach (var portalId in searchQuery.PortalIds)
{
portalIdQuery.Add(NumericRangeQuery.NewIntRange(Constants.PortalIdTag, portalId, portalId, true, true), Occur.SHOULD);
}
if (searchQuery.PortalIds.Any())
{
query.Add(portalIdQuery, Occur.MUST);
}
ApplySearchTypeIdFilter(query, searchQuery);
if (searchQuery.BeginModifiedTimeUtc > DateTime.MinValue && searchQuery.EndModifiedTimeUtc >= searchQuery.BeginModifiedTimeUtc)
{
query.Add(NumericRangeQuery.NewLongRange(Constants.ModifiedTimeTag, long.Parse(searchQuery.BeginModifiedTimeUtc.ToString(Constants.DateTimeFormat)), long.Parse(searchQuery.EndModifiedTimeUtc.ToString(Constants.DateTimeFormat)), true, true), Occur.MUST);
}
if (searchQuery.RoleId > 0)
{
query.Add(NumericRangeQuery.NewIntRange(Constants.RoleIdTag, searchQuery.RoleId, searchQuery.RoleId, true, true), Occur.MUST);
}
foreach (var tag in searchQuery.Tags)
{
query.Add(new TermQuery(new Term(Constants.Tag, tag.ToLower())), Occur.MUST);
}
if (!string.IsNullOrEmpty(searchQuery.CultureCode))
{
var localeQuery = new BooleanQuery();
var languageId = Localization.Localization.GetCultureLanguageID(searchQuery.CultureCode);
localeQuery.Add(NumericRangeQuery.NewIntRange(Constants.LocaleTag, languageId, languageId, true, true), Occur.SHOULD);
localeQuery.Add(NumericRangeQuery.NewIntRange(Constants.LocaleTag, Null.NullInteger, Null.NullInteger, true, true), Occur.SHOULD);
query.Add(localeQuery, Occur.MUST);
}
var luceneQuery = new LuceneQuery
{
Query = query,
Sort = GetSort(searchQuery),
PageIndex = searchQuery.PageIndex,
PageSize = searchQuery.PageSize,
TitleSnippetLength = searchQuery.TitleSnippetLength,
BodySnippetLength = searchQuery.BodySnippetLength
};
return(GetSecurityTrimmedResults(searchQuery, luceneQuery));
}
/// <summary> /// 设置大于操作 /// </summary> /// <param name="condition">查询条件</param> /// <param name="min">最小值</param> protected override void SetGreater(NumericRangeQuery condition, double?min) => condition.GreaterThan = min;
/// <summary> /// 设置小于操作 /// </summary> /// <param name="condition">查询条件</param> /// <param name="max">最大值</param> protected override void SetLess(NumericRangeQuery condition, double?max) => condition.LessThan = max;
/// <summary> /// 设置字段 /// </summary> /// <param name="condition">查询条件</param> /// <param name="field">字段</param> protected override void SetField(NumericRangeQuery condition, Field field) => condition.Field = field;
/// <summary>
/// Returns entity from repository by numeric Id
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="id">Id</param>
/// <returns></returns>
public TEntity GetById <TEntity>(int id) where TEntity : class
{
Query queryGet = NumericRangeQuery.NewInt64Range(IDField, id, id, true, true);
return(ProceedQuery <TEntity>(queryGet));
}
private QueryContainer VisitOperator(PredicateNode node)
{
var value = (Operator)node.Value;
var op1 = (Operand)node.Children[0].Value;
var op2 = (Operand)node.Children[1].Value;
if (op1.OperandType != OperandType.Property)
{
throw new Exception("First operand must be a property");
}
var prop1Name = (string)op1.Value;
var prop1Details = _propertyDetailsProvider.GetPropertyDetails(prop1Name);
if (prop1Details == null)
{
throw new Exception($"Property {prop1Name} does not exist");
}
if (op2.OperandType == OperandType.Property)
{
throw new Exception("Secon operand cannot be a property");
}
switch (value)
{
case Operator.Contains:
if (op2.OperandType != OperandType.String)
{
throw new Exception("Second operand must be string");
}
return(new QueryContainer(new MatchQuery
{
Query = (string)op2.Value,
Field = prop1Details.SourceName
}));
case Operator.Equal:
// can be a string or number
return(new QueryContainer(new MatchQuery
{
Query = (string)op2.Value,
Field = prop1Details.SourceName
}));
case Operator.NotEqual:
return(!(new QueryContainer(new MatchQuery
{
Query = (string)op2.Value,
Field = prop1Details.SourceName
})));
case Operator.LessThan:
case Operator.LessThanEqual:
case Operator.GreaterThan:
case Operator.GreaterThanEqual:
if (op2.OperandType != OperandType.Number)
{
throw new Exception($"Second operator {op2.Value} must be a number");
}
if (prop1Details.Type != ConcreteType.Number)
{
throw new Exception($"First operator {op1.Value} must be a property of type number");
}
var rangeQuery = new NumericRangeQuery
{
Field = prop1Details.SourceName
};
if (value == Operator.LessThan)
{
rangeQuery.LessThan = (double)(decimal)op2.Value;
}
if (value == Operator.LessThanEqual)
{
rangeQuery.LessThanOrEqualTo = (double)(decimal)op2.Value;
}
if (value == Operator.GreaterThan)
{
rangeQuery.GreaterThan = (double)(decimal)op2.Value;
}
if (value == Operator.GreaterThanEqual)
{
rangeQuery.GreaterThanOrEqualTo = (double)(decimal)op2.Value;
}
return(new QueryContainer(rangeQuery));
default:
throw new Exception($"Unknown Operator {node.Value}");
}
}
protected internal IBooleanOperation RangeInternal(string fieldName, long lower, long upper, bool includeLower, bool includeUpper, BooleanClause.Occur occurance)
{
Query.Add(NumericRangeQuery.NewLongRange(fieldName, lower, upper, includeLower, includeUpper), occurance);
return(new LuceneBooleanOperation(this));
}
public void Boost_Returns_NumericRangeQuery()
{
var query = new NumericRangeQuery().Boost(2.2);
Assert.IsInstanceOf <NumericRangeQuery> (query);
}
// [Test] // LUCENENET NOTE: For now, we are overriding this test in every subclass to pull it into the right context for the subclass
public virtual void TestWriteReadMerge()
{
// get another codec, other than the default: so we are merging segments across different codecs
Codec otherCodec;
if ("SimpleText".Equals(Codec.Default.Name, StringComparison.Ordinal))
{
otherCodec = new Lucene46Codec();
}
else
{
otherCodec = new SimpleTextCodec();
}
Directory dir = NewDirectory();
IndexWriterConfig iwConf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()));
iwConf.SetMaxBufferedDocs(RandomInts.NextIntBetween(Random(), 2, 30));
RandomIndexWriter iw = new RandomIndexWriter(Random(), dir, (IndexWriterConfig)iwConf.Clone());
int docCount = AtLeast(200);
var data = new byte[docCount][][];
for (int i = 0; i < docCount; ++i)
{
int fieldCount = Rarely() ? RandomInts.NextIntBetween(Random(), 1, 500) : RandomInts.NextIntBetween(Random(), 1, 5);
data[i] = new byte[fieldCount][];
for (int j = 0; j < fieldCount; ++j)
{
int length = Rarely() ? Random().Next(1000) : Random().Next(10);
int max = Rarely() ? 256 : 2;
data[i][j] = RandomByteArray(length, max);
}
}
FieldType type = new FieldType(StringField.TYPE_STORED);
type.IsIndexed = false;
type.Freeze();
Int32Field id = new Int32Field("id", 0, Field.Store.YES);
for (int i = 0; i < data.Length; ++i)
{
Document doc = new Document();
doc.Add(id);
id.SetInt32Value(i);
for (int j = 0; j < data[i].Length; ++j)
{
Field f = new Field("bytes" + j, data[i][j], type);
doc.Add(f);
}
iw.w.AddDocument(doc);
if (Random().NextBoolean() && (i % (data.Length / 10) == 0))
{
iw.w.Dispose();
// test merging against a non-compressing codec
if (iwConf.Codec == otherCodec)
{
iwConf.SetCodec(Codec.Default);
}
else
{
iwConf.SetCodec(otherCodec);
}
iw = new RandomIndexWriter(Random(), dir, (IndexWriterConfig)iwConf.Clone());
}
}
for (int i = 0; i < 10; ++i)
{
int min = Random().Next(data.Length);
int max = min + Random().Next(20);
iw.DeleteDocuments(NumericRangeQuery.NewInt32Range("id", min, max, true, false));
}
iw.ForceMerge(2); // force merges with deletions
iw.Commit();
DirectoryReader ir = DirectoryReader.Open(dir);
Assert.IsTrue(ir.NumDocs > 0);
int numDocs = 0;
for (int i = 0; i < ir.MaxDoc; ++i)
{
Document doc = ir.Document(i);
if (doc == null)
{
continue;
}
++numDocs;
int docId = (int)doc.GetField("id").GetNumericValue();
Assert.AreEqual(data[docId].Length + 1, doc.Fields.Count);
for (int j = 0; j < data[docId].Length; ++j)
{
var arr = data[docId][j];
BytesRef arr2Ref = doc.GetBinaryValue("bytes" + j);
var arr2 = Arrays.CopyOfRange(arr2Ref.Bytes, arr2Ref.Offset, arr2Ref.Offset + arr2Ref.Length);
Assert.AreEqual(arr, arr2);
}
}
Assert.IsTrue(ir.NumDocs <= numDocs);
ir.Dispose();
iw.DeleteAll();
iw.Commit();
iw.ForceMerge(1);
iw.Dispose();
dir.Dispose();
}
public void Boost_WhenBoostIsLessThanZero_ThrowsArgumentOutOfRangeException()
{
var query = new NumericRangeQuery();
Assert.Throws <ArgumentOutOfRangeException>(() => query.Boost(-.1));
}
/// <summary>
/// On base of https://lucenenet.apache.org
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public IEnumerable <(string name, int year)> SearchWithLucy(string query)
{
var words = query.Split(' ').ToList();
var searcher = new IndexSearcher(lucyAdapter.lucyWriter.GetReader(applyAllDeletes: true));
var totalResults = new List <Document>();
//word
MultiPhraseQuery multiPhraseQuery;
foreach (var word in words)
{
multiPhraseQuery = new MultiPhraseQuery();
if (string.IsNullOrEmpty(word))
{
continue;
}
multiPhraseQuery.Add(new Term("name_word", word));
var docs = searcher.Search(multiPhraseQuery, 10).ScoreDocs;
foreach (var doc in docs)
{
var document = searcher.Doc(doc.Doc);
if (totalResults.All(f => f.GetField("id").GetInt32Value() != document.GetField("id").GetInt32Value()))
{
totalResults.Add(document);
}
}
}
// full name
multiPhraseQuery = new MultiPhraseQuery();
multiPhraseQuery.Add(new Term("full_name", query));
var scoreDocs = searcher.Search(multiPhraseQuery, 10).ScoreDocs;
foreach (var scoreDoc in scoreDocs)
{
var doc = searcher.Doc(scoreDoc.Doc);
if (totalResults.All(f => f.GetField("id").GetInt32Value() != doc.GetField("id").GetInt32Value()))
{
totalResults.Add(doc);
}
}
//word parts
foreach (var word in words)
{
if (string.IsNullOrEmpty(word))
{
continue;
}
var wildcardQuery = new WildcardQuery(new Term("name_word", "*" + word + "*"));
var docs = searcher.Search(wildcardQuery, 10).ScoreDocs;
foreach (var doc in docs)
{
var document = searcher.Doc(doc.Doc);
if (totalResults.All(f => f.GetField("id").GetInt32Value() != document.GetField("id").GetInt32Value()))
{
totalResults.Add(document);
}
}
}
//year and word part
var number = 0;
foreach (var word in words)
{
var result = int.TryParse(word, out number);
if (!result)
{
continue;
}
words.RemoveAt(words.IndexOf(word));
break;
}
if (number != 0)
{
foreach (var word in words)
{
if (string.IsNullOrEmpty(word))
{
continue;
}
var booleanQuery = new BooleanQuery();
var wildcardQuery = new WildcardQuery(new Term("name_word", "*" + word + "*"));
var rangeQuery = NumericRangeQuery.NewInt32Range("year", 1, number, number, true, true);
booleanQuery.Add(wildcardQuery, Occur.SHOULD);
booleanQuery.Add(rangeQuery, Occur.SHOULD);
var docs = searcher.Search(booleanQuery, 10).ScoreDocs;
foreach (var doc in docs)
{
var foundDoc = searcher.Doc(doc.Doc);
if (totalResults.All(f => f.GetField("id").GetInt32Value() != foundDoc.GetField("id").GetInt32Value()))
{
totalResults.Add(foundDoc);
}
}
}
}
foreach (var doc in totalResults.Take(10))
{
yield return(doc.GetValues("full_name")[0], (int)doc.GetField("year").GetInt32Value());
}
}
public SearchResult FindSimular(string key, int resultOffset, int resultLength, bool matchCategory)
{
var pageQuery = new TermQuery(new Term("key", key));
var topDocs = _searcher.Search(pageQuery, 1);
if (topDocs.TotalHits == 0)
{
return(new SearchResult());
}
var doc = topDocs.ScoreDocs[0].Doc;
var moreLikeThis = new MoreLikeThis(_reader)
{
Analyzer = _analyzer,
MinWordLen = 3
};
moreLikeThis.SetFieldNames(new[] { "title", "summary", "content", "tags" });
moreLikeThis.SetStopWords(StopWords.DefaultEnglish);
moreLikeThis.MinDocFreq = 2;
var query = moreLikeThis.Like(doc);
var startTime = DateTime.Now;
var ticks = DateTime.Now.ToUniversalTime().Ticks;
Query publishStartQuery = NumericRangeQuery.NewLongRange("publishStart", null, ticks, true, false);
Query publishStopQuery = NumericRangeQuery.NewLongRange("publishStop", ticks, null, false, true);
var booleanQuery = new BooleanQuery {
{ query, Occur.MUST },
{ pageQuery, Occur.MUST_NOT },
{ publishStartQuery, Occur.MUST },
{ publishStopQuery, Occur.MUST }
};
if (matchCategory)
{
var document = _searcher.Doc(doc);
var field = document.GetField("category");
if (field != null && !string.IsNullOrEmpty(field.StringValue))
{
var categoryQuery = new TermQuery(new Term("category", field.StringValue.ToLowerInvariant()));
booleanQuery.Add(categoryQuery, Occur.MUST);
}
}
var scoreDocs = _searcher.Search(booleanQuery, null, MaxHits, Sort.RELEVANCE).ScoreDocs;
var result = new SearchResult {
NumberOfHits = scoreDocs.Length
};
if (resultOffset < scoreDocs.Length)
{
var resultUpperOffset = resultOffset + resultLength;
if (resultUpperOffset > scoreDocs.Length)
{
resultUpperOffset = scoreDocs.Length;
}
for (int i = resultOffset; i < resultUpperOffset; i++)
{
Document document = _searcher.Doc(scoreDocs[i].Doc);
Guid pageId;
(document.Get("pageId") ?? string.Empty).TryParseGuid(out pageId);
var hit = new SearchHit {
PageId = pageId,
Path = document.Get("path"),
Title = document.Get("title"),
Excerpt = document.Get("summary")
};
//foreach (string key in metaData) {
// hit.MetaData.Add(key, document.Get(key));
//}
result.Hits.Add(hit);
}
}
var timeTaken = DateTime.Now - startTime;
result.SecondsTaken = timeTaken.TotalSeconds;
return(result);
}
public override Query ToQuery(LuceneASTQueryConfiguration configuration)
{
// For numeric values { NUll TO <number> } should be [ <min value> TO <number>} but not for string values.
OverideInclusive();
if (RangeMin.Type == TermLuceneASTNode.TermType.Float || RangeMax.Type == TermLuceneASTNode.TermType.Float)
{
//Need to handle NULL values...
var min = (RangeMin.Type == TermLuceneASTNode.TermType.Null || RangeMin.Term == "*") ? float.MinValue : float.Parse(RangeMin.Term.Substring(2));
var max = (RangeMax.Type == TermLuceneASTNode.TermType.Null || RangeMax.Term == "*") ? float.MaxValue : float.Parse(RangeMax.Term.Substring(2));
return(NumericRangeQuery.NewFloatRange(configuration.FieldName, 4, min, max, InclusiveMin, InclusiveMax));
}
if (RangeMin.Type == TermLuceneASTNode.TermType.Double || RangeMax.Type == TermLuceneASTNode.TermType.Double)
{
//numbers inside range without prefix are treated as strings.
if (!RangeMin.Term.StartsWith("Dx") && !RangeMax.Term.StartsWith("Dx"))
{
return(new TermRangeQuery(configuration.FieldName,
RangeMin.Type == TermLuceneASTNode.TermType.Null?null:RangeMin.Term,
RangeMax.Type == TermLuceneASTNode.TermType.Null?null:RangeMax.Term,
InclusiveMin, InclusiveMax));
}
var min = (RangeMin.Type == TermLuceneASTNode.TermType.Null || RangeMin.Term == "*") ? double.MinValue : double.Parse(RangeMin.Term.Substring(2));
var max = (RangeMax.Type == TermLuceneASTNode.TermType.Null || RangeMax.Term == "*") ? double.MaxValue : double.Parse(RangeMax.Term.Substring(2));
return(NumericRangeQuery.NewDoubleRange(configuration.FieldName, 4, min, max, InclusiveMin, InclusiveMax));
}
if (RangeMin.Type == TermLuceneASTNode.TermType.Int || RangeMax.Type == TermLuceneASTNode.TermType.Int)
{
//numbers inside range without prefix are treated as strings.
if (!RangeMin.Term.StartsWith("Ix") && !RangeMax.Term.StartsWith("Ix"))
{
return(new TermRangeQuery(configuration.FieldName,
RangeMin.Type == TermLuceneASTNode.TermType.Null ? null : RangeMin.Term,
RangeMax.Type == TermLuceneASTNode.TermType.Null ? null : RangeMax.Term,
InclusiveMin, InclusiveMax));
}
var intMin = (RangeMin.Type == TermLuceneASTNode.TermType.Null || RangeMin.Term == "*") ? int.MinValue : int.Parse(RangeMin.Term.Substring(2));
var intMax = (RangeMax.Type == TermLuceneASTNode.TermType.Null || RangeMax.Term == "*") ? int.MaxValue : int.Parse(RangeMax.Term.Substring(2));
return(NumericRangeQuery.NewIntRange(configuration.FieldName, 4, intMin, intMax, InclusiveMin, InclusiveMax));
}
if (RangeMin.Type == TermLuceneASTNode.TermType.Long || RangeMax.Type == TermLuceneASTNode.TermType.Long)
{
var longMin = (RangeMin.Type == TermLuceneASTNode.TermType.Null || RangeMin.Term == "*") ? long.MinValue : long.Parse(RangeMin.Term.Substring(2));
var longMax = (RangeMax.Type == TermLuceneASTNode.TermType.Null || RangeMax.Term == "*") ? long.MaxValue : long.Parse(RangeMax.Term.Substring(2));
return(NumericRangeQuery.NewLongRange(configuration.FieldName, 4, longMin, longMax, InclusiveMin, InclusiveMax));
}
if (RangeMin.Type == TermLuceneASTNode.TermType.Hex || RangeMax.Type == TermLuceneASTNode.TermType.Hex)
{
long longMin;
long longMax;
if (RangeMin.Type == TermLuceneASTNode.TermType.Hex)
{
if (RangeMin.Term.Length <= 10)
{
var intMin = int.Parse(RangeMin.Term.Substring(2), NumberStyles.HexNumber);
var intMax = (RangeMax.Type == TermLuceneASTNode.TermType.Null || RangeMax.Term == "*") ? int.MaxValue : int.Parse(RangeMax.Term.Substring(2), NumberStyles.HexNumber);
return(NumericRangeQuery.NewIntRange(configuration.FieldName, 4, intMin, intMax, InclusiveMin, InclusiveMax));
}
longMin = long.Parse(RangeMin.Term.Substring(2), NumberStyles.HexNumber);
longMax = (RangeMax.Type == TermLuceneASTNode.TermType.Null || RangeMax.Term == "*") ? long.MaxValue : long.Parse(RangeMax.Term.Substring(2), NumberStyles.HexNumber);
return(NumericRangeQuery.NewLongRange(configuration.FieldName, 4, longMin, longMax, InclusiveMin, InclusiveMax));
}
if (RangeMax.Term.Length <= 10)
{
var intMin = (RangeMin.Type == TermLuceneASTNode.TermType.Null || RangeMin.Term == "*") ? int.MinValue : int.Parse(RangeMin.Term.Substring(2), NumberStyles.HexNumber);
var intMax = int.Parse(RangeMax.Term.Substring(2), NumberStyles.HexNumber);
return(NumericRangeQuery.NewIntRange(configuration.FieldName, 4, intMin, intMax, InclusiveMin, InclusiveMax));
}
longMin = (RangeMin.Type == TermLuceneASTNode.TermType.Null || RangeMin.Term == "*") ? long.MinValue : long.Parse(RangeMin.Term.Substring(2), NumberStyles.HexNumber);
longMax = long.Parse(RangeMax.Term.Substring(2), NumberStyles.HexNumber);
return(NumericRangeQuery.NewLongRange(configuration.FieldName, 4, longMin, longMax, InclusiveMin, InclusiveMax));
}
if (RangeMin.Type == TermLuceneASTNode.TermType.Null && RangeMax.Type == TermLuceneASTNode.TermType.Null)
{
return(new WildcardQuery(new Term(configuration.FieldName, "*")));
}
return(new TermRangeQuery(configuration.FieldName,
RangeMin.Type == TermLuceneASTNode.TermType.Null ? null : RangeMin.Term,
RangeMax.Type == TermLuceneASTNode.TermType.Null ? null : RangeMax.Term,
InclusiveMin, InclusiveMax));
}
///// <summary>
///// Gets the quick search results.
///// </summary>
///// <param name="searchText">The search text.</param>
///// <returns></returns>
//public DataTable GetQuickSearchResults(string searchText)
//{
// DataTable tempTable = new DataTable();
// try
// {
// tempTable = _contactsMetaDataTable.Clone();
// IndexSearcher MyIndexSearcher = new IndexSearcher(_directory);
// BooleanQuery.SetMaxClauseCount(0x2710);
// Query mainQuery = this.GetQuickSearchStringQuery(searchText);
// Hits hits = MyIndexSearcher.Search(mainQuery);
// for (int i = 0; i < hits.Length(); i++)
// {
// Document doc = hits.Doc(i);
// if (doc != null)
// {
// DataRow row = tempTable.NewRow();
// foreach (DataColumn clm in tempTable.Columns)
// {
// if (_contactAttributeDateFields.Contains(clm.ColumnName))
// {
// row[clm] = DateTime.ParseExact(doc.GetField(clm.ColumnName).StringValue(), "yyyyMMddHHmmss", CultureInfo.InvariantCulture,
// DateTimeStyles.None).ToString();
// }
// else
// row[clm] = doc.GetField(clm.ColumnName).StringValue();
// }
// tempTable.Rows.Add(row);
// }
// }
// }
// catch (Exception ex)
// {
// _logger.Error("Error while getting quick search results : " + ex.InnerException == null ? ex.Message.ToString() : ex.InnerException.Message);
// return null;
// }
// return tempTable;
//}
#endregion
public DataTable GetQuickSearchResults(bool isContactDirectorytSearch, string mediaType, DateTime startDate, string searchText)
{
DataTable tempTable = new DataTable();
try
{
if (_contactsMetaDataTable == null)
{
return(null);
}
tempTable = _contactsMetaDataTable.Clone();
IndexSearcher MyIndexSearcher = new IndexSearcher(_directory);
BooleanQuery mainQuery = new BooleanQuery();
BooleanQuery.SetMaxClauseCount(0x2710);
DateTime chkDate;
if (DateTime.TryParse(startDate.ToString(), out chkDate))
{
if (chkDate != null)
{
_logger.Debug("Search Field is DateTime value");
var numericQuery = NumericRangeQuery.NewLongRange("StartDate", int.MaxValue, long.Parse(startDate.ToString("yyyyMMddHHmmss")),
long.Parse(DateTime.Today.AddDays(1).AddTicks(-1).ToString("yyyyMMddHHmmss")), true, false);//To avoid inclusive of given date for before condition in searching
if (!isContactDirectorytSearch)
{
mainQuery.Add(numericQuery, BooleanClause.Occur.MUST);
}
}
}
if (searchText != string.Empty)
{
if (DateTime.TryParse(searchText.ToString(), out chkDate))
{
if (chkDate != null)
{
BooleanQuery dateQuery = new BooleanQuery();
var numericStartDateQuery = NumericRangeQuery.NewLongRange("StartDate", int.MaxValue, long.Parse(chkDate.ToString("yyyyMMddHHmmss")),
long.Parse(chkDate.AddDays(1).AddTicks(-1).ToString("yyyyMMddHHmmss")), true, false);//To avoid inclusive of given date for before condition in searching
dateQuery.Add(numericStartDateQuery, BooleanClause.Occur.SHOULD);
var numericEndDateQuery = NumericRangeQuery.NewLongRange("EndDate", int.MaxValue, long.Parse(chkDate.ToString("yyyyMMddHHmmss")),
long.Parse(chkDate.AddDays(1).AddTicks(-1).ToString("yyyyMMddHHmmss")), true, false);//To avoid inclusive of given date for before condition in searching
//dateQuery.Add(numericEndDateQuery, BooleanClause.Occur.SHOULD);
//mainQuery = new BooleanQuery();
mainQuery.Add(numericStartDateQuery, BooleanClause.Occur.MUST);
mainQuery.Add(numericEndDateQuery, BooleanClause.Occur.MUST);
Query subQuery = this.GetQuickSearchStringQuery(searchText);
// mainQuery.Add(subQuery, BooleanClause.Occur.MUST);
}
}
else
{
Query subQuery = this.GetQuickSearchStringQuery(searchText);
mainQuery.Add(subQuery, BooleanClause.Occur.MUST);
}
}
if (_contactsMetaDataTable.Columns.Contains("Media"))
{
if (mediaType != string.Empty)
{
if (mediaType.ToLower() != "all")
{
Lucene.Net.Analysis.Token token = null;
Lucene.Net.Analysis.Token token2 = null;
TokenStream stream = _analyzer.TokenStream("Media", new StringReader(mediaType));
BooleanQuery tempQuery = new BooleanQuery();
do
{
token2 = token;
token = stream.Next();
if (token2 != null)
{
string stoken = token2.TermText();
BooleanQuery outputQuery = new BooleanQuery();
this.TokenToQuery("Media", stoken, SearchCondition.Contains.ToString(), ref outputQuery);
tempQuery.Add(outputQuery, BooleanClause.Occur.SHOULD);
}
}while (token != null);
mainQuery.Add(tempQuery, BooleanClause.Occur.MUST);
}
}
}
Hits hits = MyIndexSearcher.Search(mainQuery);
for (int i = 0; i < hits.Length(); i++)
{
Document doc = hits.Doc(i);
if (doc != null)
{
DataRow row = tempTable.NewRow();
foreach (DataColumn clm in tempTable.Columns)
{
System.Type columnType = clm.DataType;
if (_contactAttributeDateFields.Contains(clm.ColumnName) || columnType == typeof(DateTime))
{
if (!string.IsNullOrEmpty(doc.GetField(clm.ColumnName).StringValue()))
{
row[clm] = DateTime.ParseExact(doc.GetField(clm.ColumnName).StringValue(), "yyyyMMddHHmmss", CultureInfo.InvariantCulture,
DateTimeStyles.None).ToString();
}
else
{
row[clm] = DBNull.Value;
}
}
else
{
if (!string.IsNullOrEmpty(doc.GetField(clm.ColumnName).StringValue()))
{
row[clm] = doc.GetField(clm.ColumnName).StringValue();
}
}
}
tempTable.Rows.Add(row);
}
}
}
catch (Exception ex)
{
_logger.Error("Error while getting GetQuickSearchResults : " + ((ex.InnerException == null) ? ex.Message.ToString() : ex.InnerException.ToString()));
return(null);
}
return(tempTable);
}
public virtual void TestMixedRangeAndNonRangeTaxonomy()
{
Directory d = NewDirectory();
RandomIndexWriter w = new RandomIndexWriter(Random(), d, Similarity, TimeZone);
Directory td = NewDirectory();
DirectoryTaxonomyWriter tw = new DirectoryTaxonomyWriter(td, OpenMode.CREATE);
FacetsConfig config = new FacetsConfig();
for (long l = 0; l < 100; l++)
{
Document doc = new Document();
// For computing range facet counts:
doc.Add(new NumericDocValuesField("field", l));
// For drill down by numeric range:
doc.Add(new Int64Field("field", l, Field.Store.NO));
if ((l & 3) == 0)
{
doc.Add(new FacetField("dim", "a"));
}
else
{
doc.Add(new FacetField("dim", "b"));
}
w.AddDocument(config.Build(tw, doc));
}
IndexReader r = w.Reader;
var tr = new DirectoryTaxonomyReader(tw);
IndexSearcher s = NewSearcher(r);
if (VERBOSE)
{
Console.WriteLine("TEST: searcher=" + s);
}
DrillSideways ds = new DrillSidewaysAnonymousInnerClassHelper(this, s, config, tr);
// First search, no drill downs:
DrillDownQuery ddq = new DrillDownQuery(config);
DrillSidewaysResult dsr = ds.Search(null, ddq, 10);
Assert.AreEqual(100, dsr.Hits.TotalHits);
Assert.AreEqual("dim=dim path=[] value=100 childCount=2\n b (75)\n a (25)\n", dsr.Facets.GetTopChildren(10, "dim").ToString());
Assert.AreEqual("dim=field path=[] value=21 childCount=5\n less than 10 (10)\n less than or equal to 10 (11)\n over 90 (9)\n 90 or above (10)\n over 1000 (0)\n", dsr.Facets.GetTopChildren(10, "field").ToString());
// Second search, drill down on dim=b:
ddq = new DrillDownQuery(config);
ddq.Add("dim", "b");
dsr = ds.Search(null, ddq, 10);
Assert.AreEqual(75, dsr.Hits.TotalHits);
Assert.AreEqual("dim=dim path=[] value=100 childCount=2\n b (75)\n a (25)\n", dsr.Facets.GetTopChildren(10, "dim").ToString());
Assert.AreEqual("dim=field path=[] value=16 childCount=5\n less than 10 (7)\n less than or equal to 10 (8)\n over 90 (7)\n 90 or above (8)\n over 1000 (0)\n", dsr.Facets.GetTopChildren(10, "field").ToString());
// Third search, drill down on "less than or equal to 10":
ddq = new DrillDownQuery(config);
ddq.Add("field", NumericRangeQuery.NewInt64Range("field", 0L, 10L, true, true));
dsr = ds.Search(null, ddq, 10);
Assert.AreEqual(11, dsr.Hits.TotalHits);
Assert.AreEqual("dim=dim path=[] value=11 childCount=2\n b (8)\n a (3)\n", dsr.Facets.GetTopChildren(10, "dim").ToString());
Assert.AreEqual("dim=field path=[] value=21 childCount=5\n less than 10 (10)\n less than or equal to 10 (11)\n over 90 (9)\n 90 or above (10)\n over 1000 (0)\n", dsr.Facets.GetTopChildren(10, "field").ToString());
IOUtils.Close(tw, tr, td, w, r, d);
}
public SearchResult Search(SearchRequest request)
{
using var indexReader = DirectoryReader.Open(_directory);
var searcher = new IndexSearcher(indexReader);
var searchResult = new SearchResult
{
SearchText = request.Text,
Hits = Enumerable.Empty <SearchHit>()
};
Query q = null;
switch (request.QueryType)
{
case QueryTypesEnum.Term:
q = new TermQuery(new Term(request.Fields[0], request.Text));
break;
case QueryTypesEnum.MultiTerm:
q = new BooleanQuery();
if (request.Terms.Length.Equals(request.Fields.Length) && request.Terms.Length > 0)
{
for (int i = 0; i < request.Terms.Length; i++)
{
((BooleanQuery)q).Add(new TermQuery(new Term(request.Fields[i], request.Terms[i])), Occur.MUST);
}
}
break;
case QueryTypesEnum.Numeric:
q = NumericRangeQuery.NewInt32Range(request.Fields[0], int.Parse(request.Text), int.Parse(request.Text), true, true);
break;
case QueryTypesEnum.Text:
var parser = new QueryParser(AppLuceneVersion, request.Fields[0], _analyzer)
{
AllowLeadingWildcard = true,
DefaultOperator = Operator.AND
};
q = parser.Parse(request.Text);
break;
}
var startIndex = request.Pagination.PageIndex * request.Pagination.PageSize;
var topDocs = searcher.Search(q, startIndex + request.Pagination.PageSize);
if (topDocs.TotalHits == 0)
{
return(searchResult);
}
var hits = new List <SearchHit>(topDocs.ScoreDocs.Skip(startIndex).Count());
foreach (var hit in topDocs.ScoreDocs.Skip(startIndex))
{
hits.Add(CreateSearchHit(searcher.Doc(hit.Doc)));
}
searchResult.TotalHits = topDocs.TotalHits;
searchResult.Hits = hits.OrderBy(x => x.Name).ToList();
searchResult.Pagination = request.Pagination;
return(searchResult);
}
/// <summary>
/// Detects numeric range terms and expands range expressions accordingly
/// </summary>
/// <param name="field"></param>
/// <param name="lower"></param>
/// <param name="upper"></param>
/// <param name="inclusive"></param>
/// <returns></returns>
protected override Query GetRangeQuery(string field, string lower, string upper, bool inclusive)
{
if (lower == "NULL" || lower == "*")
{
lower = null;
}
if (upper == "NULL" || upper == "*")
{
upper = null;
}
if ((lower == null || !NumericRangeValue.IsMatch(lower)) && (upper == null || !NumericRangeValue.IsMatch(upper)))
{
return(NewRangeQuery(field, lower, upper, inclusive));
}
var from = NumberUtil.StringToNumber(lower);
var to = NumberUtil.StringToNumber(upper);
TypeCode numericType;
if (from != null)
{
numericType = Type.GetTypeCode(from.GetType());
}
else if (to != null)
{
numericType = Type.GetTypeCode(to.GetType());
}
else
{
numericType = TypeCode.Empty;
}
switch (numericType)
{
case TypeCode.Int32:
{
return(NumericRangeQuery.NewIntRange(field, (int)(from ?? Int32.MinValue), (int)(to ?? Int32.MaxValue), inclusive, inclusive));
}
case TypeCode.Int64:
{
return(NumericRangeQuery.NewLongRange(field, (long)(from ?? Int64.MinValue), (long)(to ?? Int64.MaxValue), inclusive, inclusive));
}
case TypeCode.Double:
{
return(NumericRangeQuery.NewDoubleRange(field, (double)(from ?? Double.MinValue), (double)(to ?? Double.MaxValue), inclusive, inclusive));
}
case TypeCode.Single:
{
return(NumericRangeQuery.NewFloatRange(field, (float)(from ?? Single.MinValue), (float)(to ?? Single.MaxValue), inclusive, inclusive));
}
default:
{
return(NewRangeQuery(field, lower, upper, inclusive));
}
}
}
private static Query NumericValueQuery(string numericName, int numericVal)
{
return(NumericRangeQuery.NewIntRange(numericName, numericVal, numericVal, true, true));
}
public ISearchBuilder WithinRange(string field, double?min, double?max, bool includeMin = true, bool includeMax = true)
{
CreatePendingClause();
_query = NumericRangeQuery.NewDoubleRange(field, min, max, includeMin, includeMax);
return(this);
}
public override Query GetQuery(double?lower, double?upper, bool lowerInclusive = true, bool upperInclusive = true)
{
return(NumericRangeQuery.NewDoubleRange(FieldName,
lower ?? double.MinValue,
upper ?? double.MaxValue, lowerInclusive, upperInclusive));
}
public Query CreateQuery(ILuceneQueryService builder, LuceneQueryContext context, string type, JObject query)
{
if (type != "range")
{
return(null);
}
var range = query.Properties().First();
Query rangeQuery;
switch (range.Value.Type)
{
case JTokenType.Object:
var field = range.Name;
JToken gt = null;
JToken lt = null;
var tokenType = JTokenType.None;
float? boost = null;
bool includeLower = false, includeUpper = false;
foreach (var element in ((JObject)range.Value).Properties())
{
switch (element.Name.ToLowerInvariant())
{
case "gt":
gt = element.Value;
tokenType = gt.Type;
break;
case "gte":
gt = element.Value;
tokenType = gt.Type;
includeLower = true;
break;
case "lt":
lt = element.Value;
tokenType = lt.Type;
break;
case "lte":
lt = element.Value;
tokenType = lt.Type;
includeUpper = true;
break;
case "boost":
boost = element.Value.Value <float>();
break;
}
}
if (gt != null && lt != null && gt.Type != lt.Type)
{
throw new ArgumentException("Lower and upper bound range types don't match");
}
switch (tokenType)
{
case JTokenType.Integer:
var minInt = gt?.Value <int>();
var maxInt = lt?.Value <int>();
rangeQuery = NumericRangeQuery.NewInt32Range(field, minInt, maxInt, includeLower, includeUpper);
break;
case JTokenType.Float:
var minFloat = gt?.Value <double>();
var maxFloat = lt?.Value <double>();
rangeQuery = NumericRangeQuery.NewDoubleRange(field, minFloat, maxFloat, includeLower, includeUpper);
break;
case JTokenType.String:
var minString = gt?.Value <string>();
var maxString = lt?.Value <string>();
rangeQuery = TermRangeQuery.NewStringRange(field, minString, maxString, includeLower, includeUpper);
break;
default: throw new ArgumentException($"Unsupported range value type: {type}");
}
if (boost != null)
{
rangeQuery.Boost = boost.Value;
}
return(rangeQuery);
default: throw new ArgumentException("Invalid range query");
}
}
static void Main(string[] args)
{
Console.WriteLine("LUCENE CREATE INDEX - Start");
// Create Lucene Index Location
var indexLocation = Path.Combine(Environment.CurrentDirectory, "LuceneIndex");
var indexZipLocation = Path.Combine(Environment.CurrentDirectory, "LuceneIndexZip");
if (!System.IO.Directory.Exists(indexLocation))
{
System.IO.Directory.CreateDirectory(indexLocation);
}
if (!System.IO.Directory.Exists(indexZipLocation))
{
System.IO.Directory.CreateDirectory(indexZipLocation);
}
var dataStream = GetBaseballData();
var lines = ReadLines(() => dataStream, Encoding.UTF8);
// Skip the first header line
var batters = lines
.Skip(1)
.Select(v => MLBBaseballBatter.FromCsv(v))
.ToList();
// LUCENE - CREATE THE INDEX
var AppLuceneVersion = LuceneVersion.LUCENE_48;
var dir = FSDirectory.Open(indexLocation);
//create an analyzer to process the text
var analyzer = new StandardAnalyzer(AppLuceneVersion);
//create an index writer
var indexConfig = new IndexWriterConfig(AppLuceneVersion, analyzer);
indexConfig.OpenMode = OpenMode.CREATE;
var writer = new IndexWriter(dir, indexConfig);
// Get max Years Played for each batter
var battersMaxYearsPlayed = from b in batters
group b by b.ID into g
select new MLBBaseballBatter {
ID = g.Key, YearsPlayed = g.Max(b => b.YearsPlayed)
};
Console.WriteLine("LUCENE CREATE INDEX - Iterating Data for Index");
foreach (var batter in batters)
{
var isBatterMaxYearsRecord = (from batterMax in battersMaxYearsPlayed
where ((batterMax.ID == batter.ID) && (batterMax.YearsPlayed == batter.YearsPlayed))
select new { ID = batterMax.ID }).Count();
Document doc = new Document
{
// Field names map to the MLBBaseballPlayer.cs class
// that is used in ML.NET models, demos etc.
// StringField indexes but doesn't tokenize
new StringField("Id",
batter.ID,
Field.Store.YES),
new Int32Field("IsBatterMaxYearsRecord",
isBatterMaxYearsRecord, Field.Store.YES),
new TextField("FullPlayerName",
batter.FullPlayerName,
Field.Store.YES),
new StringField("InductedToHallOfFame",
batter.InductedToHallOfFame.ToString(),
Field.Store.YES),
new StringField("OnHallOfFameBallot",
batter.OnHallOfFameBallot.ToString(),
Field.Store.YES),
new SingleField("YearsPlayed",
batter.YearsPlayed, Field.Store.YES),
// Use StoredField to minimize index storage, since these fields won't be searched on
new StoredField("AB",
batter.AB),
new StoredField("R",
batter.R),
new StoredField("H",
batter.H),
new StoredField("Doubles",
batter.Doubles),
new StoredField("Triples",
batter.Triples),
new StoredField("HR",
batter.HR),
new StoredField("RBI",
batter.RBI),
new StoredField("SB",
batter.SB),
new StoredField("BattingAverage",
batter.BattingAverage),
new StoredField("SluggingPct",
batter.SluggingPct),
new StoredField("AllStarAppearances",
batter.AllStarAppearances),
new StoredField("MVPs",
batter.MVPs),
new StoredField("TripleCrowns",
batter.TripleCrowns),
new StoredField("GoldGloves",
batter.GoldGloves),
new StoredField("MajorLeaguePlayerOfTheYearAwards",
batter.MajorLeaguePlayerOfTheYearAwards),
new StoredField("TB",
batter.TB),
new StoredField("TotalPlayerAwards",
batter.TotalPlayerAwards),
new StoredField("LastYearPlayed",
batter.LastYearPlayed)
};
// Console.WriteLine("Added: " + batter.ToString());
writer.AddDocument(doc);
}
writer.Flush(triggerMerge: true, applyAllDeletes: false);
writer.Commit();
var numberDocs = writer.NumDocs;
Console.WriteLine("LUCENE CREATE INDEX - Number of Docs Written to Index: " + numberDocs);
// Close the index writer
writer.Dispose();
Console.WriteLine("LUCENE CREATE INDEX - Index Created");
// LUCENE - PACKAGE THE INDEX AS ZIP FILE
var packagePath = Path.Combine(indexZipLocation, "LuceneIndex.zip");
// Delete the Zip file before proceeding
if (File.Exists(packagePath))
{
File.Delete(packagePath);
}
ZipFile.CreateFromDirectory(indexLocation, packagePath, CompressionLevel.Optimal, false);
Console.WriteLine("LUCENE CREATE INDEX - Index Packaged (Zip)");
// LUCENE - TEST THE INDEX
// Load the index from Zip file (mimic it loading)
Console.WriteLine("LUCENE CREATE INDEX - Text the Index from Packaged (Zip)");
ZipFile.ExtractToDirectory(packagePath, Environment.CurrentDirectory, true);
var zipDirectory = FSDirectory.Open(Environment.CurrentDirectory);
var indexReader = DirectoryReader.Open(zipDirectory);
var searcher = new IndexSearcher(indexReader);
// Simple Query
QueryParser parser = new QueryParser(AppLuceneVersion, "FullPlayerName", analyzer);
var query = parser.Parse("Todd");
var searchResults = searcher.Search(query, 500);// 20 /* top 20 */);
var hits = searchResults.ScoreDocs;
Console.WriteLine("LUCENE CREATE INDEX - Search for 'Todd': " + hits.Length);
//foreach (var hit in hits)
//{
// var foundDoc = searcher.Doc(hit.Doc);
// var name = foundDoc.GetField("FullPlayerName").GetStringValue();
// var yearsPlayed = foundDoc.GetField("YearsPlayed").GetSingleValue();
// var explanation = searcher.Explain(query, hit.Doc);
// Console.WriteLine("Found: " + name + " - " + hit.Score);
// Console.WriteLine("Explanation: " + explanation.ToString());
// var score = hit.Score;
//}
// Simple Query- With Filter
var queryRanged = NumericRangeQuery.NewInt32Range("IsBatterMaxYearsRecord", 1, 1, true, true);
BooleanQuery andQuery = new BooleanQuery();
andQuery.Add(query, Occur.MUST);
andQuery.Add(queryRanged, Occur.MUST);
var searchResultsWithFilter = searcher.Search(andQuery, 500); /* top 500 */;
var hitsWithFilter = searchResultsWithFilter.ScoreDocs;
Console.WriteLine("LUCENE CREATE INDEX - Search for 'Todd' with Max Years Filter: " + hitsWithFilter.Length);
//foreach (var hit in hitsWithFilter)
//{
// var foundDoc = searcher.Doc(hit.Doc);
// var name = foundDoc.GetField("FullPlayerName").GetStringValue();
// var isBatterMaxYearsRecord = foundDoc.GetField("IsBatterMaxYearsRecord").GetInt32Value();
// var explanation = searcher.Explain(query, hit.Doc);
// Console.WriteLine("Found: " + name + " - " + hit.Score);
// Console.WriteLine("Explanation: " + explanation.ToString());
// var score = hit.Score;
//}
// Query For Id
var termHankAaron = new Term("Id", "aaronha01");
var termQuery = new TermQuery(termHankAaron);
var searchResultsTermQuery = searcher.Search(termQuery, 50); /* top 50 */;
var hitsTermQuery = searchResultsTermQuery.ScoreDocs;
Console.WriteLine("LUCENE CREATE INDEX - Search for 'Id = aaronha01': " + hitsTermQuery.Length);
}
private static Query CreateRange(string fieldName, double minValue, bool inclusiveMin, double maxValue, bool inclusiveMax)
{
return(NumericRangeQuery.NewDoubleRange(fieldName, 4, minValue, maxValue, inclusiveMin, inclusiveMax));
}
private NumericRangeFilter(NumericRangeQuery query):base(query)
{
}
