private TResult ApplyScalarMethods <TResult, TDocument>(SolrCompositeQuery compositeQuery, SolrSearchResults <TDocument> processedResults, SolrQueryResults <Dictionary <string, object> > results)
{
var queryMethod = compositeQuery.Methods.First();
object obj;
switch (queryMethod.MethodType)
{
case QueryMethodType.All:
obj = true;
break;
case QueryMethodType.Any:
obj = processedResults.Any() ? 1 : 0;
break;
case QueryMethodType.Count:
obj = !compositeQuery.Methods.Any(i =>
{
if (i.MethodType != QueryMethodType.Take)
{
return(i.MethodType == QueryMethodType.Skip);
}
return(true);
}) ? processedResults.Count() : (object)results.Count();
break;
case QueryMethodType.ElementAt:
obj = !((ElementAtMethod)queryMethod).AllowDefaultValue ? processedResults.ElementAt(((ElementAtMethod)queryMethod).Index) : (object)processedResults.ElementAtOrDefault(((ElementAtMethod)queryMethod).Index);
break;
case QueryMethodType.First:
obj = !((FirstMethod)queryMethod).AllowDefaultValue ? processedResults.First() : (object)processedResults.FirstOrDefault();
break;
case QueryMethodType.Last:
obj = !((LastMethod)queryMethod).AllowDefaultValue ? processedResults.Last() : (object)processedResults.LastOrDefault();
break;
case QueryMethodType.Single:
obj = !((SingleMethod)queryMethod).AllowDefaultValue ? processedResults.Single() : (object)processedResults.SingleOrDefault();
break;
case QueryMethodType.GetResults:
var searchHits = processedResults.GetSearchHits();
var facetResults = this.FormatFacetResults(processedResults.GetFacets(), compositeQuery.FacetQueries);
obj = ReflectionUtility.CreateInstance(typeof(TResult), (object)searchHits, (object)processedResults.NumberFound, (object)facetResults);
break;
case QueryMethodType.GetFacets:
obj = this.FormatFacetResults(processedResults.GetFacets(), compositeQuery.FacetQueries);
break;
default:
throw new InvalidOperationException("Invalid query method");
}
return((TResult)Convert.ChangeType(obj, typeof(TResult)));
}
private static SelectMethod GetSelectMethod(SolrCompositeQuery compositeQuery)
{
var list = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Select).Select(m => (SelectMethod)m).ToList();
if (list.Count() != 1)
{
return(null);
}
return(list[0]);
}
public override IEnumerable <TElement> FindElements <TElement>(SolrCompositeQuery compositeQuery)
{
var results = this.Execute(compositeQuery, typeof(TElement));
var selectMethods = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Select).Select(m => (SelectMethod)m).ToList();
var selectMethod = selectMethods.Count() == 1 ? selectMethods[0] : null;
var processedResults = new SolrSearchResults <TElement>(this.context, results, selectMethod, compositeQuery.ExecutionContexts, compositeQuery.VirtualFieldProcessors);
return(processedResults.GetSearchResults());
}
// called from the base class using reflection!!!!
private TResult ApplyScalarMethods <TResult, TDocument>(SolrCompositeQuery compositeQuery,
object processedResults,
object results)
{
var type = typeof(LinqToSolrIndex <>).MakeGenericType(typeof(TItem));
MethodInfo baseMethod = type
.GetMethod("ApplyScalarMethods", BindingFlags.NonPublic | BindingFlags.Instance).MakeGenericMethod(typeof(TResult), typeof(TDocument));
var ret = baseMethod.Invoke(this, new object[] { compositeQuery, processedResults, results });
return((TResult)ret);
}
private void PrepareHiglightOptions(SolrCompositeQuery query, QueryOptions options)
{
var extQuery = query as SolrCompositeQueryWithHighlights;
if (extQuery == null || extQuery.HighlightParameters == null)
{
return;
}
var highlightOptions = new HighlightingParameters();
highlightOptions.Fields = extQuery.HighlightParameters;
options.Highlight = highlightOptions;
}
public override TResult Execute <TResult>(SolrCompositeQuery compositeQuery)
{
var queryWithHighlighting = compositeQuery as SolrCompositeQueryWithHighlights;
bool resWithHighlights = queryWithHighlighting != null && typeof(TResult).GetGenericTypeDefinition() == typeof(SearchResultsWithHighlights <>);
// TODO Check this condition in more details
if (typeof(TResult).IsGenericType && (typeof(TResult).GetGenericTypeDefinition() == typeof(SearchResults <>) || resWithHighlights))
{
var documentType = typeof(TResult).GetGenericArguments()[0];
var results = this.Execute(compositeQuery, documentType);
var solrSearchResultsType = typeof(SolrSearchResults <>);
var solrSearchResultsGenericType = solrSearchResultsType.MakeGenericType(documentType);
var applyScalarMethodsMethod = this.GetType().GetMethod("ApplyScalarMethods", BindingFlags.Instance | BindingFlags.NonPublic);
// We need to handle the search result for the GetResultsWithHighlights as for the default GetResults case:
Type returnType = (resWithHighlights) ? typeof(SearchResults <>).MakeGenericType(documentType) : typeof(TResult);
var applyScalarMethodsGenericMethod = applyScalarMethodsMethod.MakeGenericMethod(returnType, documentType);
var selectMethod = GetSelectMethod(compositeQuery);
// Execute query methods
var processedResults = ReflectionUtility.CreateInstance(solrSearchResultsGenericType, this.context, results, selectMethod, compositeQuery.ExecutionContexts, compositeQuery.VirtualFieldProcessors);
var searchResult = applyScalarMethodsGenericMethod.Invoke(this, new object[] { compositeQuery, processedResults, results });
if (resWithHighlights)
{
return((TResult)ReflectionUtility.CreateInstance(typeof(TResult), searchResult, results.Highlights));
}
return((TResult)searchResult);
}
else
{
var results = this.Execute(compositeQuery, typeof(TResult));
var selectMethod = GetSelectMethod(compositeQuery);
var processedResults = new SolrSearchResults <TResult>(this.context, results, selectMethod, compositeQuery.ExecutionContexts, compositeQuery.VirtualFieldProcessors);
return(this.ApplyScalarMethods <TResult, TResult>(compositeQuery, processedResults, results));
}
}
private void PrepareHiglightOptions(SolrCompositeQuery query, QueryOptions options)
{
var extQuery = query as SolrCompositeQueryWithHighlights;
if (extQuery == null || extQuery.HighlightParameters == null)
{
return;
}
var highlightOptions = new HighlightingParameters();
highlightOptions.Fields = extQuery.HighlightParameters;
highlightOptions.Snippets = extQuery.Snippets;
highlightOptions.BeforeTerm = "<" + extQuery.Htmltag + ">";
highlightOptions.AfterTerm = "</" + extQuery.Htmltag + ">";
highlightOptions.Fragsize = extQuery.FragmentSize;
options.Highlight = highlightOptions;
}
public override TResult Execute <TResult>(SolrCompositeQuery compositeQuery)
{
if (EnumerableLinq.ShouldExecuteEnumerableLinqQuery(compositeQuery))
{
return(EnumerableLinq.ExecuteEnumerableLinqQuery <TResult>(compositeQuery));
}
if (typeof(TResult).IsGenericType &&
typeof(TResult).GetGenericTypeDefinition() == typeof(SearchResults <>))
{
var resultType = typeof(TResult).GetGenericArguments()[0];
var solrQueryResults = this.Execute(compositeQuery, resultType);
var type = typeof(SolrSearchResults <>).MakeGenericType(resultType);
var methodInfo = this.GetType()
.GetMethod("ApplyScalarMethods", BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(typeof(TResult), resultType);
var selectMethod = GetSelectMethod(compositeQuery);
var instance = ReflectionUtility.CreateInstance(type, (object)this._context, (object)solrQueryResults,
(object)selectMethod, (object)compositeQuery.ExecutionContexts,
(object)compositeQuery.VirtualFieldProcessors);
return((TResult)methodInfo.Invoke(this, new object[3]
{
compositeQuery,
instance,
solrQueryResults
}));
}
compositeQuery.Methods.Add(new GetFacetsMethod());
var solrQueryResults1 = this.Execute(compositeQuery, typeof(TResult));
var selectMethod1 = GetSelectMethod(compositeQuery);
var processedResults = new SolrSearchResults <TResult>(this._context, solrQueryResults1, selectMethod1, compositeQuery.ExecutionContexts, compositeQuery.VirtualFieldProcessors);
return(this.ApplyScalarMethods <TResult, TResult>(compositeQuery, processedResults, solrQueryResults1));
}
private int GetMaxHits(SolrCompositeQuery query, int maxDoc, out int startIdx, out int maxHits)
{
var list = query.Methods != null ? new List <QueryMethod>(query.Methods) : new List <QueryMethod>();
list.Reverse();
var modifierScalarMethod = this.GetMaxHitsModifierScalarMethod(query.Methods);
startIdx = 0;
var num1 = maxDoc;
var num2 = num1;
var num3 = num1;
var num4 = 0;
foreach (var queryMethod in list)
{
switch (queryMethod.MethodType)
{
case QueryMethodType.Skip:
var count = ((SkipMethod)queryMethod).Count;
if (count > 0)
{
startIdx += count;
continue;
}
continue;
case QueryMethodType.Take:
num4 = ((TakeMethod)queryMethod).Count;
if (num4 <= 0)
{
num1 = startIdx++;
continue;
}
if (num4 > 1 && modifierScalarMethod != null && modifierScalarMethod.MethodType == QueryMethodType.First)
{
num4 = 1;
}
if (num4 > 1 && modifierScalarMethod != null && modifierScalarMethod.MethodType == QueryMethodType.Any)
{
num4 = 1;
}
if (num4 > 2 && modifierScalarMethod != null && modifierScalarMethod.MethodType == QueryMethodType.Single)
{
num4 = 2;
}
num1 = startIdx + num4 - 1;
if (num1 > num2)
{
num1 = num2;
continue;
}
if (num2 < num1)
{
num2 = num1;
continue;
}
continue;
default:
continue;
}
}
if (num3 == num1)
{
num4 = -1;
if (modifierScalarMethod != null && modifierScalarMethod.MethodType == QueryMethodType.First)
{
num4 = 1;
}
if (modifierScalarMethod != null && modifierScalarMethod.MethodType == QueryMethodType.Any)
{
num4 = 1;
}
if (modifierScalarMethod != null && modifierScalarMethod.MethodType == QueryMethodType.Single)
{
num4 = 2;
}
if (num4 >= 0)
{
num1 = startIdx + num4 - 1;
if (num1 > num2)
{
num1 = num2;
}
else if (num2 < num1)
{
;
}
}
}
if (num3 == num1 && startIdx == 0 && (modifierScalarMethod != null && modifierScalarMethod.MethodType == QueryMethodType.Count))
{
;
}
maxHits = num4;
return(maxHits);
}
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> >());
}
}
}
private TResult ApplyScalarMethods <TResult, TDocument>(SolrCompositeQuery compositeQuery, SolrSearchResults <TDocument> processedResults, SolrQueryResults <Dictionary <string, object> > results)
{
var method = compositeQuery.Methods.First();
object result;
switch (method.MethodType)
{
case QueryMethodType.All:
result = true;
break;
case QueryMethodType.Any:
result = processedResults.Any();
break;
case QueryMethodType.Count:
result = processedResults.Count();
break;
case QueryMethodType.ElementAt:
if (((ElementAtMethod)method).AllowDefaultValue)
{
result = processedResults.ElementAtOrDefault(((ElementAtMethod)method).Index);
}
else
{
result = processedResults.ElementAt(((ElementAtMethod)method).Index);
}
break;
case QueryMethodType.First:
if (((FirstMethod)method).AllowDefaultValue)
{
result = processedResults.FirstOrDefault();
}
else
{
result = processedResults.First();
}
break;
case QueryMethodType.Last:
if (((LastMethod)method).AllowDefaultValue)
{
result = processedResults.LastOrDefault();
}
else
{
result = processedResults.Last();
}
break;
case QueryMethodType.Single:
if (((SingleMethod)method).AllowDefaultValue)
{
result = processedResults.SingleOrDefault();
}
else
{
result = processedResults.Single();
}
break;
case QueryMethodType.GetResults:
var resultList = processedResults.GetSearchHits();
var facets = this.FormatFacetResults(processedResults.GetFacets(), compositeQuery.FacetQueries);
result = ReflectionUtility.CreateInstance(typeof(TResult), resultList, processedResults.NumberFound, facets); // Create instance of SearchResults<TDocument>
break;
case QueryMethodType.GetFacets:
result = this.FormatFacetResults(processedResults.GetFacets(), compositeQuery.FacetQueries);
break;
default:
throw new InvalidOperationException("Invalid query method");
}
return((TResult)System.Convert.ChangeType(result, typeof(TResult)));
}
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> >());
}
}
private static SelectMethod GetSelectMethod(SolrCompositeQuery compositeQuery)
{
var selectMethods = compositeQuery.Methods.Where(m => m.MethodType == QueryMethodType.Select).Select(m => (SelectMethod)m).ToList();
return(selectMethods.Count() == 1 ? selectMethods[0] : null);
}
public SolrCompositeQueryWithHighlights(SolrCompositeQuery query, GetResultsOptions options = GetResultsOptions.Default)
: base(query.Query, query.Filter, query.Methods, query.VirtualFieldProcessors, query.FacetQueries, query.ExecutionContexts)
{
this.Methods.Insert(0, new GetResultsMethod(options));
}
/*
* THIS METHOD IS A TOTAL HACK
* They exist to work around a bug in Sitecore (7.x-8.0 at least) where it uses private reflection
* in such a way that it breaks all derived classes of LinqToSolrIndex when the solr query is mapped
* in a particular way, such as when using a database name in your search query.
*
* These basically act as proxies so the private reflection in Sitecore hits these methods,
* which then reflect the call down to the base class' private method as is expected.
*
* Source of hack: the Execute() method on the base class doing this:
* MethodInfo methodInfo = this.GetType().GetMethod("ApplyScalarMethods", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(typeof (TResult), resultType);
*
* The this.GetType() cause it to look for the private methods on any derived classes, where they do not exist.
*/
// ReSharper disable once UnusedMember.Local
private TResult ApplyScalarMethods <TResult, TDocument>(SolrCompositeQuery compositeQuery, object processedResults, SolrQueryResults <Dictionary <string, object> > results)
{
var baseMethod = typeof(LinqToSolrIndex <T>).GetMethod("ApplyScalarMethods", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(typeof(TResult), typeof(TDocument));
return((TResult)baseMethod.Invoke(this, new[] { compositeQuery, processedResults, results }));
}
