private OutputProperties InitOutputProperties(IQueryable <T> data)
{
var arg = Expression.Parameter(typeof(T), "x");
var selectArgs = Expression.Parameter(typeof(IGrouping <,>).MakeGenericType(outputFeature.DataType, typeof(T)), "x");
var selectCtor = Expression.New(typeof(GroupInfo));
//int Count<TSource>(this IEnumerable<TSource> source);
var countMethod = typeof(Enumerable).GetMethods().First(x => x.Name == "Count").MakeGenericMethod(typeof(T));
var selectMemberInit = Expression.MemberInit(selectCtor,
Expression.Bind(typeof(GroupInfo).GetProperty("Output"), Expression.Convert(Expression.Property(selectArgs, "Key"), typeof(object))),
Expression.Bind(typeof(GroupInfo).GetProperty("Count"), Expression.Call(countMethod, selectArgs))
);
var selectLambdaExpression = Expression.Lambda(selectMemberInit, selectArgs);
var groupedData = IQueryableHelper.GroupBy(data, outputFeature.Selector, typeof(T), outputFeature.DataType);
var groups = (IQueryableHelper.Select(groupedData, selectLambdaExpression, typeof(IGrouping <,>).MakeGenericType(outputFeature.DataType, typeof(T)),
typeof(GroupInfo)) as IQueryable <GroupInfo>).ToArray();
return(new DecisionTreeOutputProperties()
{
DataCount = groups.Sum(x => x.Count),
OutputDistribution = groups.ToDictionary(x => x.Output, x => x.Count),
});
}
public void GetQueryPredicateThrowsInvalidOperationExceptionWhenMultiplePredicateChained()
{
// Arrange and Act
IQueryable <int> query = _queryable.Where(p => p == 3)
.Where(p => p == 18);
// Assert
Assert.Throws <InvalidOperationException>(
() => IQueryableHelper.GetQueryPredicate(query)
);
}
public void GetQueryPredicateReturnsPredicate()
{
// Arrange
Expression <Func <int, bool> > predicate = p => p == 3;
// Act
IQueryable <int> query = _queryable.Where(predicate);
// Assert
Assert.Same(predicate, IQueryableHelper.GetQueryPredicate(query));
}
public static int Delete <T>(this IQueryable <T> queryable)
where T : class
{
// Resolve service
var serviceFactory = new ServiceFactory <T>(queryable);
ICommandService <T> commandService = serviceFactory.CreateCommandService();
// Execute Query
var query = new DeleteStatement <T>(IQueryableHelper.GetQueryPredicate(queryable));
return(commandService.Delete(query));
}
public static int Update <T>(this UpdateStatementBuilder <T> updateBuilder) where T : class
{
IQueryable <T> queryable = updateBuilder.Queryable;
// Resolve Service
var serviceFactory = new ServiceFactory <T>(queryable);
var commandService = serviceFactory.CreateCommandService();
// Create & Execute Query
var query = new UpdateStatement <T>(
updateBuilder.Assignements,
IQueryableHelper.GetQueryPredicate(queryable)
);
return(commandService.Update(query));
}
private IQueryable <InputOutputPair> BranchContiniousData(Feature feature, IQueryable <T> data)
{
var orderedData = IQueryableHelper.OrderBy(data, feature.Selector, typeof(T), feature.DataType);
var arg = Expression.Parameter(typeof(T), "x");
var ctor = Expression.New(typeof(InputOutputPair));
var inputExpression = ExpressionHelper.ReplaceLambdaParameter(feature.Selector as LambdaExpression, arg);
var outputExpression = ExpressionHelper.ReplaceLambdaParameter(outputFeature.Selector as LambdaExpression, arg);
var selectMemberInit = Expression.MemberInit(ctor,
Expression.Bind(typeof(InputOutputPair).GetProperty("Input"), Expression.Convert(inputExpression, typeof(object))),
Expression.Bind(typeof(InputOutputPair).GetProperty("Output"), Expression.Convert(outputExpression, typeof(object)))
);
var selectLambdaExpression = Expression.Lambda(selectMemberInit, arg);
var orderedInputOutput = IQueryableHelper.Select(orderedData, selectLambdaExpression, typeof(T), typeof(InputOutputPair)) as IQueryable <InputOutputPair>;
return(orderedInputOutput);
}
private GroupInfo[] GroupFeatureWithOutput(Feature feature, IQueryable <T> data)
{
var arg = Expression.Parameter(typeof(T), "x");
var groupByType = typeof(GroupBy <,>).MakeGenericType(feature.DataType, outputFeature.DataType);
var ctor = Expression.New(groupByType);
var inputExp = new ReplaceExpressionVisitor((feature.Selector as LambdaExpression).Parameters[0], arg)
.Visit((feature.Selector as LambdaExpression).Body);
var outputExp = new ReplaceExpressionVisitor((outputFeature.Selector as LambdaExpression).Parameters[0], arg)
.Visit((outputFeature.Selector as LambdaExpression).Body);
var bindExpInput = Expression.Bind(groupByType.GetProperty("Input"), inputExp);//TODO: FIX THIS
var bindExpOutput = Expression.Bind(groupByType.GetProperty("Output"), outputExp);
var groupByExpression = Expression.MemberInit(ctor, new MemberBinding[] { bindExpInput, bindExpOutput });
var lambdaExpression = Expression.Lambda(groupByExpression, arg);
var groups = IQueryableHelper.GroupBy(data, lambdaExpression, typeof(T), groupByType);
var selectArgs = Expression.Parameter(typeof(IGrouping <,>).MakeGenericType(groupByType, typeof(T)), "x");
var selectCtor = Expression.New(typeof(GroupInfo));
//int Count<TSource>(this IEnumerable<TSource> source);
var countMethod = typeof(Enumerable).GetMethods().First(x => x.Name == "Count").MakeGenericMethod(typeof(T));
var selectMemberInit = Expression.MemberInit(selectCtor,
Expression.Bind(typeof(GroupInfo).GetProperty("Input"), Expression.Convert(Expression.Property(Expression.Property(selectArgs, "Key"), "Input"), typeof(object))),
Expression.Bind(typeof(GroupInfo).GetProperty("Output"), Expression.Convert(Expression.Property(Expression.Property(selectArgs, "Key"), "Output"), typeof(object))),
Expression.Bind(typeof(GroupInfo).GetProperty("Count"), Expression.Call(countMethod, selectArgs))
);
var selectLambdaExpression = Expression.Lambda(selectMemberInit, selectArgs);
var selectedGroups = IQueryableHelper.Select(groups, selectLambdaExpression, typeof(IGrouping <,>)
.MakeGenericType(groupByType, typeof(T)), typeof(GroupInfo)) as IQueryable <GroupInfo>;
return(selectedGroups.ToArray());
//var groups = this.GetType().GetMethod("GenericGroup")
// .MakeGenericMethod(feature.DataType, OutputFeature.DataType)
// .Invoke(this, new object[] { data, groupByExpression, arg }) as GroupInfo[];
}
public bool Delete(List <int> entityIDs)
{
var module = LogUtilities.GetModuleFromType(typeof(T));
var param = Expression.Parameter(typeof(T));
var property = IQueryableHelper.GetMemberExpr(param, "ID");
var val = Expression.Constant(entityIDs, typeof(List <int>));
var contains = typeof(List <int>).GetMethod("Contains", new[] { typeof(int) });
//method.Invoke(entityIDs, new object[] { })
var expr = Expression.Call(val, contains, property);
LambdaExpression predicate = Expression.Lambda(expr, param);;
var query = (IQueryable <T>) typeof(Queryable).GetMethods().Single(method => method.Name == "Where" &&
method.IsGenericMethodDefinition &&
method.GetParameters()[1].ParameterType.GetGenericArguments()[0].GenericTypeArguments[1] == typeof(bool))
.MakeGenericMethod(typeof(T)).Invoke(null, new object[] { AsQueryable(), predicate });
if (query.Count() != entityIDs.Count())
{
return(false);
}
var entities = query.ToList();
foreach (var entity in entities)
{
var id = (int)typeof(T).GetProperty("ID").GetValue(entity);
string data = LogUtilities.SerializeEntity(entity, context);
Log logEntry = new Log(id, module, Activity.Deleted, user.ID, user.Name, data);
log.Add(logEntry);
set.Remove(entity);
}
return(true);
}
public void GetQueryPredicateReturnsNullWhenNotFiltering()
{
IQueryable <int> query = _queryable;
Assert.Null(IQueryableHelper.GetQueryPredicate(query));
}
public void GetQueryPredicateThrowsArgumentNullExceptionWhenQuerayableIsNull()
{
Assert.Throws <ArgumentNullException>(
() => IQueryableHelper.GetQueryPredicate <int>(null)
);
}
public ServiceFactory(IQueryable <TEntity> queryable)
{
DbContext dbContext = IQueryableHelper.GetDbContext(queryable);
_sqlServiceFactory = CreateSqlServiceFactory(dbContext);
}
