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 void OnNavigatedTo(NavigationContext navigationContext)
{
if (ResultFilters.All(i => i.IsChecked == false))
{
ResultFilters[0].IsChecked = true;
}
ForceGraphToRedisgn();
}
public IEnumerable <TResult> Evaluate(IEnumerable <TSource> source)
{
Debug.Assert(source != null);
Debug.Assert(Select != null);
var result = Select(SourceFilters.Evaluate(source));
return(ResultFilters.Evaluate(result));
}
/// <summary>
/// Called when the user clicks on the button to see the decoding results.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripButtonResults_Click(object sender, EventArgs e)
{
if (this.postProcess == null)
{
return;
}
(new DecodeResultsForm(this.Handle, this.postProcess, this.filePath, this.phoneInfo,
ResultFilters.GetActiveFilters())).Show();
}
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);
}
public IEnumerable <TResult> Evaluate(IEnumerable <TSource> source, IEnumerable <TInner> inner)
{
Debug.Assert(source != null);
Debug.Assert(inner != null);
var join = _joinFunction(source, inner); // the joined data
var filtered = _joinFilters.Evaluate(join); // joined data filtered and ordered
var result = _resultSelector(filtered); // the results (trasnformed)
return(ResultFilters.Evaluate(result)); // the results filtered and ordered
}
public Type GetSequenceResultType()
{
return(ResultFilters.Where(x =>
{
switch (x.ResultFilterType)
{
case ResultFilterType.Distinct:
case ResultFilterType.SkipTake:
case ResultFilterType.Skip:
case ResultFilterType.Take:
case ResultFilterType.Sequence:
return true;
default:
return false;
}
}).Select(x => x.ResultType).FirstOrDefault());
}
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()));
}
}
