/// <summary>
/// Add a field into the sorting of result
/// </summary>
/// <returns>FindRequest with new sorting option</returns>
/// <param name="field">The sort field</param>
/// <param name="ascending">True if direction of sort is Asceding use false for Descending(Default is True)</param>
public FindRequest <T> Sort(Expression <Func <T, object> > field, bool ascending = true)
{
var fieldName = Metadata.GetMemberInfo(field).Member.Name;
SortFields.Add(new Sorting(fieldName, ascending));
return(this);
}
public void AddSortField(SortField sortField)
{
if (string.IsNullOrWhiteSpace(sortField.Label))
{
sortField.Label = TextService.Title(sortField.Name);
}
SortFields.Add(sortField);
}
SortEdgeTable
(
ListObject oEdgeTable,
Range oRangeToSortOn
)
{
Debug.Assert(oEdgeTable != null);
Debug.Assert(oRangeToSortOn != null);
AssertValid();
Sort oSort = oEdgeTable.Sort;
SortFields oSortFields = oSort.SortFields;
oSortFields.Clear();
oSortFields.Add(oRangeToSortOn, XlSortOn.xlSortOnValues,
XlSortOrder.xlAscending, Missing.Value,
XlSortDataOption.xlSortNormal);
oSort.Apply();
oSortFields.Clear();
}
/// <summary>
/// Add sort field. Use + prefix for asc sorting, or use - prefix for desc sorting.
/// </summary>
public IndexQuery AddOrderBy(string field)
{
var reverse = false;
if (field[0] == '+' || field[0] == '-')
{
reverse = field[0] == '-';
field = field.Substring(1);
}
var sortType = Lucene.Net.Search.SortField.STRING;
var property = ModelType.GetProperty(field, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
if (property != null)
{
sortType = LuceneUtility.GetSortType(property.PropertyType);
}
SortFields.Add(new SortField(field, sortType, reverse));
return(this);
}
/// <summary>
/// Internal operation for adding the ordered results
/// </summary>
/// <param name="descending">if set to <c>true</c> [descending].</param>
/// <param name="fields">The field names.</param>
/// <returns>A new <see cref="IBooleanOperation"/> with the clause appended</returns>
private LuceneBooleanOperation OrderByInternal(bool descending, params SortableField[] fields)
{
if (fields == null)
{
throw new ArgumentNullException(nameof(fields));
}
foreach (var f in fields)
{
var fieldName = f.FieldName;
var defaultSort = SortField.STRING;
switch (f.SortType)
{
case SortType.Score:
defaultSort = SortField.SCORE;
break;
case SortType.DocumentOrder:
defaultSort = SortField.DOC;
break;
case SortType.String:
defaultSort = SortField.STRING;
break;
case SortType.Int:
defaultSort = SortField.INT;
break;
case SortType.Float:
defaultSort = SortField.FLOAT;
break;
case SortType.Long:
defaultSort = SortField.LONG;
break;
case SortType.Double:
defaultSort = SortField.DOUBLE;
break;
case SortType.Short:
defaultSort = SortField.SHORT;
break;
case SortType.Byte:
defaultSort = SortField.BYTE;
break;
default:
throw new ArgumentOutOfRangeException();
}
//get the sortable field name if this field type has one
var valType = _searchContext.GetFieldValueType(fieldName);
if (valType?.SortableFieldName != null)
{
fieldName = valType.SortableFieldName;
}
SortFields.Add(new SortField(fieldName, defaultSort, descending));
}
return(new LuceneBooleanOperation(this));
}
public FindRequest <T> Sort(string fieldName, bool ascending = true)
{
SortFields.Add(new Sorting(fieldName, ascending));
return(this);
}
public void AddField(SortField <T> field)
{
SortFields.Add(field);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
Trace(MethodInfo.GetCurrentMethod(), node);
var visited = base.VisitMethodCall(node);
var methodCallExpr = visited as MethodCallExpression;
if (methodCallExpr == null)
{
throw new NotSupportedException("#VisitMethodCall if visited is not null");
}
switch (methodCallExpr.Method.Name)
{
case "OfType":
// Do nothing. Type of expression has been changed so a TypeIs query will be created.
case "Where":
// do nothing
break;
case "Take":
var topExpr = GetArgumentAsConstant(methodCallExpr, 1);
this.Top = (int)topExpr.Value;
break;
case "Skip":
var skipExpr = GetArgumentAsConstant(methodCallExpr, 1);
this.Skip = (int)skipExpr.Value;
break;
case "Count":
if (node.Arguments.Count == 2)
{
if (_queries.Count > 1) // There is Where in the main expression
{
CombineTwoQueriesOnStack();
}
}
this.CountOnly = true;
break;
case "ThenBy":
case "OrderBy":
SortFields.Add(CreateSortFieldFromExpr(node, false));
break;
case "ThenByDescending":
case "OrderByDescending":
SortFields.Add(CreateSortFieldFromExpr(node, true));
break;
case "StartsWith":
var startsWithExpr = GetArgumentAsConstant(methodCallExpr, 0);
var startsWithArg = (string)startsWithExpr.Value;
BuildWildcardQuery(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtEnd, startsWithArg);
break;
case "EndsWith":
var endsWithExpr = GetArgumentAsConstant(methodCallExpr, 0);
var endsWithArg = (string)endsWithExpr.Value;
BuildWildcardQuery(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStart, endsWithArg);
break;
case "Contains":
var arg0 = methodCallExpr.Arguments[0];
var constantExpr = arg0 as ConstantExpression;
if (constantExpr != null)
{
if (constantExpr.Type == typeof(string))
{
var containsArg = (string)constantExpr.Value;
BuildWildcardQuery(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStartAndEnd, containsArg);
break;
}
throw new NotSupportedException(String.Format("Calling Contains on an instance of type {0} is not supported. Allowed types: string, IEnumerable<Node>.", constantExpr.Type));
}
var memberExpr = arg0 as MemberExpression;
if (memberExpr != null)
{
if (memberExpr.Type == typeof(IEnumerable <Node>))
{
var rightConstant = methodCallExpr.Arguments[1] as ConstantExpression;
if (rightConstant != null)
{
var nodeValue = (Node)rightConstant.Value;
BuildTermQuery(memberExpr.Member.Name, nodeValue);
break;
}
throw NotSupportedException(node, "#1");
}
throw NotSupportedException(node, "#2");
}
throw NotSupportedException(node, "#3");
case "First":
this.Top = 1;
this.ThrowIfEmpty = true;
if (methodCallExpr.Arguments.Count == 2)
{
if (_queries.Count > 1)
{
CombineTwoQueriesOnStack();
}
}
break;
case "FirstOrDefault":
this.ThrowIfEmpty = false;
this.Top = 1;
if (methodCallExpr.Arguments.Count == 2)
{
if (_queries.Count > 1) // There is Where in the main expression
{
CombineTwoQueriesOnStack();
}
}
break;
case "Any":
this.CountOnly = true;
this.ExistenceOnly = true;
this.Top = 1;
if (methodCallExpr.Arguments.Count == 2)
{
if (_queries.Count > 1)
{
CombineTwoQueriesOnStack();
}
}
break;
case "Type":
var typeExpr = GetArgumentAsConstant(methodCallExpr, 0);
BuildTermQuery("Type", (string)typeExpr.Value);
break;
case "TypeIs":
var typeIsExpr = GetArgumentAsConstant(methodCallExpr, 0);
BuildTermQuery("TypeIs", (string)(typeIsExpr).Value);
break;
case "get_Item":
var typedParamExpr = methodCallExpr.Object as ParameterExpression;
if (typedParamExpr == null)
{
throw new NotSupportedException("#get_Item");
}
break;
case "startswith":
{
var fieldName = GetPropertyName(methodCallExpr.Arguments[0]);
var startswithExpr = GetArgumentAsConstant(methodCallExpr, 1);
var arg = (string)startswithExpr.Value;
BuildWildcardQuery(fieldName, WildcardPosition.AtEnd, arg);
break;
}
case "endswith":
{
var fieldName = GetPropertyName(methodCallExpr.Arguments[0]);
var endswithExpr = GetArgumentAsConstant(methodCallExpr, 1);
var arg = (string)endswithExpr.Value;
BuildWildcardQuery(fieldName, WildcardPosition.AtStart, arg);
break;
}
case "substringof":
{
var fieldName = GetPropertyName(methodCallExpr.Arguments[1]);
var substringofExpr = GetArgumentAsConstant(methodCallExpr, 0);
var arg = (string)substringofExpr.Value;
BuildWildcardQuery(fieldName, WildcardPosition.AtStartAndEnd, arg);
break;
}
case "isof":
{
var isofExpr = GetArgumentAsConstant(methodCallExpr, 1);
BuildTermQuery("TypeIs", (string)(isofExpr).Value);
break;
}
case "InFolder":
{
var infolderexpr = GetArgumentAsConstant(methodCallExpr, 0);
var folder = infolderexpr.Value;
BuildTermQuery("InFolder", GetPath(folder, "InFolder"));
break;
}
case "InTree":
{
var intreeexpr = GetArgumentAsConstant(methodCallExpr, 0);
var folder = intreeexpr.Value;
BuildTermQuery("InTree", GetPath(folder, "InTree"));
break;
}
case "GetType":
{
var member = methodCallExpr.Object as MemberExpression;
if (member != null && member.Member == typeof(Content).GetProperty("ContentHandler"))
{
_queries.Push(new ContentHandlerGetTypeQuery());
}
else
{
throw new NotSupportedException("GetType method is not supported: " + node);
}
break;
}
case "IsAssignableFrom":
{
var member = methodCallExpr.Object as ConstantExpression;
if (member == null)
{
throw new NotSupportedException("IsAssignableFrom method is not supported: " + node);
}
var type = member.Value as Type;
if (type == null)
{
throw new NotSupportedException("IsAssignableFrom method is not supported" + node);
}
if (_queries.Count == 0)
{
throw new NotSupportedException("IsAssignableFrom method is not supported" + node);
}
var q = _queries.Pop() as ContentHandlerGetTypeQuery;
if (q == null)
{
throw new NotSupportedException("IsAssignableFrom method is not supported" + node);
}
_queries.Push(CreateTypeIsQuery(type));
break;
}
default:
throw new SnNotSupportedException("Unknown method: " + methodCallExpr.Method.Name);
}
return(visited);
}
DeleteDuplicateRows
(
ListObject oEdgeTable,
ListColumn oEdgeWeightColumn,
Range oEdgeWeightData,
Object [,] aoEdgeWeightValues
)
{
Debug.Assert(oEdgeTable != null);
Debug.Assert(oEdgeWeightColumn != null);
Debug.Assert(oEdgeWeightData != null);
Debug.Assert(aoEdgeWeightValues != null);
AssertValid();
Range oDuplicateRows = null;
// Find the rows with null edge weights, which are the duplicates. To
// avoid multiple areas, which can slow things down signficantly, sort
// the table on the edge weight column. That forces the duplicates
// to be contiguous.
//
// But first, add a temporary column and set its values to the
// worksheet row numbers. This will be used later to restore the
// original sort order.
ListColumn oTemporaryColumn;
if (!ExcelUtil.TryAddTableColumnWithRowNumbers(oEdgeTable,
"Temporary for Sort", 5F, null, out oTemporaryColumn))
{
return;
}
Sort oSort = oEdgeTable.Sort;
SortFields oSortFields = oSort.SortFields;
oSortFields.Clear();
oSortFields.Add(oEdgeWeightColumn.Range, XlSortOn.xlSortOnValues,
XlSortOrder.xlAscending, Missing.Value,
XlSortDataOption.xlSortNormal);
oSort.Apply();
if (oEdgeWeightData.Rows.Count != 1)
{
try
{
oDuplicateRows = oEdgeWeightData.SpecialCells(
XlCellType.xlCellTypeBlanks, Missing.Value);
}
catch (COMException)
{
// There are no such rows.
oDuplicateRows = null;
}
}
else
{
// Range.SpecialCells() can't be used in the one-cell case, for
// which it behaves in a bizarre manner. See this posting:
//
// http://ewbi.blogs.com/develops/2006/03/determine_if_a_.html
//
// ...of which this is an excerpt:
//
// "SpecialCells ignores any source Range consisting of only one
// cell. When executing SpecialCells on a Range having only one
// cell, it will instead consider all of the cells falling within
// the boundary marked by the bottom right cell of the source Range
// sheet's UsedRange."
//
// Instead, just check the single row.
if (aoEdgeWeightValues[1, 1] == null)
{
oDuplicateRows = oEdgeWeightData.EntireRow;
}
}
if (oDuplicateRows != null)
{
// Delete the duplicate rows, which are contiguous.
Debug.Assert(oDuplicateRows.Areas.Count == 1);
oDuplicateRows.EntireRow.Delete(XlDeleteShiftDirection.xlShiftUp);
}
// Restore the original sort order by sorting on the temporary column
// that contains the original worksheet row numbers.
Debug.Assert(oTemporaryColumn != null);
oSortFields.Clear();
oSortFields.Add(oTemporaryColumn.Range, XlSortOn.xlSortOnValues,
XlSortOrder.xlAscending, Missing.Value,
XlSortDataOption.xlSortNormal);
oSort.Apply();
oSortFields.Clear();
oTemporaryColumn.Delete();
oSort.Apply();
}
