protected override SearchQuery DoBuild <TFilterField, TSortField>(SearchCriteria <TFilterField, TSortField> criteria, string dataQuery, string countQuery,
IDictionary <string, object> parameters, bool hasExistingConditions)
{
bool requiresPagination = criteria.RequiresPagination();
var dataQueryBuilder = new StringBuilder(dataQuery);
StringBuilder countQueryBuilder = requiresPagination ? new StringBuilder(countQuery) : null;
if (criteria.RequiresFiltering())
{
string filterClause = BuildFilterClause(criteria, parameters);
if (!string.IsNullOrWhiteSpace(filterClause))
{
AppendSpaceIfNeeded(dataQueryBuilder, countQueryBuilder);
Append(hasExistingConditions ? "AND" : "WHERE", dataQueryBuilder, countQueryBuilder);
AppendSpaceIfNeeded(dataQueryBuilder, countQueryBuilder);
Append(filterClause, dataQueryBuilder, countQueryBuilder);
}
}
//In SQL Server 2012+, to do pagination with OFFSET and FETCH NEXT, there must be at
//least one ORDER BY clause.
//If there are no sort specs, we add one using the first enum value in TSortField and
//ascending order.
if (requiresPagination && criteria.SortSpecs.Count == 0)
{
var sortField = (TSortField)Enum.GetValues(typeof(TSortField)).GetValue(0);
criteria.SortSpecs.Add(sortField, SortOrder.Ascending);
}
if (criteria.SortSpecs.Count > 0)
{
AppendSpaceIfNeeded(dataQueryBuilder);
dataQueryBuilder.Append("ORDER BY ");
for (var i = 0; i < criteria.SortSpecs.Count; i++)
{
if (i > 0)
{
dataQueryBuilder.Append(", ");
}
SortSpec <TSortField> sortSpec = criteria.SortSpecs[i];
//TODO:
//dataQueryBuilder.Append(
// SearchCriteria<TFilterField, TSortField>.SortFields[sortSpec.Field].ColumnName);
dataQueryBuilder.Append(sortSpec.Order == SortOrder.Ascending ? " ASC" : " DESC");
}
}
if (requiresPagination)
{
AppendSpaceIfNeeded(dataQueryBuilder);
dataQueryBuilder.Append($"OFFSET {criteria.StartRecord.GetValueOrDefault(0)} ROWS");
if (criteria.RecordCount.HasValue)
{
dataQueryBuilder.Append($" FETCH NEXT {criteria.RecordCount.Value} ROWS ONLY");
}
}
return(CreateSearchQueryInstance(dataQueryBuilder.ToString(), countQueryBuilder?.ToString(), parameters));
}
public static PagedList <TEntity> ToPagedList <TEntity>(this IEnumerable <TEntity> enumerable, int pageNumber,
int pageSize, SortSpec sortSpec = null)
{
if (sortSpec != null)
{
enumerable = enumerable.OrderBy(sortSpec);
}
return(new PagedList <TEntity>(enumerable, pageNumber, pageSize));
}
public static PagedList <TEntity> ToPagedList <TEntity>(this IQueryable <TEntity> queryable, int pageNumber,
int pageSize, SortSpec sortSpec = null)
{
if (sortSpec != null)
{
queryable = queryable.OrderBy(sortSpec);
}
return(new PagedList <TEntity>(queryable, pageNumber, pageSize));
}
public SortDefinition <T> Compile <T>(SortSpec sortSpec)
{
var sb = new StringBuilder();
sb.Append("{ ");
for (int i = 0; i < sortSpec.Fields.Length; i++)
{
var field = sortSpec.Fields[i];
var name = MongoNameFixer.Field(field.Name);
sb.AppendFormat("{0} : {1}", name, field.Order == SortSpecSortOrder.Ascending ? "1" : "-1");
if (i < sortSpec.Fields.Length - 1)
{
sb.Append(", ");
}
}
sb.Append(" }");
return(new BsonDocumentSortDefinition <T>(BsonSerializer.Deserialize <BsonDocument>(sb.ToString())));
}
public static IOrderedQueryable <TEntity> OrderBy <TEntity>(this IQueryable <TEntity> queryable, SortSpec sortSpec)
{
var prop = typeof(TEntity).GetProperties(BindingFlags.Public | BindingFlags.Instance)
.SingleOrDefault(p => p.Name.Equals(sortSpec.Member, StringComparison.OrdinalIgnoreCase));
if (prop == null)
{
throw new ArgumentException($"No property '{sortSpec.Member}' in '{typeof(TEntity).Name}'");
}
var arg = Expression.Parameter(typeof(TEntity));
var expr = Expression.Property(arg, prop);
var delegateType = typeof(Func <,>).MakeGenericType(typeof(TEntity), prop.PropertyType);
var lambda = Expression.Lambda(delegateType, expr, arg);
var methodName = sortSpec.SortDirection == ListSortDirection.Ascending ? "OrderBy" : "OrderByDescending";
var method = typeof(Queryable)
.GetMethods(BindingFlags.Static | BindingFlags.Public)
.Single(m => m.Name == methodName &&
m.IsGenericMethodDefinition &&
m.GetGenericArguments().Length == 2 &&
m.GetParameters().Length == 2);
return((IOrderedQueryable <TEntity>)method
.MakeGenericMethod(typeof(TEntity), prop.PropertyType)
.Invoke(null, new object[] { queryable, lambda }));
}
public void Clear()
{
this.Spec = null;
}
public void ByDegreeOfParallelism(AdlClient.OData.Models.OrderByDirection dir)
{
this.Spec = new SortSpec(jobfields.DegreeOfParallelism, dir);
}
public void ByState(AdlClient.OData.Models.OrderByDirection dir)
{
this.Spec = new SortSpec(jobfields.State, dir);
}
public void BySubmitter(AdlClient.OData.Models.OrderByDirection dir)
{
this.Spec = new SortSpec(jobfields.Submitter, dir);
}
public void ByResult(AdlClient.OData.Models.OrderByDirection dir)
{
this.Spec = new SortSpec(jobfields.Result, dir);
}
public void ByPriority(AdlClient.OData.Models.OrderByDirection dir)
{
this.Spec = new SortSpec(jobfields.Priority, dir);
}
public void Constructor_WithDefault_TypeIsCorrect()
{
var spec = new SortSpec();
Assert.That(spec.Type, Is.EqualTo(SortingOrder.lexicographic));
}
public void Constructor_WithSpecifiedSort_TypeIsCorrect()
{
var spec = new SortSpec(SortingOrder.alphanumeric);
Assert.That(spec.Type, Is.EqualTo(SortingOrder.alphanumeric));
}
