public static ISolrQuery BuildQuery(SearchParameters parameters)
{
if (!string.IsNullOrEmpty(parameters.FreeSearch))
{
return(new SolrQuery(parameters.FreeSearch));
}
AbstractSolrQuery searchquery = null;
var solrQuery = parameters.SearchFor
.Select(searchType => new SolrQuery($"{searchType.Key}:{searchType.Value}"))
.ToList();
if (solrQuery.Count > 0)
{
searchquery = new SolrMultipleCriteriaQuery(solrQuery, SolrMultipleCriteriaQuery.Operator.OR);
}
var solrNotQuery = parameters.Exclude
.Select(excludeType => new SolrQuery($"{excludeType.Key}:{excludeType.Value}"))
.ToList();
if (solrNotQuery.Count > 0)
{
searchquery = (searchquery ?? SolrQuery.All) - new SolrMultipleCriteriaQuery(solrNotQuery, SolrMultipleCriteriaQuery.Operator.OR);
}
return(searchquery ?? SolrQuery.All);
}
public void NullNot_argumentnull()
{
Assert.Throws <ArgumentNullException>(() => {
AbstractSolrQuery a = null;
var b = !a;
});
}
public static ISolrQuery BuildQuery(SearchParameters parameters)
{
if (!string.IsNullOrEmpty(parameters.FreeSearch))
{
return(new SolrQuery(parameters.FreeSearch));
}
AbstractSolrQuery searchQuery = null;
List <SolrQuery> solrQuery = new List <SolrQuery>();
List <SolrQuery> solrNotQuery = new List <SolrQuery>();
foreach (var searchType in parameters.SearchFor)
{
solrQuery.Add(new SolrQuery($"{searchType.Key}:{searchType.Value}"));
}
if (solrQuery.Count > 0)
{
searchQuery = new SolrMultipleCriteriaQuery(solrQuery, SolrMultipleCriteriaQuery.Operator.OR);
}
foreach (var excludeType in parameters.Exclude)
{
solrNotQuery.Add(new SolrQuery($"{excludeType.Key}:{excludeType.Value}"));
}
if (solrNotQuery.Count > 0)
{
searchQuery = (searchQuery ?? SolrQuery.All) - new SolrMultipleCriteriaQuery(solrNotQuery, SolrMultipleCriteriaQuery.Operator.OR);
}
return(searchQuery ?? SolrQuery.All);
}
/// <summary>
/// Removes Solr Indexes based on the query
/// </summary>
/// <param name="solrQuery">Solr Query</param>
private void RemoveFromSOLR(AbstractSolrQuery solrQuery)
{
GenericStorageExtensionLogger.WriteLog(ELogLevel.DEBUG, "Entering SolrIndexManager.RemoveFromSOLR");
var solr = GetInstance <Dictionary <string, object> >();
solr.Delete(solrQuery);
GenericStorageExtensionLogger.WriteLog(ELogLevel.DEBUG, "Exiting SolrIndexManager.RemoveFromSOLR");
}
public AbstractSolrQuery BuildQuery(Filtro filtro)
{
_query = new SolrQuery("*:*");
if (!string.IsNullOrEmpty(filtro.NomeCandidato))
{
_query = _query && new SolrQuery($"NM_CANDIDATO:{filtro.NomeCandidato.ToUpper()}*");
}
if (!string.IsNullOrEmpty(filtro.Partido))
{
_query = _query && new SolrQuery($"NM_CANDIDATO:{filtro.Partido.ToUpper()}");
}
return(_query);
}
private static AbstractSolrQuery ComputerExpression(Expression expression)
{
if (expression == null)
{
return(null);
}
else if (expression.HasChild() == false)
{
return(Compute(expression.NodeData, expression.Operation));
}
else
{
AbstractSolrQuery leftData = ComputerExpression(expression.LeftNode);
AbstractSolrQuery rightData = ComputerExpression(expression.RightNode);
return(Compute(leftData, rightData, expression.Operation));
}
}
public StandardQuery CreateStandardQuery(string query, string[] searchfilters, int page, int pageSize, string sortOrder, string language = null)
{
string defaultField = CurrentConfiguration.SearchSettings.DefaultField;
AbstractSolrQuery abstractSolrQuery1 = (AbstractSolrQuery)null;
AbstractSolrQuery abstractSolrQuery2 = (AbstractSolrQuery)null;
DateTime dateTime;
if (!string.IsNullOrEmpty(query))
{
if (!this.IsCustomQuery(query))
{
string query1 = query;
this.log.AddLogentry(SolisSearch.Log.Enum.LogLevel.Debug, string.Format("Query contains no field information, inserting default field \"{0}\" to query", (object)defaultField), (Exception)null);
string str1 = string.Empty;
if (CurrentConfiguration.SearchSettings.EnableLanguageSupport)
{
if (string.IsNullOrEmpty(language))
{
language = Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName;
}
if (((IEnumerable <string>)CurrentConfiguration.SearchSettings.EnabledLanguages.Split(new string[1]
{
","
}, StringSplitOptions.RemoveEmptyEntries)).Contains <string>(language))
{
str1 = "_" + language;
this.log.AddLogentry(SolisSearch.Log.Enum.LogLevel.Debug, "Language support enabled and language active on default query, appending language to text field: " + str1, (Exception)null);
}
string str2 = "lang:" + language;
if (searchfilters == null)
{
searchfilters = new string[1] {
str2
}
}
;
else
{
searchfilters = new List <string>((IEnumerable <string>)searchfilters)
{
str2
}
}.ToArray();
public async Task <List <BasicSongSearchResult> > Search(string input)
{
if (string.IsNullOrWhiteSpace(input))
{
return(null);
}
var terms = GetStringFuzzySearchTerms(input);
AbstractSolrQuery query = null;
foreach (var term in terms)
{
if (query == null)
{
query = new SolrQueryByField(SolrSearchConstants.SongName, term)
{
Quoted = false
};
}
else
{
query = query || new SolrQueryByField(SolrSearchConstants.SongName, term)
{
Quoted = false
};
}
query = query || new SolrQueryByField(SolrSearchConstants.ArtistName, term)
{
Quoted = false
};
}
var result = await _songSearchOperations.QueryAsync(query, new QueryOptions { Rows = 50 });
var resultList = result.ToList();
var basicSongSearchResults = _getSongsFromSearchResultsQuery.Get(resultList);
return(basicSongSearchResults);
}
/// <summary>
/// Adds passed documents and deletes existing documents matching delete criteria
/// </summary>
/// <param name="docs">List of documents to add</param>
/// <param name="dels">List of delete crileria as key-value pairs</param>
private void AddToSolr(List <Dictionary <string, object> > documentsToAdd,
List <KeyValuePair <string, object> > deleteCriteria)
{
GenericStorageExtensionLogger.WriteLog(ELogLevel.DEBUG, "Entering SolrIndexManager.AddToSolr");
var solr = ServiceLocator.Current.GetInstance <ISolrOperations <Dictionary <string, object> > >();
List <Dictionary <string, object> > deldocs = new List <Dictionary <string, object> >();
List <SolrQueryByField> deleteQueries = deleteCriteria.Select(item =>
new SolrQueryByField(item.Key, (string)item.Value)).ToList();
if (deleteQueries.Count > 0)
{
AbstractSolrQuery deleteQuery = deleteQueries[0];
foreach (SolrQueryByField dq in deleteQueries)
{
deleteQuery |= dq;
}
solr.Delete(deleteQuery);
}
solr.Add(documentsToAdd);
GenericStorageExtensionLogger.WriteLog(ELogLevel.DEBUG, "Exiting SolrIndexManager.AddToSolr");
}
public async Task <List <FeedItem> > Search(string keywords, int page)
{
AbstractSolrQuery q = null;
foreach (var keyword in keywords.Split(' '))
{
if (string.IsNullOrWhiteSpace(keyword))
{
continue;
}
var k = new SolrQuery($"title:{keyword}") || new SolrQuery($"summary:{keyword}");
if (q == null)
{
q = k;
}
else
{
q = q && k;
}
}
if (q == null)
{
return(new List <FeedItem>());
}
var res = await _solrFeedItems.QueryAsync(q, new QueryOptions
{
OrderBy = new [] { new SortOrder("publish_time_in_utc", Order.DESC) },
StartOrCursor = new StartOrCursor.Start(page * 50),
Rows = 50
});
return(res.Select(s => SolrFeedItemToFeedItem(s)).ToList());
}
public async Task <IEnumerable <CandidatoDocumento> > SearchAsync(AbstractSolrQuery query)
{
return(await _solr.QueryAsync(query));
}
public void NullNot_argumentnull()
{
AbstractSolrQuery a = null;
var b = !a;
}
public static int GetCount(this ISolrReadOnlyOperations <Dictionary <string, object> > solr, AbstractSolrQuery baseQuery = null)
{
var result = solr.Query(
baseQuery ?? SolrQuery.All,
new QueryOptions {
StartOrCursor = new StartOrCursor.Start(0),
Rows = 0,
Fields = new Collection <string>()
});
return(result.NumFound);
}
public static object GetMaxValue(this ISolrReadOnlyOperations <Dictionary <string, object> > solr, string field, AbstractSolrQuery baseQuery = null)
{
var result = solr.Query(
baseQuery ?? SolrQuery.All,
new QueryOptions {
StartOrCursor = new StartOrCursor.Start(0),
Rows = 1,
Fields = new List <string> {
field
},
OrderBy = new List <SortOrder> {
new SortOrder(field, Order.DESC)
}
});
return(result.NumFound > 0 ? result[0][field] : null);
}
public SearchResult <Product> Handle(SearchQuery query)
{
var solr = Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance <ISolrOperations <ProductSearchResultItem> >();
//Text search
AbstractSolrQuery solrQuery = string.IsNullOrEmpty(query.SearchText) ? SolrQuery.All :
new SolrQueryBoost(new SolrQueryByField("product_title_t", query.SearchText), 2.0) ||
new SolrQueryByField("product_description_t", query.SearchText);
//Default filters that is always applied
var filters = new List <ISolrQuery>
{
new SolrQueryByField("_language", query.Language),
new SolrQueryByField("_templatename", query.TemplateName),
new SolrNotQuery(new SolrQueryByField("_name", "__Standard Values"))
};
string keepFacetName = null;
//User applied filters
if (query.Filters.Any())
{
var index = 0;
query.Filters.ForEach(filter =>
{
ISolrQuery t = new SolrQueryInList(filter.Key, filter.Value);
if (++index == query.Filters.Count())
{
keepFacetName = filter.Key;
t = new LocalParams.LocalParamsQuery(t, new LocalParams(new Dictionary <string, string> {
{ "tag", "keepfacet" }
}));
}
filters.Add(t);
});
}
var options = new QueryOptions();
options.FilterQueries = filters;
//Selected facets
if (query.Facets != null && query.Facets.Any())
{
var facets = new List <ISolrFacetQuery>();
query.Facets.ForEach(facet =>
{
var facetPrefix = keepFacetName != null && keepFacetName == facet.Key ? "{!ex=keepfacet}" : string.Empty;
facets.Add(new SolrFacetFieldQuery(facetPrefix + facet.Key)
{
MinCount = facet.Value
});
});
options.AddFacets(facets.ToArray());
}
var results = solr.Query(solrQuery, options);
return(new SearchResult <Product>
{
Hits = results.NumFound,
Results = results.Select(result => new Product
{
Id = result.ProductId,
Title = result.Title.First(),
Description = result.Description.First(),
Type = result.Type,
Category = result.Category,
Price = result.Price,
Rating = result.Rating,
IntroDate = result.IntroDate
}),
FacetResults = results.FacetFields.Select(facet => new Facet
{
Key = facet.Key,
Values = facet.Value.Select(facetValue => new FacetValue
{
Key = facetValue.Key,
Count = facetValue.Value
})
})
});
}
private static AbstractSolrQuery Compute(AbstractSolrQuery a, AbstractSolrQuery b, Operation op)
{
switch (op)
{
case Operation.NOT:
if (a != null)
{
return(!a);
}
else if (b != null)
{
return(!b);
}
else
{
return(null);
}
case Operation.AND:
if (a != null && b != null)
{
return(a && b);
}
else if (a != null)
{
return(a);
}
else
{
return(b);
}
case Operation.OR:
if (a != null && b != null)
{
return(a || b);
}
else if (a != null)
{
return(a);
}
else
{
return(b);
}
default:
if (a != null)
{
return(a);
}
else if (b != null)
{
return(b);
}
else
{
return(null);
}
}
}
public IEnumerable <IRow> Read()
{
AbstractSolrQuery query = SolrQuery.All;
var filterQueries = new Collection <ISolrQuery>();
var facetQueries = new Collection <ISolrFacetQuery>();
if (_context.Entity.Filter.Any())
{
var queries = new Collection <ISolrQuery>();
foreach (var filter in _context.Entity.Filter.Where(f => f.Type == "search" && f.Value != "*"))
{
if (filter.Field == string.Empty)
{
queries.Add(new SolrQuery(filter.Expression));
}
else
{
foreach (var term in Terms(filter.Value))
{
queries.Add(new SolrQueryByField(filter.Field, term)
{
Quoted = false
});
}
}
}
query = queries.Any() ? new SolrMultipleCriteriaQuery(queries, "AND") : SolrQuery.All;
foreach (var filter in _context.Entity.Filter.Where(f => f.Type == "filter"))
{
if (filter.Field == string.Empty)
{
filterQueries.Add(new SolrQuery(filter.Expression));
}
else
{
if (filter.Value != "*")
{
foreach (var term in Terms(filter.Value))
{
queries.Add(new SolrQueryByField(filter.Field, term)
{
Quoted = false
});
}
}
}
}
foreach (var filter in _context.Entity.Filter.Where(f => f.Type == "facet"))
{
facetQueries.Add(new SolrFacetFieldQuery(filter.Field)
{
MinCount = filter.Min,
Limit = filter.Size
});
if (filter.Value != "*")
{
if (filter.Value.IndexOf(',') > 0)
{
filterQueries.Add(new SolrQueryInList(filter.Field, filter.Value.Split(new[] { ',' })));
}
else
{
filterQueries.Add(new SolrQueryByField(filter.Field, filter.Value));
}
}
}
}
int rows;
StartOrCursor startOrCursor;
if (_context.Entity.IsPageRequest())
{
rows = _context.Entity.PageSize;
startOrCursor = new StartOrCursor.Start((_context.Entity.Page * _context.Entity.PageSize) - _context.Entity.PageSize);
}
else
{
rows = _context.Entity.ReadSize > 0 ? _context.Entity.ReadSize : _solr.Query(query, new QueryOptions {
StartOrCursor = new StartOrCursor.Start(0), Rows = 0
}).NumFound;
startOrCursor = _context.Entity.ReadSize == 0 ? (StartOrCursor) new StartOrCursor.Start(0) : StartOrCursor.Cursor.Start;
}
var sortOrder = new Collection <SortOrder>();
foreach (var orderBy in _context.Entity.Order)
{
Field field;
if (_context.Entity.TryGetField(orderBy.Field, out field))
{
var name = field.SortField.ToLower();
sortOrder.Add(new SortOrder(name, orderBy.Sort == "asc" ? SolrNet.Order.ASC : SolrNet.Order.DESC));
}
}
sortOrder.Add(new SortOrder("score", SolrNet.Order.DESC));
var result = _solr.Query(
query,
new QueryOptions {
StartOrCursor = startOrCursor,
Rows = rows,
Fields = _fieldNames,
OrderBy = sortOrder,
FilterQueries = filterQueries,
Facet = new FacetParameters {
Queries = facetQueries, Sort = false
}
}
);
foreach (var filter in _context.Entity.Filter.Where(f => f.Type == "facet"))
{
if (result.FacetFields.ContainsKey(filter.Field))
{
var facet = result.FacetFields[filter.Field];
var map = _context.Process.Maps.First(m => m.Name == filter.Map);
foreach (var f in facet)
{
map.Items.Add(new MapItem {
From = $"{f.Key} ({f.Value})", To = f.Key
});
}
}
}
if (result.NumFound <= 0)
{
yield break;
}
_context.Entity.Hits = result.NumFound;
foreach (var row in result.Select(x => DocToRow(_rowFactory.Create(), _fields, x)))
{
_context.Increment();
++_localCount;
yield return(row);
}
// using cursor, solr 4.7+ (un-tested)
while (result.NextCursorMark != null)
{
result = _solr.Query(
query,
new QueryOptions {
StartOrCursor = result.NextCursorMark,
Rows = _context.Entity.ReadSize,
Fields = _fieldNames,
OrderBy = sortOrder,
FilterQueries = filterQueries,
Facet = new FacetParameters {
Queries = facetQueries, Sort = false
}
}
);
foreach (var row in result.Select(r => DocToRow(_rowFactory.Create(), _fields, r)))
{
_context.Increment();
++_localCount;
yield return(row);
}
}
// traditional paging
if (_context.Entity.ReadSize == 0 || _localCount >= result.NumFound)
{
yield break;
}
var pages = result.NumFound / _context.Entity.ReadSize;
for (var page = 1; page <= pages; page++)
{
result = _solr.Query(
query,
new QueryOptions {
StartOrCursor = new StartOrCursor.Start(page * _context.Entity.ReadSize),
Rows = _context.Entity.ReadSize,
Fields = _fieldNames,
OrderBy = sortOrder,
FilterQueries = filterQueries,
Facet = new FacetParameters {
Queries = facetQueries, Sort = false
}
}
);
foreach (var row in result.Select(r => DocToRow(_rowFactory.Create(), _fields, r)))
{
++_localCount;
_context.Increment();
yield return(row);
}
}
}
protected virtual AbstractSolrQuery VisitInsidePolygon(InsidePolygonNode node, AbstractSolrQuery query)
{
AbstractSolrQuery abstractSolrQuery = new SolrQueryByField(node.Field, $"Intersects({node.Coordinate.Latitude} {node.Coordinate.Longitude})");
if (!abstractSolrQuery)
{
return(abstractSolrQuery & query);
}
return(abstractSolrQuery);
}
/// <summary>
/// 构建Solr检索选项，派生类可根据需要进行重写
/// </summary>
/// <param name="condition"></param>
/// <returns></returns>
protected virtual QueryOptions BuildQueryOptions(SearchCondition condition)
{
QueryOptions queryOptions = new QueryOptions();
#region 搜索关键字
if (String.IsNullOrEmpty(condition.KeyWord))
{
condition.KeyWord = "*:*";
}
#endregion 搜索关键字
#region 分页信息
if (condition.PagingInfo == null)
{
condition.PagingInfo = new PagingInfo()
{
PageSize = 24,
PageNumber = 1
};
}
queryOptions.Rows = condition.PagingInfo.PageSize >= 0 ? condition.PagingInfo.PageSize : 24;
queryOptions.Start = condition.PagingInfo.PageNumber > 1 ? queryOptions.Rows * (condition.PagingInfo.PageNumber - 1) : 0;
#endregion 分页信息
#region 排序信息
if (condition.SortItems != null && condition.SortItems.Count > 0)
{
List <SortOrder> sortList = new List <SortOrder>();
foreach (SortItem sortItem in condition.SortItems)
{
if (sortItem.SortType == SortOrderType.ASC)
{
SortOrder sortOrder = new SortOrder(sortItem.SortKey, Order.ASC);
sortList.Add(sortOrder);
}
else
{
SortOrder sortOrder = new SortOrder(sortItem.SortKey, Order.DESC);
sortList.Add(sortOrder);
}
}
queryOptions.OrderBy = sortList.ToArray();
}
#endregion 排序信息
#region 一般过滤条件
if (condition.Filters != null && condition.Filters.Count > 0)
{
foreach (FilterBase filter in condition.Filters)
{
if (filter is RangeFilter)
{
RangeFilter rf = filter as RangeFilter;
if (!string.IsNullOrWhiteSpace(rf.From) || !string.IsNullOrWhiteSpace(rf.To))
{
queryOptions.FilterQueries.Add(new SolrQueryByRange <string>(rf.Field, rf.From, rf.To, rf.Inclusive, rf.Inclusive));
}
}
else if (filter is FieldFilter)
{
FieldFilter ff = filter as FieldFilter;
if (!string.IsNullOrWhiteSpace(ff.Value))
{
queryOptions.FilterQueries.Add(new SolrQueryByField(ff.Field, ff.Value));
}
}
}
}
#endregion 一般过滤条件
#region 杂过滤条件计算
AbstractSolrQuery expressiongResult = ComputerExpression(condition.FilterExpression);
if (expressiongResult != null)
{
queryOptions.FilterQueries.Add(expressiongResult);
}
#endregion 杂过滤条件计算
return(queryOptions);
}
