/// <summary>
/// </summary>
/// <param name="dictPars">查询参数字典</param>
/// <param name="start">分页开始标识</param>
/// <param name="rows">每页数量</param>
/// <param name="startTime">开始时间</param>
/// <param name="endTime">结束时间</param>
/// <param name="count">输出参数 总个数</param>
/// <returns></returns>
/// <remarks>peng.li 2015年7月23日14:11:43</remarks>
public static List<int> GroupingSerach(Dictionary<string, string> dictPars, int start, int rows,
DateTime startTime, DateTime endTime, out int count)
{
//定义solr
var solr = ServiceLocator.Current.GetInstance<ISolrOperations<LogItems>>();
var queryOptions = new QueryOptions();
//定义分组
var groupingParameters = new GroupingParameters();
groupingParameters.Fields = new Collection<string> { "logs_id" };
groupingParameters.Ngroups = true; //设置查询分组的总个数为true
//定义过滤条件
var timeRange = new SolrQueryByRange<DateTime>("logs_time", startTime, endTime);
queryOptions.AddFilterQueries(timeRange);
foreach (string key in dictPars.Keys)
{
queryOptions.AddFilterQueries(new SolrQueryByField(key, dictPars[key]));
}
//定义排序
queryOptions.OrderBy = new Collection<SortOrder> { new SortOrder("logs_id", Order.DESC) };
queryOptions.Grouping = groupingParameters;
queryOptions.Start = start;
queryOptions.Rows = rows;
SolrQueryResults<LogItems> res = solr.Query(SolrQuery.All, queryOptions);
GroupedResults<LogItems> items = res.Grouping["logs_id"];
count = items.Ngroups ?? 0;
return items.Groups.Select(item => Convert.ToInt32(item.GroupValue)).ToList();
}
/// <summary>
/// Return the top <see cref="RESULTS" /> results for a given natural language query in a channel.
/// </summary>
public List <CodeDoc> NaturalLangQuery(string search, string channelId)
{
ISolrOperations <CodeDoc> solr = ServiceLocator.Current.GetInstance <ISolrOperations <CodeDoc> >();
var opts = new QueryOptions();
var lang = GetLanguageRequest(search);
if (!string.IsNullOrEmpty(lang))
{
opts.AddFilterQueries(new SolrQueryByField("prog_language", lang));
}
opts.AddFilterQueries(new SolrQueryByField("channel", channelId));
opts.Rows = RESULTS;
var query = new LocalParams {
{ "type", "boost" }, { "b", "recip(ms(NOW,author_date),3.16e-11,-1,1)" }
} +(new SolrQuery("patch:\"" + search + "\"") || new SolrQuery("commit_message:\"" + search + "\""));
var codeQuery = solr.Query(query, opts);
List <CodeDoc> results = new List <CodeDoc>();
foreach (CodeDoc doc in codeQuery)
{
results.Add(doc);
}
return(results);
}
/// <summary>
/// 根据lambda表达式条件获取实体集合
/// </summary>
/// <param name="predicate">lambda表达式条件</param>
/// <returns></returns>
public List <TEntity> GetAllList(ICollection <KeyValuePair <string, string> > wheres)
{
if (wheres.Count > 1)
{
SolrQueryByField[] conds = new SolrQueryByField[wheres.Count];
int i = 0;
foreach (var param in wheres)
{
if (!string.IsNullOrWhiteSpace(param.Key))
{
conds[i] = new SolrQueryByField(param.Key, param.Value);
}
i++;
}
QueryOptions qo = new QueryOptions();
qo.AddFilterQueries(conds);
return(_solrOperations.Query(SolrQuery.All, qo));
}
else
{
SolrQueryByField qf = null;
foreach (var param in wheres)
{
qf = new SolrQueryByField(param.Key, param.Value);
}
return(_solrOperations.Query(qf));
}
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="startPage">页码</param>
/// <param name="pageSize">单页数据数</param>
/// <param name="rowCount">行数</param>
/// <param name="where">条件</param>
/// <param name="order">排序</param>
/// <returns></returns>
public List <TEntity> LoadPageList(int startPage, int pageSize, out int rowCount, ICollection <KeyValuePair <string, string> > wheres = null, ICollection <KeyValuePair <string, string> > orders = null)
{
QueryOptions options = new QueryOptions();
//分页参数
options.Rows = pageSize; //数据条数
options.Start = startPage; //开始项
// 拼接相关查询条件
SolrQueryByField[] conds = new SolrQueryByField[wheres.Count];
int i = 0;
foreach (var param in wheres)
{
if (!string.IsNullOrWhiteSpace(param.Key))
{
conds[i] = new SolrQueryByField(param.Key, param.Value);
}
i++;
}
options.AddFilterQueries(conds);
//执行查询
var results = _solrOperations.Query(SolrQuery.All, options);
// 得到返回的数据总条数和total和 总页数 用于分页显示，
rowCount = results.NumFound;
return(results);
}
public ISolrQueryResults<BaseballGame> ExecuteQuery()
{
List<ISolrQuery> fieldQueries = new List<ISolrQuery>();
QueryOptions options = new QueryOptions();
options.Facet = BuildBaseFacetQuery();
options.Rows = 200;
if (this.AppliedFacets.Count > 0)
{
var facetGroups = this.AppliedFacets.Select(t => t.Item1).Distinct().ToList();
foreach(var group in facetGroups)
{
List<ISolrQuery> queries = this.AppliedFacets.Where(fg => fg.Item1 == group).Select(q => new SolrQueryByField(q.Item1, q.Item2) as ISolrQuery).ToList();
SolrMultipleCriteriaQuery smcq =
new SolrMultipleCriteriaQuery(queries,"OR");
fieldQueries.Add(smcq);
}
ISolrQuery multipleCriteriaQuery = new SolrMultipleCriteriaQuery(fieldQueries, "AND");
options.AddFilterQueries(multipleCriteriaQuery);
}
options.OrderBy.Add(new SortOrder(this.CurrentSortTerm, this.SortDirection == "D" ? Order.DESC : Order.ASC));
options.AddFilterQueries(new SolrQueryByField("docType", DocType.BaseballGame.ToString()));
ISolrQuery finalQuery = SolrQuery.All;
if (!string.IsNullOrEmpty(this.SearchTerm))
{
finalQuery = new SolrQuery(this.SearchTerm);
}
return _solrOperations.Query(finalQuery, options);
}
/// <summary>
/// 根据lambda表达式条件获取单个实体
/// </summary>
/// <param name="predicate">lambda表达式条件</param>
/// <returns></returns>
public TEntity FirstOrDefault(ICollection <KeyValuePair <string, string> > wheres)
{
if (wheres.Count > 1)
{
SolrQueryByField[] conds = new SolrQueryByField[wheres.Count];
int i = 0;
foreach (var param in wheres)
{
if (!string.IsNullOrWhiteSpace(param.Key))
{
conds[i] = new SolrQueryByField(param.Key, param.Value);
}
i++;
}
QueryOptions qo = new QueryOptions();
qo.AddFilterQueries(conds);
var res = _solrOperations.Query(SolrQuery.All, qo);
if (res?.Count > 0)
{
return(res[0]);
}
else
{
return(null);
}
}
else
{
SolrQueryByField qf = null;
foreach (var param in wheres)
{
qf = new SolrQueryByField(param.Key, param.Value);
}
var res = _solrOperations.Query(qf);
if (res?.Count > 0)
{
return(res[0]);
}
else
{
return(null);
}
}
}
/// <summary>
/// 根据条件删除实体
/// </summary>
/// <param name="where">lambda表达式</param>
/// <param name="autoSave">是否自动保存</param>
public void Delete(ICollection <KeyValuePair <string, string> > wheres, bool autoSave = true)
{
//_solrOperations.Set<TEntity>().RemoveRange(_solrOperations.Set<TEntity>().Where(where).ToList());
if (wheres.Count > 1)
{
SolrQueryByField[] conds = new SolrQueryByField[wheres.Count];
int i = 0;
foreach (var param in wheres)
{
if (string.IsNullOrWhiteSpace(param.Key))
{
conds[i] = new SolrQueryByField(param.Key, param.Value);
}
}
QueryOptions qo = new QueryOptions();
qo.AddFilterQueries(conds);
var res = _solrOperations.Query(SolrQuery.All, qo);
if (res?.Count > 0)
{
_solrOperations.Delete(res);
if (autoSave)
{
Save();
}
}
}
else
{
SolrQueryByField qf = null;
foreach (var param in wheres)
{
qf = new SolrQueryByField(param.Key, param.Value);
}
if (qf != null)
{
_solrOperations.Query(qf);
if (autoSave)
{
Save();
}
}
}
}
/// <summary>
/// Queries Solr and looks for exact matches
/// </summary>
/// <param name="search"></param>
/// <param name="channelId"></param>
/// <returns></returns>
private List <CodeDoc> BasicQuery(string search, string channelId)
{
ISolrOperations <CodeDoc> solr = ServiceLocator.Current.GetInstance <ISolrOperations <CodeDoc> >();
List <ISolrQuery> filter = new List <ISolrQuery>();
var opts = new QueryOptions();
var lang = GetLanguageRequest(search);
if (!string.IsNullOrEmpty(lang))
{
filter.Add(new SolrQueryByField("prog_language", lang));
}
filter.Add(new SolrQueryByField("channel", channelId));
foreach (var filt in filter)
{
opts.AddFilterQueries(filt);
}
// return top n results
opts.Rows = RESULTS;
var query = new LocalParams {
{ "type", "boost" }, { "b", "recip(ms(NOW,author_date),3.16e-11,-1,1)" }
} +new SolrQuery("unindexed_patch:\"" + search + "\"");
var codeQuery = solr.Query(query, opts);
List <CodeDoc> results = new List <CodeDoc>();
foreach (CodeDoc doc in codeQuery)
{
results.Add(doc);
}
return(results);
}
internal SolrQueryResults <Dictionary <string, object> > Execute(SolrCompositeQuery compositeQuery, Type resultType)
{
var options = new QueryOptions();
if (compositeQuery.Methods != null)
{
var list1 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Select).Select(m => (SelectMethod)m).ToList();
if (list1.Any())
{
foreach (
var str in
list1.SelectMany(selectMethod => (IEnumerable <string>)selectMethod.FieldNames))
{
options.Fields.Add(str.ToLowerInvariant());
}
options.Fields.Add("_uniqueid");
options.Fields.Add("_datasource");
}
var list2 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.GetResults).Select(m => (GetResultsMethod)m).ToList();
if (list2.Any())
{
if (options.Fields.Count > 0)
{
options.Fields.Add("score");
}
else
{
options.Fields.Add("*");
options.Fields.Add("score");
}
}
var list3 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.OrderBy).Select(m => (OrderByMethod)m).ToList();
if (list3.Any())
{
foreach (var orderByMethod in list3)
{
var field = orderByMethod.Field;
options.AddOrder(new SortOrder(field,
orderByMethod.SortDirection == SortDirection.Ascending ? Order.ASC : Order.DESC));
}
}
int startIdx;
int maxHits;
this.GetMaxHits(compositeQuery, this._contentSearchSettings.SearchMaxResults(), out startIdx, out maxHits);
var list4 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Skip).Select(m => (SkipMethod)m).ToList();
if (list4.Any())
{
var num = list4.Sum(skipMethod => skipMethod.Count);
options.Start = new int?(num);
}
var list5 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Take).Select(m => (TakeMethod)m).ToList();
if (list5.Any())
{
var num = list5.Sum(takeMethod => takeMethod.Count);
options.Rows = new int?(num);
}
var list6 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Count).Select(m => (CountMethod)m).ToList();
if (compositeQuery.Methods.Count == 1 && list6.Any())
{
options.Rows = new int?(0);
}
var list7 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Any).Select(m => (AnyMethod)m).ToList();
if (compositeQuery.Methods.Count == 1 && list7.Any())
{
options.Rows = new int?(0);
}
var list8 =
compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.GetFacets).Select(m => (GetFacetsMethod)m).ToList();
if (compositeQuery.FacetQueries.Count > 0 &&
(list8.Any() ||
list2.Any()))
{
foreach (
var facetQuery in
GetFacetsPipeline.Run(
new GetFacetsArgs(null,
compositeQuery.FacetQueries, this._context.Index.Configuration.VirtualFieldProcessors, this._context.Index.FieldNameTranslator)).FacetQueries.ToHashSet())
{
if (facetQuery.FieldNames.Any())
{
var minimumResultCount = facetQuery.MinimumResultCount;
if (facetQuery.FieldNames.Count() == 1)
{
var fieldNameTranslator = this.FieldNameTranslator as SolrFieldNameTranslator;
var fieldName = facetQuery.FieldNames.First();
if (fieldNameTranslator != null &&
fieldName == fieldNameTranslator.StripKnownExtensions(fieldName) &&
this._context.Index.Configuration.FieldMap.GetFieldConfiguration(fieldName) == null)
{
fieldName =
fieldNameTranslator.GetIndexFieldName(
fieldName.Replace("__", "!").Replace("_", " ").Replace("!", "__"), true);
}
/**
* ******* UPDATED HERE *******
* If any FilterValues passed into the Facets, add them to the FilterValues AND the Facet On
* have them excluded
*/
if (facetQuery.FilterValues.Any())
{
options.AddFilterQueries(new LocalParams {
{ "tag", fieldName }
} +new SolrQueryInList(fieldName, facetQuery.FilterValues.Cast <string>()));
options.AddFacets(
new SolrFacetFieldQuery(new LocalParams {
{ "ex", fieldName }
} +fieldName));
}
else
{
options.AddFacets((ISolrFacetQuery) new SolrFacetFieldQuery(fieldName)
{
MinCount = minimumResultCount
});
}
}
if (facetQuery.FieldNames.Count() > 1)
{
options.AddFacets((ISolrFacetQuery) new SolrFacetPivotQuery()
{
Fields = (ICollection <string>) new string[1]
{
string.Join(",", facetQuery.FieldNames)
},
MinCount = minimumResultCount
});
}
}
}
if (!list2.Any())
{
options.Rows = new int?(0);
}
}
}
if (compositeQuery.Filter != null)
{
options.AddFilterQueries((ISolrQuery)compositeQuery.Filter);
}
options.AddFilterQueries((ISolrQuery) new SolrQueryByField("_indexname", this._context.Index.Name));
if (!this._settings.DefaultLanguage().StartsWith(this._cultureCode))
{
options.AddFilterQueries((ISolrQuery) new SolrQueryByField("_language", this._cultureCode + "*")
{
Quoted = false
});
}
var loggingSerializer = new SolrLoggingSerializer();
var q = loggingSerializer.SerializeQuery(compositeQuery.Query);
var solrSearchIndex = this._context.Index as SolrSearchIndex;
try
{
if (!options.Rows.HasValue)
{
options.Rows = new int?(this._contentSearchSettings.SearchMaxResults());
}
SearchLog.Log.Info("Query - " + q, null);
SearchLog.Log.Info(
"Serialized Query - ?q=" + q + "&" +
string.Join("&",
loggingSerializer.GetAllParameters(options).Select(p => string.Format("{0}={1}", p.Key, p.Value)).ToArray()),
null);
return(this.SolrOperations.Query(q, options));
}
catch (Exception ex)
{
if (!(ex is SolrConnectionException) && !(ex is SolrNetException))
{
throw;
}
else
{
var message = ex.Message;
if (ex.Message.StartsWith("<?xml"))
{
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml(ex.Message);
var xmlNode1 =
xmlDocument.SelectSingleNode("/response/lst[@name='error'][1]/str[@name='msg'][1]");
var xmlNode2 =
xmlDocument.SelectSingleNode(
"/response/lst[@name='responseHeader'][1]/lst[@name='params'][1]/str[@name='q'][1]");
if (xmlNode1 != null && xmlNode2 != null)
{
SearchLog.Log.Error(
string.Format("Solr Error : [\"{0}\"] - Query attempted: [{1}]",
xmlNode1.InnerText, xmlNode2.InnerText), null);
return(new SolrQueryResults <Dictionary <string, object> >());
}
}
Log.Error(message, this);
return(new SolrQueryResults <Dictionary <string, object> >());
}
}
}
internal SolrQueryResults <Dictionary <string, object> > Execute(SolrCompositeQuery compositeQuery, Type resultType)
{
var queryOpertions = new QueryOptions();
if (compositeQuery.Methods != null)
{
var selectFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Select).Select(m => (SelectMethod)m).ToList();
if (selectFields.Any())
{
foreach (var fieldName in selectFields.SelectMany(selectMethod => selectMethod.FieldNames))
{
queryOpertions.Fields.Add(fieldName.ToLowerInvariant());
}
if (!this.context.SecurityOptions.HasFlag(SearchSecurityOptions.DisableSecurityCheck))
{
queryOpertions.Fields.Add(BuiltinFields.UniqueId);
queryOpertions.Fields.Add(BuiltinFields.DataSource);
}
}
var getResultsFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.GetResults).Select(m => (GetResultsMethod)m).ToList();
if (getResultsFields.Any())
{
if (queryOpertions.Fields.Count > 0)
{
queryOpertions.Fields.Add("score");
}
else
{
queryOpertions.Fields.Add("*");
queryOpertions.Fields.Add("score");
}
}
var sortFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.OrderBy).Select(m => ((OrderByMethod)m)).ToList();
if (sortFields.Any())
{
foreach (var sortField in sortFields)
{
var fieldName = sortField.Field;
queryOpertions.AddOrder(new SortOrder(fieldName, sortField.SortDirection == SortDirection.Ascending ? Order.ASC : Order.DESC));
}
}
var skipFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Skip).Select(m => (SkipMethod)m).ToList();
if (skipFields.Any())
{
var start = skipFields.Sum(skipMethod => skipMethod.Count);
queryOpertions.Start = start;
}
var takeFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Take).Select(m => (TakeMethod)m).ToList();
if (takeFields.Any())
{
var rows = takeFields.Sum(takeMethod => takeMethod.Count);
queryOpertions.Rows = rows;
}
var countFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Count).Select(m => (CountMethod)m).ToList();
if (compositeQuery.Methods.Count == 1 && countFields.Any())
{
queryOpertions.Rows = 0;
}
var anyFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Any).Select(m => (AnyMethod)m).ToList();
if (compositeQuery.Methods.Count == 1 && anyFields.Any())
{
queryOpertions.Rows = 0;
}
var facetFields = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.GetFacets).Select(m => (GetFacetsMethod)m).ToList();
if (compositeQuery.FacetQueries.Count > 0 && (facetFields.Any() || getResultsFields.Any()))
{
var result = GetFacetsPipeline.Run(this.pipeline, new GetFacetsArgs(null, compositeQuery.FacetQueries, this.context.Index.Configuration.VirtualFieldProcessors, this.context.Index.FieldNameTranslator));
var facetQueries = result.FacetQueries.ToHashSet();
foreach (var facetQuery in facetQueries)
{
if (!facetQuery.FieldNames.Any())
{
continue;
}
var minCount = facetQuery.MinimumResultCount;
if (facetQuery.FieldNames.Count() == 1)
{
var fn = FieldNameTranslator as SolrFieldNameTranslator;
var fieldName = facetQuery.FieldNames.First();
if (fn != null && fieldName == fn.StripKnownExtensions(fieldName) && this.context.Index.Configuration.FieldMap.GetFieldConfiguration(fieldName) == null)
{
fieldName = fn.GetIndexFieldName(fieldName.Replace("__", "!").Replace("_", " ").Replace("!", "__"), true);
}
queryOpertions.AddFacets(new SolrFacetFieldQuery(fieldName)
{
MinCount = minCount
});
}
if (facetQuery.FieldNames.Count() > 1)
{
queryOpertions.AddFacets(new SolrFacetPivotQuery {
Fields = new[] { string.Join(",", facetQuery.FieldNames) }, MinCount = minCount
});
}
}
if (!getResultsFields.Any())
{
queryOpertions.Rows = 0;
}
}
}
if (compositeQuery.Filter != null)
{
queryOpertions.AddFilterQueries(compositeQuery.Filter);
}
queryOpertions.AddFilterQueries(new SolrQueryByField(BuiltinFields.IndexName, this.context.Index.Name));
if (!Settings.DefaultLanguage.StartsWith(this.cultureCode))
{
queryOpertions.AddFilterQueries(new SolrQueryByField(BuiltinFields.Language, this.cultureCode + "*")
{
Quoted = false
});
}
var querySerializer = new SolrLoggingSerializer();
var serializedQuery = querySerializer.SerializeQuery(compositeQuery.Query);
var idx = this.context.Index as SolrSearchIndex;
PrepareHiglightOptions(compositeQuery, queryOpertions);
try
{
if (queryOpertions.Rows == null)
{
queryOpertions.Rows = this.contentSearchSettings.SearchMaxResults();
}
SearchLog.Log.Info("Query - " + serializedQuery);
SearchLog.Log.Info("Serialized Query - " + "?q=" + serializedQuery + "&" + string.Join("&", querySerializer.GetAllParameters(queryOpertions).Select(p => string.Format("{0}={1}", p.Key, p.Value)).ToArray()));
return(GetOperations(idx).Query(serializedQuery, queryOpertions));
}
catch (Exception exception)
{
if (!(exception is SolrConnectionException) && !(exception is SolrNetException))
{
throw;
}
var message = exception.Message;
if (exception.Message.StartsWith("<?xml"))
{
var doc = new XmlDocument();
doc.LoadXml(exception.Message);
var errorNode = doc.SelectSingleNode("/response/lst[@name='error'][1]/str[@name='msg'][1]");
var queryNode = doc.SelectSingleNode("/response/lst[@name='responseHeader'][1]/lst[@name='params'][1]/str[@name='q'][1]");
if (errorNode != null && queryNode != null)
{
message = string.Format("Solr Error : [\"{0}\"] - Query attempted: [{1}]", errorNode.InnerText, queryNode.InnerText);
SearchLog.Log.Error(message);
return(new SolrQueryResults <Dictionary <string, object> >());
}
}
Log.Error(message, this);
return(new SolrQueryResults <Dictionary <string, object> >());
}
}
public void BuildQuery(QueryOptions queryOptions)
{
string excludes;
if (FacetIsApplied())
{
queryOptions
.AddFilterQueries(BuildFilterQuery());
}
queryOptions
.AddFacets(_ranges
.Select(range => range.BuildFacetQuery(_solrField, _filterQueryTag, FacetIsApplied()))
.ToArray());
if (WeHaveExclusionFilters(_facets, out excludes))
{
queryOptions
.AddFacets(_ranges
.Select(range => range.BuildFacetQuery(_solrField, excludes))
.ToArray());
}
}