public FilterContext(DataFilter owner, Resultset source, Object filterPredicate, QueryContext queryContext, Object[] parameters)
: base(owner, source, queryContext, parameters)
{
_source = source;
_compiledBody = new FunctionLink();
List<ColumnBinding> bindings = new List<ColumnBinding>();
ExpressionTransformer transformer = new ExpressionTransformer(bindings);
foreach (RowType.TypeInfo ti in source.RowType.Fields)
foreach (RowType.TypeInfo nested_ti in ti.NestedType.Fields)
if (!nested_ti.IsHidden)
{
ColumnBinding b = new ColumnBinding();
b.typecode = Type.GetTypeCode(nested_ti.DataType);
b.rnum = ti.Ordinal;
b.TableName = ti.Name;
b.Name = nested_ti.Name;
b.fieldType = nested_ti;
b.natural = nested_ti.IsNatural;
b.container = nested_ti.IsContainer;
b.caseSensitive = nested_ti.IsCaseSensitive;
b.data = new SymbolLink(nested_ti.DataType);
bindings.Add(b);
if (nested_ti.IsContainer)
transformer.NeedTransform = true;
}
LispExecutive.Enter(_resolver = new DataResolver(new Binder(bindings)));
if (transformer.NeedTransform)
_filterPredicate = transformer.Process(filterPredicate);
else
_filterPredicate = filterPredicate;
}
public IEnumerable<DalUser> GetByPredicate(Expression<Func<DalUser, bool>> f)
{
var transpormer = new ExpressionTransformer<DalUser, User>(Expression.Parameter(typeof(User), f.Parameters[0].Name));
var expression = Expression.Lambda<Func<User, bool>>(transpormer.Visit(f.Body), transpormer.NewParamExpr);
return context.Set<User>().Where(expression).Select(ormuser => new DalUser()
{
Id = ormuser.Id,
Login = ormuser.Login,
E_mail = ormuser.E_mail,
Password = ormuser.Password,
Role_Id = ormuser.Role_Id,
RegistryDate = ormuser.RegistryDate,
Products = ormuser.Products.Select(product => new DalProduct()
{
Id = product.Id,
Auction_Cost = product.Auction_Cost,
AuctionStart = product.AuctionStart,
AuctionEnd = product.AuctionEnd,
Seller_Id = product.Seller_Id,
Buyer_Id = product.Buyer_Id,
Description = product.Description
}).ToList(),
Products1 = ormuser.Products.Select(product => new DalProduct()
{
Id = product.Id,
Auction_Cost = product.Auction_Cost,
AuctionStart = product.AuctionStart,
AuctionEnd = product.AuctionEnd,
Seller_Id = product.Seller_Id,
Buyer_Id = product.Buyer_Id,
Description = product.Description
}).ToList()
});
}
public IEnumerable <AlbumEntity> GetByPredicate(Expression <Func <AlbumEntity, bool> > f)
{
var dalAlbums = albumRepository
.GetByPredicate(ExpressionTransformer <AlbumEntity, DalAlbum> .Tranform(f));
return(dalAlbums.Select(album => album.ToBll()));
}
public void GetOperationElements_InvalidOperationString_ThrowsIncorrectOperationStringException()
{
var expressionTransformer = new ExpressionTransformer();
TestDelegate t = () => expressionTransformer.GetOperationElements("2!2");
Assert.Throws <IncorrectOperationStringException>(t);
}
public void SortElementsInOnpOrder_validOperationElements_ElementsInONPQueue(string expression, IEnumerable <string> expectedValues)
{
var algorithm = new OnpAlgorithm();
var expressionTransformer = new ExpressionTransformer();
var result = algorithm.SortElementsInOnpOrder(expressionTransformer.GetOperationElements(expression));
Assert.AreEqual(expectedValues, result.Select(r => r.Value));
}
/// <summary>
/// Registers the transformation to apply.
/// </summary>
/// <param name="transformation">A method that transforms an <see cref="Expression"/>.</param>
public void RegisterInterceptor(ExpressionTransformer transformation)
{
if (this.transformation != null)
{
throw new InvalidOperationException();
}
this.transformation = transformation;
}
public static Expression <Func <T1, U> > ConvertExpressionType <T1, U>(Expression <Func <T, U> > filter)
{
if (filter == null)
{
return(null);
}
var newExpression = ExpressionTransformer <T, T1> .Tranform(filter);
return(newExpression);
}
public IEnumerable<DalRole> GetByPredicate(Expression<Func<DalRole, bool>> f)
{
var transpormer = new ExpressionTransformer<DalRole, Role>(Expression.Parameter(typeof(Role), f.Parameters[0].Name));
var expression = Expression.Lambda<Func<Role, bool>>(transpormer.Visit(f.Body), transpormer.NewParamExpr);
return context.Set<Role>().Where(expression).Select(ormrole => new DalRole()
{
Id = ormrole.Id,
Name = ormrole.Name
});
}
/// <summary>
/// Creates a query that can transformation the <see cref="Expression"/>
/// wen run.
/// </summary>
/// <typeparam name="T">The entity type.</typeparam>
/// <param name="source">The source query.</param>
/// <param name="transformation">The transformation to apply.</param>
/// <returns>The new intercepting query.</returns>
public static IQueryable <T> CreateInterceptedQueryable <T>(
this IQueryable <T> source,
ExpressionTransformer transformation)
{
var provider = ServiceHost.GetService <IQueryInterceptingProvider <T> >(source);
var interceptingHost = ServiceHost.GetService <IQueryHost <T, IQueryInterceptingProvider <T> > >(
source.Expression, provider);
provider.RegisterInterceptor(transformation);
return(interceptingHost);
}
public override Expression <Func <TCandidate, bool> > GetSatisfiedExpression <TCandidate>()
{
Type candidateType = typeof(TCandidate);
if (candidateType == typeof(Agreement))
{
Expression <Func <Agreement, bool> > sourceExpression = GetAgreementExpression();
return(ExpressionTransformer.Transform <Agreement, TCandidate>(sourceExpression));
}
return(base.GetSatisfiedExpression <TCandidate>());
}
public void GetOperationElements_ValidOperationString_ElementsInQueue()
{
var expressionTransformer = new ExpressionTransformer();
var expectation = new OperationElementsHelper
{
{ OperationElementType.Number, "3" },
{ OperationElementType.Operator, "+" },
{ OperationElementType.Number, "2" }
}.Cast <OperationElement>();
var result = expressionTransformer.GetOperationElements("3+2");
Assert.AreEqual(expectation.Select(r => r.ToTestValue()), result.Select(r => r.ToTestValue()));
}
/// <summary>
/// Registers the transformation to apply.
/// </summary>
/// <param name="transformation">A method that transforms an <see cref="Expression"/>.</param>
/// <exception cref="ArgumentNullException">Thrown when transformation is null.</exception>
/// <exception cref="InvalidOperationException">Thrown when interceptor already registered.</exception>
public void RegisterInterceptor(ExpressionTransformer transformation)
{
Ensure.NotNull(() => transformation);
if (this.transformation != null)
{
throw ExceptionHelper.InterceptorAlreadyRegistered.AsInvalidOperationException();
}
while (interceptors.Count > 0)
{
var child = interceptors.Pop();
child.RegisterInterceptor(transformation);
}
this.transformation = transformation;
}
public IEnumerable<DalProduct> GetByPredicate(Expression<Func<DalProduct, bool>> f)
{
var transpormer = new ExpressionTransformer<DalProduct, Product>(Expression.Parameter(typeof(Product), f.Parameters[0].Name));
var expression = Expression.Lambda<Func<Product, bool>>(transpormer.Visit(f.Body), transpormer.NewParamExpr);
return context.Set<Product>().Where(expression).Select(ormproduct => new DalProduct()
{
Id = ormproduct.Id,
Auction_Cost = ormproduct.Auction_Cost,
AuctionStart = ormproduct.AuctionStart,
AuctionEnd = ormproduct.AuctionEnd,
Seller_Id = ormproduct.Seller_Id,
Buyer_Id = ormproduct.Buyer_Id,
Description = ormproduct.Description
});
}
public override Resultset Get(QueryContext queryContext, object[] parameters)
{
// Prepare bindings
Resultset source = ChildNodes[0].Get(queryContext, parameters);
List<ColumnBinding> bindings = new List<ColumnBinding>();
ExpressionTransformer transformer = new ExpressionTransformer(bindings);
foreach (RowType.TypeInfo ti in source.RowType.Fields)
foreach (RowType.TypeInfo nested_ti in ti.NestedType.Fields)
if (!nested_ti.IsHidden && nested_ti.IsNatural)
{
ColumnBinding b = new ColumnBinding();
b.typecode = Type.GetTypeCode(nested_ti.DataType);
b.rnum = ti.Ordinal;
b.TableName = ti.Name;
b.Name = nested_ti.Name;
b.fieldType = nested_ti;
b.natural = nested_ti.IsNatural;
b.container = nested_ti.IsContainer;
b.caseSensitive = nested_ti.IsCaseSensitive;
b.data = new SymbolLink(nested_ti.DataType);
bindings.Add(b);
if (nested_ti.IsContainer)
transformer.NeedTransform = true;
}
foreach (RowType.TypeInfo ti in source.RowType.Fields)
foreach (RowType.TypeInfo nested_ti in ti.NestedType.Fields)
if (!nested_ti.IsHidden && !nested_ti.IsNatural)
{
ColumnBinding b = new ColumnBinding();
b.typecode = Type.GetTypeCode(nested_ti.DataType);
b.rnum = ti.Ordinal;
b.TableName = ti.Name;
b.Name = nested_ti.Name;
b.fieldType = nested_ti;
b.natural = nested_ti.IsNatural;
b.container = nested_ti.IsContainer;
b.caseSensitive = nested_ti.IsCaseSensitive;
b.data = new SymbolLink(nested_ti.DataType);
bindings.Add(b);
if (nested_ti.IsContainer)
transformer.NeedTransform = true;
}
// Expand columns.
// On this step we transform select table.* and select * to select field1,...
List<Column> columns = new List<Column>();
if (_targets == null) // Select fields from all selected tables
{
foreach (ColumnBinding b in bindings)
columns.Add(new Column(ATOM.Create(null, new string[] { b.TableName, b.Name }, false)));
}
else
foreach (Column col in _targets)
{
if (Lisp.IsFunctor(col.Expr, Table)) // Select fields from specified table
{
bool found = false;
String name = (String)Lisp.Second(col.Expr);
var tableBindings =
from b in bindings
where b.TableName == name
select b;
foreach (ColumnBinding b in tableBindings)
{
columns.Add(new Column(ATOM.Create(null, new string[] { b.TableName, b.Name }, false)));
found = true;
}
if (!found)
throw new ESQLException(Properties.Resources.InvalidIdentifier, name);
}
else // Select expression specified
if (transformer.NeedTransform)
{
Column c = new Column();
c.Alias = col.Alias;
c.Expr = transformer.Process(col.Expr);
columns.Add(c);
}
else
columns.Add(col);
}
// Create demand context
FunctionLink[] compiledBody = new FunctionLink[columns.Count];
SelectorResolver resolver = new SelectorResolver(new Binder(bindings));
SelectorContext context = new SelectorContext(this, _distinct, columns.ToArray(),
resolver, source, queryContext, parameters, compiledBody);
// Create columns type info and generate unique column names by field name and alias
RowType.TypeInfo[] fields = new RowType.TypeInfo[columns.Count];
List<String> fieldNames = new List<string>();
int p = 1;
for (int k = 0; k < fields.Length; k++)
{
String name;
RowType.TypeInfo fieldType = null;
object expr = columns[k].Expr;
compiledBody[k] = new FunctionLink();
Type resType = context.LispExecutive.Compile(null, expr, compiledBody[k]);
if (Lisp.IsAtom(expr))
{
ColumnBinding b = resolver.GetBinding(expr);
if (b != null)
fieldType = b.fieldType;
}
else if (Lisp.IsNode(expr) && expr is String)
{
fieldType = new RowType.TypeInfo(null, typeof(String),
TypeConverter.GetValueSize(expr));
}
else if (Lisp.IsFunctor(expr, ID.ParamRef))
{
object value = parameters[(int)Lisp.Arg1(expr)];
fieldType = new RowType.TypeInfo(null, value.GetType(),
TypeConverter.GetValueSize(value));
}
else if (Lisp.IsFunctor(expr, ID.ToString))
{
if (Lisp.Length(expr) == 3)
fieldType = new RowType.TypeInfo(null, typeof(String), (int)Lisp.Arg2(expr));
else
fieldType = new RowType.TypeInfo(null, typeof(String), 0);
}
else if (Lisp.IsFunctor(expr, ID.ToInt16))
fieldType = new RowType.TypeInfo(null, typeof(Int16), 0);
else if (Lisp.IsFunctor(expr, ID.ToInt32))
fieldType = new RowType.TypeInfo(null, typeof(Int32), 0);
else if (Lisp.IsFunctor(expr, ID.ToInt64))
fieldType = new RowType.TypeInfo(null, typeof(Int64), 0);
else if (Lisp.IsFunctor(expr, ID.ToSingle))
fieldType = new RowType.TypeInfo(null, typeof(Single), 0);
else if (Lisp.IsFunctor(expr, ID.ToDouble))
fieldType = new RowType.TypeInfo(null, typeof(Double), 0);
else if (Lisp.IsFunctor(expr, ID.ToDecimal))
fieldType = new RowType.TypeInfo(null, typeof(Decimal), 0);
else if (Lisp.IsFunctor(expr, ID.ToDateTime))
fieldType = new RowType.TypeInfo(null, typeof(DateTime), 0);
else
fieldType = new RowType.TypeInfo(null, resType, 0);
if (!String.IsNullOrEmpty(columns[k].Alias))
name = columns[k].Alias;
else
if (fieldType.Name == null)
name = String.Format("Expr{0}", p++);
else
name = fieldType.Name;
fields[k] = new RowType.TypeInfo(k,
Util.CreateUniqueName(fieldNames, name), fieldType);
}
ScanDynatableAccessors(ChildNodes[0], resolver);
return new Resultset(new RowType(fields), context);
}
public IEnumerable<ProductEntity> GetByPredicate(Expression<Func<ProductEntity, bool>> p)
{
var transpormer = new ExpressionTransformer<ProductEntity, DalProduct>(Expression.Parameter(typeof(DalProduct), p.Parameters[0].Name));
var expression = Expression.Lambda<Func<DalProduct, bool>>(transpormer.Visit(p.Body), transpormer.NewParamExpr);
return productRepository.GetByPredicate(expression).Select(product => product.ToBllProduct());
}
public IEnumerable<RoleEntity> GetByPredicate(Expression<Func<RoleEntity, bool>> p)
{
var transpormer = new ExpressionTransformer<RoleEntity, DalRole>(Expression.Parameter(typeof(DalRole), p.Parameters[0].Name));
var expression = Expression.Lambda<Func<DalRole, bool>>(transpormer.Visit(p.Body), transpormer.NewParamExpr);
return roleRepository.GetByPredicate(expression).Select(role => role.ToBllRole());
}
public void Initialize()
{
this.transformer = new ExpressionTransformer();
}
public Calculator(ExpressionTransformer expressionTransformer, IOnpAlgorithm onpAlgorithm)
{
this.expressionTransformer = expressionTransformer;
this.onpAlgorithm = onpAlgorithm;
}
public IEnumerable<UserEntity> GetByPredicate(Expression<Func<UserEntity, bool>> f)
{
var transpormer = new ExpressionTransformer<UserEntity, DalUser>(Expression.Parameter(typeof(DalUser), f.Parameters[0].Name));
var expression = Expression.Lambda<Func<DalUser, bool>>(transpormer.Visit(f.Body), transpormer.NewParamExpr);
return userRepository.GetByPredicate(expression).Select(user => user.ToBllUser());
}