protected override void OnCompile()
{
if (SyntaxNode.GroupByClause != null)
{
Select = SyntaxNode.GroupByClause.CreateGroupBySelector <TSource, TResult>(SyntaxNode.Columns.Aggregates);
}
else
{
Select = SyntaxNode.Columns.CreateSelector <TSource, TResult>();
}
// build up the source and result filters
if (SyntaxNode.WhereClause != null)
{
SourceFilters.Add(list => list.Where(SyntaxNode.WhereClause.CreateEvaluator <TSource>()));
}
if (SyntaxNode.OrderByClause != null)
{
SourceFilters.Add(SyntaxNode.OrderByClause.CreateEvaluator <TSource>());
}
if (SyntaxNode.HavingClause != null)
{
ResultFilters.Add(list => list.Where(SyntaxNode.HavingClause.CreateEvaluator <TResult>()));
}
if (SyntaxNode.Columns.Distinct)
{
ResultFilters.Add(list => list.Distinct(CreateDistinctComparer()));
}
}
public ResultFilterClause AddResultFilter(Type resultType, ResultFilterType resultFilterType, int selectorArgument)
{
var filter = new ResultFilterClause(resultType, resultFilterType, selectorArgument);
ResultFilters.Add(filter);
return(filter);
}
/// <summary>
/// Adds the result filter.
/// </summary>
/// <param name="filter">The filter.</param>
protected virtual void AddResultFilter(IResultFilter filter)
{
if (!ResultFilters.Contains(filter))
{
ResultFilters.Add(filter);
}
}
private void AddFilter(Filter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
var instance = filter.Instance;
if (instance is IAuthenticationFilter authentication)
{
AuthenticationFilters.Add(new FilterInfo <IAuthenticationFilter>
{
Filter = authentication,
Scope = filter.Scope,
Order = filter.Order
});
}
if (instance is IAuthorizationFilter authorization)
{
AuthorizationFilters.Add(new FilterInfo <IAuthorizationFilter>
{
Filter = authorization,
Scope = filter.Scope,
Order = filter.Order
});
}
if (instance is IActionFilter action)
{
ActionFilters.Add(new FilterInfo <IActionFilter>
{
Filter = action,
Scope = filter.Scope,
Order = filter.Order
});
}
if (instance is IResultFilter result)
{
ResultFilters.Add(new FilterInfo <IResultFilter>
{
Filter = result,
Scope = filter.Scope,
Order = filter.Order
});
}
if (instance is IExceptionFilter exception)
{
ExceptionFilters.Add(new FilterInfo <IExceptionFilter>
{
Filter = exception,
Scope = filter.Scope,
Order = filter.Order
});
}
}
public ResultFilterClause ResetResultFilters(Type resultType, ResultFilterType resultFilterType, int selectorArgument)
{
ResultFilters.Clear();
var resultFilterClause = new ResultFilterClause(resultType, resultFilterType, selectorArgument);
ResultFilters.Add(resultFilterClause);
return(resultFilterClause);
}
public ResultFilterClause AddTakeResultFilter(Type resultType, int takeCount)
{
var filter = new ResultFilterClause(resultType, ResultFilterType.Take, 0)
{
TakeCount = takeCount
};
ResultFilters.Add(filter);
return(filter);
}
public ResultFilterClause AddSkipResultFilter(Type resultType, int skipCount)
{
var filter = new ResultFilterClause(resultType, ResultFilterType.Skip, 0)
{
SkipCount = skipCount
};
ResultFilters.Add(filter);
return(filter);
}
protected override void OnCompile()
{
if (SyntaxNode.FromClause.Join == null)
{
throw new SqlException("The query does not contain a JOIN expression\n" + Sql);
}
_joinFunction = SyntaxNode.FromClause.Join.CreateJoinFunction <TSource, TInner>();
if (SyntaxNode.GroupByClause != null)
{
_resultSelector = SyntaxNode.GroupByClause.CreateGroupBySelector <JoinResultSelector <TSource, TInner>, TResult>(SyntaxNode.Columns.Aggregates);
}
else
{
_resultSelector = SyntaxNode.Columns.CreateSelector <JoinResultSelector <TSource, TInner>, TResult>();
}
if (SyntaxNode.WhereClause != null)
{
_joinFilters.Add(list => list.Where(SyntaxNode.WhereClause.CreateEvaluator <JoinResultSelector <TSource, TInner> >()));
}
if (SyntaxNode.OrderByClause != null)
{
_joinFilters.Add(SyntaxNode.OrderByClause.CreateEvaluator <JoinResultSelector <TSource, TInner> >());
}
if (SyntaxNode.HavingClause != null)
{
ResultFilters.Add(list => list.Where(SyntaxNode.HavingClause.CreateEvaluator <TResult>()));
}
if (SyntaxNode.Columns.Distinct)
{
ResultFilters.Add(list => list.Distinct(CreateDistinctComparer()));
}
}
