/// <summary>Resolve enumerable parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List <ParameterExpression> ResolveParameterEnumerable(ExpressionScope scope, IDictionary <string, Type> parameterTypes)
{
var parameters = new List <ParameterExpression>();
var parameterEnumerable = scope.CreateParameter(typeof(IEnumerable));
parameters.Add(parameterEnumerable);
var dictParameter = scope.CreateVariable(typeof(Dictionary <string, object>));
var methodConvert = typeof(EvalCompiler).GetMethod("ResolveToParameterDictionary", BindingFlags.NonPublic | BindingFlags.Static);
var expressionConvert = Expression.Call(methodConvert, new Expression[] { parameterEnumerable });
var expressionAssign = Expression.Assign(dictParameter, expressionConvert);
scope.Expressions.Add(expressionAssign);
foreach (var parameter in parameterTypes)
{
scope.CreateLazyVariable(parameter.Key, new Lazy <Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
Expression innerExpression = Expression.Property(dictParameter, DictionaryItemPropertyInfo, Expression.Constant(parameter.Key));
innerExpression = innerExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
Expression.Assign(innerParameter, innerExpression);
scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
return(innerParameter);
}));
}
return(parameters);
}
/// <summary>Resolve single object parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List<ParameterExpression> ResolveParameterSingleObject(ExpressionScope scope, IDictionary<string, Type> parameterTypes)
{
var parameters = new List<ParameterExpression>();
var parameterExpression = scope.CreateParameter(typeof (object));
parameters.Add(parameterExpression);
var parameterObjectType = parameterTypes["{0}"];
var parameterObject = scope.CreateVariable(parameterObjectType, "{0}");
scope.Expressions.Add(Expression.Assign(parameterObject, Expression.Convert(parameterExpression, parameterObjectType)));
foreach (var parameter in parameterTypes)
{
scope.CreateLazyVariable(parameter.Key, new Lazy<Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
var property = parameterObjectType.GetProperty(parameter.Key);
Expression innerExpression = property != null ?
Expression.Property(parameterObject, property) :
Expression.Field(parameterObject, parameterObjectType.GetField(parameter.Key));
innerExpression = innerExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
Expression.Assign(innerParameter, innerExpression);
scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
return innerParameter;
}));
}
return parameters;
}
public IEnumerable <EvaluationResult> Evaluate(IEnumerable <string> expressions, JObject source, CultureInfo culture = null)
{
var sourcePayload = source ?? new JObject();
var sourceName = "inp";
var sources = new List <EvaluationSource>()
{
new EvaluationSource()
{
Name = sourceName, Cell = "N3", Payload = sourcePayload
}
};
var results = new List <EvaluationResult>();
var scope = new ExpressionScope(culture == null ? outputLang : Language.Create(culture), sources);
var helper = new JsonExpressionHelper();
var index = 1;
foreach (var expression in expressions)
{
var exprName = $"__A{index}";
var cell = exprName;
var tokens = helper.Parse(sourcePayload, expression);
var result = Evaluate(exprName, cell, tokens, scope, null);
result.Value = helper.TranslateResult(result.Value);
results.Add(result);
++index;
}
return(results);
}
private static ExpressionNode ParseAgainstModel(string originalExpression, string expression, SuperSimpleTemplateParserScope scope, ExpressionScope expressionScope)
{
var subModelIndex = expression.IndexOf('.');
if (subModelIndex >= 0)
{
var subModel = ParseAgainstModel(originalExpression, expression.Substring(0, subModelIndex), scope, expressionScope);
return SyntaxTreeExpression.SubModel(
subModel,
ParseAgainstModel(originalExpression, expression.Substring(subModelIndex + 1), new SuperSimpleTemplateParserScope { Block = scope.Block, ModelType = subModel.ResultType }, ExpressionScope.CurrentModelOnStack)
);
}
var propertyInfo = scope.ModelType.GetProperty(expression);
if (propertyInfo != null) return SyntaxTreeExpression.Property(scope.ModelType, expression, expressionScope);
var fieldInfo = scope.ModelType.GetField(expression);
if (fieldInfo != null) return SyntaxTreeExpression.Field(scope.ModelType, expression, expressionScope);
if (IsLateBoundAcceptingType(scope.ModelType)) return SyntaxTreeExpression.LateBound(expression, true, expressionScope);
if (expression.StartsWith("Has"))
{
var collectionExpression = ParseAgainstModel(originalExpression, expression.Substring(3), scope, expressionScope);
return SyntaxTreeExpression.HasItems(collectionExpression);
}
throw new VeilParserException(String.Format("Unable to parse model expression '{0}'", originalExpression));
}
private static ExpressionNode ParseAgainstModel(Type modelType, string expression, ExpressionScope expressionScope)
{
var dotIndex = expression.IndexOf('.');
if (dotIndex >= 0)
{
var subModel = HandlebarsExpressionParser.ParseAgainstModel(modelType, expression.Substring(0, dotIndex), expressionScope);
return SyntaxTreeExpression.SubModel(
subModel,
HandlebarsExpressionParser.ParseAgainstModel(subModel.ResultType, expression.Substring(dotIndex + 1), ExpressionScope.CurrentModelOnStack)
);
}
if (expression.EndsWith("()"))
{
var func = FindMember(modelType, expression.Substring(0, expression.Length - 2), MemberTypes.Method);
if (func != null) return SyntaxTreeExpression.Function(modelType, func.Name, expressionScope);
}
var prop = FindMember(modelType, expression, MemberTypes.Property | MemberTypes.Field);
if (prop != null)
{
switch (prop.MemberType)
{
case MemberTypes.Property: return SyntaxTreeExpression.Property(modelType, prop.Name, expressionScope);
case MemberTypes.Field: return SyntaxTreeExpression.Field(modelType, prop.Name, expressionScope);
}
}
if (IsLateBoundAcceptingType(modelType)) return SyntaxTreeExpression.LateBound(expression, false, expressionScope);
throw new VeilParserException(String.Format("Unable to parse model expression '{0}' againt model '{1}'", expression, modelType.Name));
}
/// <summary>Resolve dictionary parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List <ParameterExpression> ResolveParameterDictionary(ExpressionScope scope, IDictionary <string, Type> parameterTypes)
{
var parameters = new List <ParameterExpression>();
var parameterDictionary = scope.CreateParameter(typeof(IDictionary));
parameters.Add(parameterDictionary);
foreach (var parameter in parameterTypes)
{
scope.CreateLazyVariable(parameter.Key, new Lazy <Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
Expression innerExpression = Expression.Property(parameterDictionary, DictionaryItemPropertyInfo, Expression.Constant(parameter.Key));
innerExpression = innerExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
Expression.Assign(innerParameter, innerExpression);
scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
return(innerParameter);
}));
}
return(parameters);
}
/// <summary>Resolve enumerable parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List<ParameterExpression> ResolveParameterEnumerable(ExpressionScope scope, IDictionary<string, Type> parameterTypes)
{
var parameters = new List<ParameterExpression>();
var parameterEnumerable = scope.CreateParameter(typeof (IEnumerable));
parameters.Add(parameterEnumerable);
var dictParameter = scope.CreateVariable(typeof (Dictionary<string, object>));
var methodConvert = typeof (EvalCompiler).GetMethod("ResolveToParameterDictionary", BindingFlags.NonPublic | BindingFlags.Static);
var expressionConvert = Expression.Call(methodConvert, new Expression[] {parameterEnumerable});
var expressionAssign = Expression.Assign(dictParameter, expressionConvert);
scope.Expressions.Add(expressionAssign);
foreach (var parameter in parameterTypes)
{
scope.CreateLazyVariable(parameter.Key, new LazySingleThread<Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
Expression innerExpression = Expression.Property(dictParameter, DictionaryItemPropertyInfo, Expression.Constant(parameter.Key));
innerExpression = innerExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
Expression.Assign(innerParameter, innerExpression);
scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
return innerParameter;
}));
}
return parameters;
}
/// <summary>Resolve untyped parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List<ParameterExpression> ResolveParameterUntyped(ExpressionScope scope, IDictionary<string, Type> parameterTypes, bool forceFirstParameterProperty = false)
{
var parameters = new List<ParameterExpression>();
foreach (var parameter in parameterTypes)
{
var parameterExpression = scope.CreateParameter(typeof (object));
parameters.Add(parameterExpression);
scope.CreateLazyVariable(parameter.Key, new Lazy<Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
var innerExpression = parameterExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(parameterExpression, parameter.Value)) :
Expression.Assign(innerParameter, parameterExpression);
scope.Expressions.Insert(0, innerExpression);
return innerParameter;
}));
}
if (parameterTypes.Count == 1 || (parameterTypes.Count > 0 && forceFirstParameterProperty))
{
var keyValue = parameterTypes.First();
if (Type.GetTypeCode(keyValue.Value) == TypeCode.Object)
{
ResolzeLazyMember(scope, parameterTypes, keyValue.Key, keyValue.Value);
}
}
return parameters;
}
private static ExpressionNode ParseAgainstModel(Type modelType, string expression, ExpressionScope expressionScope, IMemberLocator memberLocator, SourceLocation location)
{
var dotIndex = expression.IndexOf('.');
if (dotIndex >= 0)
{
var subModel = ParseAgainstModel(modelType, expression.Substring(0, dotIndex), expressionScope, memberLocator, location.SetLength(dotIndex));
return SyntaxTreeExpression.SubModel(
subModel,
ParseAgainstModel(subModel.ResultType, expression.Substring(dotIndex + 1), ExpressionScope.CurrentModelOnStack, memberLocator, location.MoveIndex(dotIndex + 1)),
location
);
}
if (expression.EndsWith("()"))
{
var func = memberLocator.FindMethod(modelType, expression.Substring(0, expression.Length - 2));
if (func != null) return SyntaxTreeExpression.Function(modelType, func.Name, location, expressionScope);
}
var prop = memberLocator.FindProperty(modelType, expression);
if (prop != null)
return SyntaxTreeExpression.Property(modelType, prop.Name, location, expressionScope);
var field = memberLocator.FindField(modelType, expression);
if (field != null)
return SyntaxTreeExpression.Field(modelType, field.Name, location, expressionScope);
if (IsLateBoundAcceptingType(modelType))
return SyntaxTreeExpression.LateBound(expression, location, memberLocator, false, expressionScope);
throw new VeilParserException(
$"Unable to parse model expression '{expression}' againt model '{modelType.Name}'", location);
}
/// <summary>Resolve parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterKind">The parameter kind for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List<ParameterExpression> ResolveParameter(ExpressionScope scope, EvalCompilerParameterKind parameterKind, IDictionary<string, Type> parameterTypes)
{
if (parameterTypes == null) return null;
List<ParameterExpression> parameterExpressions;
switch (parameterKind)
{
case EvalCompilerParameterKind.Dictionary:
parameterExpressions = ResolveParameterDictionary(scope, parameterTypes);
break;
case EvalCompilerParameterKind.Enumerable:
parameterExpressions = ResolveParameterEnumerable(scope, parameterTypes);
break;
case EvalCompilerParameterKind.SingleDictionary:
parameterExpressions = ResolveParameterSingleDictionary(scope, parameterTypes);
break;
case EvalCompilerParameterKind.Typed:
parameterExpressions = ResolveParameterTyped(scope, parameterTypes);
break;
case EvalCompilerParameterKind.Untyped:
parameterExpressions = ResolveParameterUntyped(scope, parameterTypes);
break;
default:
parameterExpressions = new List<ParameterExpression>();
break;
}
return parameterExpressions;
}
/// <summary>Resolve untyped parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List <ParameterExpression> ResolveParameterUntyped(ExpressionScope scope, IDictionary <string, Type> parameterTypes)
{
var parameters = new List <ParameterExpression>();
foreach (var parameter in parameterTypes)
{
var parameterExpression = scope.CreateParameter(typeof(object));
parameters.Add(parameterExpression);
scope.CreateLazyVariable(parameter.Key, new LazySingleThread <Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
var innerExpression = parameterExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(parameterExpression, parameter.Value)) :
Expression.Assign(innerParameter, parameterExpression);
scope.Expressions.Insert(0, innerExpression);
return(innerParameter);
}));
}
if (parameterTypes.Count == 1)
{
var keyValue = parameterTypes.First();
if (Type.GetTypeCode(keyValue.Value) == TypeCode.Object)
{
ResolzeLazyMember(scope, parameterTypes, keyValue.Key, keyValue.Value);
}
}
return(parameters);
}
public override object Execute(object dataContext, ExpressionScope scope)
{
var left = Left.Execute(dataContext, scope);
var right = (Type)Right.Execute(dataContext, scope);
return(right.IsInstanceOfType(left) ? left : null);
}
public object Execute(object dataContext, ExpressionScope scope)
{
var expression = _expression.Execute(dataContext, scope);
var indexes = _indexes.Select(i => i.Execute(dataContext, scope));
return(ObjectHelper.GetIndexProperty(expression, indexes));
}
public override object Execute(object dataContext, ExpressionScope scope)
{
dynamic left = Left.Execute(dataContext, scope);
dynamic right = Right.Execute(dataContext, scope);
return(left == right);
}
/// <summary>Resolve dictionary parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List<ParameterExpression> ResolveParameterDictionary(ExpressionScope scope, IDictionary<string, Type> parameterTypes)
{
var parameters = new List<ParameterExpression>();
var parameterDictionary = scope.CreateParameter(typeof (IDictionary));
parameters.Add(parameterDictionary);
foreach (var parameter in parameterTypes)
{
scope.CreateLazyVariable(parameter.Key, new Lazy<Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
Expression innerExpression = Expression.Property(parameterDictionary, DictionaryItemPropertyInfo, Expression.Constant(parameter.Key));
innerExpression = innerExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
Expression.Assign(innerParameter, innerExpression);
scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
return innerParameter;
}));
}
return parameters;
}
/// <summary>
/// Evaluate the model itself e.g. Value types
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static SelfExpressionNode Self(Type modelType, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return(new SelfExpressionNode
{
ModelType = modelType,
Scope = scope
});
}
/// <summary>
/// Evaluate a field on the model object
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="fieldName">The name of the field</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static FieldExpressionNode Field(Type modelType, string fieldName, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return(new FieldExpressionNode
{
FieldInfo = modelType.GetField(fieldName),
Scope = scope
});
}
/// <summary>
/// Evaluate a field on the model object
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="fieldName">The name of the field</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static FieldExpressionNode Field(Type modelType, string fieldName, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new FieldExpressionNode
{
FieldInfo = modelType.GetField(fieldName),
Scope = scope
};
}
/// <summary>
/// Evaluate a function call on the model
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="functionName">The name of the function</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static FunctionCallExpressionNode Function(Type modelType, string functionName, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new FunctionCallExpressionNode
{
MethodInfo = modelType.GetMethod(functionName, new Type[0]),
Scope = scope
};
}
/// <summary>
/// Evaluate a property at runtime against an unknown model type
/// </summary>
/// <param name="itemName">The name of the proeprty that will be searched for</param>
/// <param name="isCaseSenstiive">Indcates whether the expression should be evaluated with case sensitivity</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static LateBoundExpressionNode LateBound(string itemName, bool isCaseSenstiive = true, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new LateBoundExpressionNode
{
ItemName = itemName,
Scope = scope
};
}
/// <summary>
/// Evaluate a property on the model object
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="propertyName">The name of the property</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static PropertyExpressionNode Property(Type modelType, string propertyName, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new PropertyExpressionNode
{
PropertyInfo = modelType.GetProperty(propertyName),
Scope = scope
};
}
/// <summary>
/// Evaluate the model itself e.g. Value types
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static SelfExpressionNode Self(Type modelType, SourceLocation location, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new SelfExpressionNode
{
Location = location,
ModelType = modelType,
Scope = scope
};
}
/// <summary>
/// Evaluate an expression on a sub model, can be nested to traverse any depth of sub models
/// </summary>
/// <param name="modelExpression">An expression referencing the model to traverse to</param>
/// <param name="subModelExpression">An expression to evaluate in the scope of the model that has been traversed to</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static SubModelExpressionNode SubModel(ExpressionNode modelExpression, ExpressionNode subModelExpression, SourceLocation location, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new SubModelExpressionNode
{
Location = location,
ModelExpression = modelExpression,
SubModelExpression = subModelExpression,
Scope = scope
};
}
/// <summary>
/// Evaluate a property on the model object
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="propertyName">The name of the property</param>
/// <param name="location"></param>
/// <param name="scope">The scope this expression evaluated in</param>
/// <param name="recursionLevel"></param>
public static PropertyExpressionNode Property(Type modelType, string propertyName, SourceLocation location, ExpressionScope scope = ExpressionScope.CurrentModelOnStack, int recursionLevel = 0)
{
return new PropertyExpressionNode
{
Location = location,
PropertyInfo = modelType.GetProperty(propertyName),
Scope = scope,
RecursionLevel = recursionLevel
};
}
/// <summary>
/// Evaluate a field on the model object
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="fieldName">The name of the field</param>
/// <param name="location"></param>
/// <param name="scope">The scope this expression evaluated in</param>
/// <param name="recursionLevel"></param>
public static FieldExpressionNode Field(Type modelType, string fieldName, SourceLocation location, ExpressionScope scope = ExpressionScope.CurrentModelOnStack, int recursionLevel = 0)
{
return new FieldExpressionNode
{
Location = location,
FieldInfo = modelType.GetField(fieldName),
Scope = scope,
RecursionLevel = recursionLevel
};
}
public static TResult Find <TScope, TResult>(this ExpressionScope scope, INamespace <TScope> session, linq.Expression <Func <TScope, TResult> > getItem) where TScope : INamespace
{
foreach (var current in scope.Enumerate())
{
if (current.Context.TryGetItem(session, getItem, out var value))
{
return(value);
}
}
return(default);
public object Execute(object dataContext, ExpressionScope scope)
{
var result = new DynamicWrapper();
if (_initializer != null)
{
_initializer.Initialize(result, dataContext, scope);
}
return(result);
}
public object Execute(object dataContext, ExpressionScope scope)
{
// Формирование делегата для исполнения функции
return(Expression.Lambda(Expression.Call(Expression.Constant(this),
ExecuteLambdaExpressionMethod,
Expression.Constant(dataContext),
Expression.Constant(scope),
Expression.NewArrayInit(typeof(object), _parameters)),
_parameters)
.Compile());
}
public override Expression VisitStatement(ExprParser.StatementContext context)
{
if (context.GetChild(0).GetText() == "return")
{
ExpressionScope e = new ExpressionScope();
e.Name = "return";
e.Operation = Operation.RETURN;
e.Input = Visit(context.expression());
return(e);
}
return(null);
}
public void Initialize(object instance, object dataContext, ExpressionScope scope)
{
if (instance != null && _properties != null)
{
foreach (var property in _properties)
{
var propertyName = property.Key;
var propertyValue = property.Value.Execute(dataContext, scope);
instance.SetProperty(propertyName, propertyValue);
}
}
}
public void ProjectionTest()
{
// Create Oldedb top set
SetTopOledb dbTop = new SetTopOledb("Northwind");
dbTop.ConnectionString = Northwind;
dbTop.Open();
dbTop.ImportSchema();
SetTop wsTop = new SetTop("My Mashup");
//
// Load test data
//
Set targetSet = Mapper.ImportSet(dbTop.FindSubset("Order Details"), wsTop);
targetSet.TableDefinition.Populate();
//
// Create derived dimensions
//
Set od = wsTop.FindSubset("Order Details");
// Create expression
Dim d1 = od.GetGreaterDim("Order ID");
Dim d2 = d1.GreaterSet.GetGreaterDim("Customer ID");
Dim d3 = d2.GreaterSet.GetGreaterDim("Last Name");
List <Dim> path = new List <Dim> {
d1, d2, d3
};
Expression expr = Expression.CreateProjectExpression(path, Operation.PROJECTION);
// Add derived dimension
Dim derived1 = d3.GreaterSet.CreateDefaultLesserDimension("Customer Last Name", od);
derived1.Add();
var funcExpr = ExpressionScope.CreateFunctionDeclaration("Customer Last Name", "Order Details", "String");
funcExpr.Statements[0].Input = expr; // Return statement
funcExpr.ResolveFunction(wsTop);
funcExpr.Resolve();
derived1.SelectExpression = funcExpr;
// Update
derived1.Evaluate();
Assert.AreEqual("Axen", od.GetValue("Customer Last Name", 10));
}
private Expression EvaluateScope(ExpressionScope scope)
{
switch (scope)
{
case ExpressionScope.CurrentModelOnStack: return(this.modelStack.First.Value);
case ExpressionScope.RootModel: return(this.modelStack.Last.Value);
case ExpressionScope.ModelOfParentScope: return(this.modelStack.First.Next.Value);
default:
throw new VeilCompilerException("Unknown expression scope '{0}'".FormatInvariant(scope));
}
}
public object Execute(object dataContext, ExpressionScope scope)
{
object result;
object invokeTarget = null;
object[] invokeArguments = null;
if (_invokeTarget != null)
{
invokeTarget = _invokeTarget.Execute(dataContext, scope);
}
if (_invokeArguments != null)
{
invokeArguments =
_invokeArguments.Select(i => (i != null) ? i.Execute(dataContext, scope) : null).ToArray();
}
// Вызов статического метода
if (invokeTarget is Type)
{
ReflectionExtensions.InvokeMember((Type)invokeTarget, _methodName, invokeArguments, out result,
_genericArguments);
}
// Вызов метода динамического объекта
else if (invokeTarget is IDynamicMetaObjectProvider)
{
// Получение свойства динамического объекта
var methodDelegate = ObjectHelper.GetProperty(invokeTarget, _methodName) as Delegate;
if (methodDelegate != null)
{
result = ReflectionExtensions.FastDynamicInvoke(methodDelegate, invokeArguments);
}
else
{
ReflectionExtensions.InvokeMember(invokeTarget, _methodName, invokeArguments, out result,
_genericArguments);
}
}
// Вызов метода строготипизированного обычного объекта
else
{
ReflectionExtensions.InvokeMember(invokeTarget, _methodName, invokeArguments, out result,
_genericArguments);
}
return(result);
}
public object Execute(object dataContext, ExpressionScope scope)
{
var parameters = (_parameters != null)
? _parameters.Select(i => i.Execute(dataContext, scope)).ToArray()
: null;
var result = Activator.CreateInstance(_type, parameters);
if (_initializer != null)
{
_initializer.Initialize(result, dataContext, scope);
}
return(result);
}
public object Execute(object dataContext, ExpressionScope scope)
{
var expression = _expression.Execute(dataContext, scope);
foreach (var section in _sections)
{
var label = section.Key.Execute(dataContext, scope);
if (Equals(label, expression))
{
return(section.Value.Execute(dataContext, scope));
}
}
return(null);
}
public object Execute(object dataContext, ExpressionScope scope)
{
object result;
var expression = _expression.Execute(dataContext, scope);
if (expression is Type)
{
result = ReflectionExtensions.GetMemberValue((Type)expression, _memberName);
}
else
{
result = ObjectHelper.GetProperty(expression, _memberName);
}
return(result);
}
public object Execute(object dataContext, ExpressionScope scope)
{
var expression = _expression.Execute(dataContext, scope);
if (expression == null)
{
if (_type.IsValueType)
{
expression = ReflectionExtensions.GetDefaultValue(_type);
}
}
else
{
expression = Convert.ChangeType(expression, _type);
}
return(expression);
}
//
// Function
//
public override Expression VisitFunction(ExprParser.FunctionContext context)
{
string type = GetType(context.type()); // Return type
string name = GetName(context.name()); // Function name
ExpressionScope e = new ExpressionScope();
e.Name = name;
e.Operation = Operation.FUNCTION;
e.OutputSetName = type;
// Find all parameter declarations and store them as operands of the expression
int paramCount = context.parameter().Count();
for (int i = 0; i < paramCount; i++)
{
Expression paramExpr = Visit(context.parameter(i));
if (i == 0)
{
e.Input = paramExpr;
}
else
{
e.AddOperand(paramExpr);
}
}
// Find all statements and store them in the expression
int stmtCount = context.statement().Count();
for (int i = 0; i < stmtCount; i++)
{
ExpressionScope stmtExpr = (ExpressionScope)Visit(context.statement(i));
if (stmtExpr == null)
{
continue;
}
e.AddStatement(stmtExpr);
}
return(e);
}
/// <summary>Resolve lazy member from the member type</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <param name="parameterName">The main parameter name.</param>
/// <param name="memberType">The member type.</param>
private static void ResolzeLazyMember(ExpressionScope scope, IDictionary <string, Type> parameterTypes, string parameterName, Type memberType)
{
if (Type.GetTypeCode(memberType) == TypeCode.Object)
{
var parameterProperties = memberType.GetProperties().Where(x => x.GetIndexParameters().Count() == 0).ToArray();
var parameterFields = memberType.GetFields();
var instanceMethods = memberType.GetMethods();
foreach (var propertyInfo in parameterProperties)
{
parameterTypes.Add(propertyInfo.Name, propertyInfo.PropertyType);
scope.CreateLazyVariable(propertyInfo.Name, new Lazy <Expression>(() =>
{
var innerParameter = scope.CreateVariable(propertyInfo.PropertyType, propertyInfo.Name);
var innerExpression = Expression.Assign(innerParameter, Expression.Property(scope.GetValueExpressionOrNull(parameterName), propertyInfo));
scope.Expressions.Add(innerExpression);
return(innerParameter);
}));
}
foreach (var fieldInfo in parameterFields)
{
parameterTypes.Add(fieldInfo.Name, fieldInfo.FieldType);
scope.CreateLazyVariable(fieldInfo.Name, new Lazy <Expression>(() =>
{
var innerParameter = scope.CreateVariable(fieldInfo.FieldType, fieldInfo.Name);
var innerExpression = Expression.Assign(innerParameter, Expression.Field(scope.GetValueExpressionOrNull(parameterName), fieldInfo));
scope.Expressions.Add(innerExpression);
return(innerParameter);
}));
}
foreach (var method in instanceMethods)
{
scope.InstanceMethods.Add(method, parameterName);
}
}
}
/// <summary>Resolve lazy member from the member type</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <param name="parameterName">The main parameter name.</param>
/// <param name="memberType">The member type.</param>
private static void ResolzeLazyMember(ExpressionScope scope, IDictionary<string, Type> parameterTypes, string parameterName, Type memberType)
{
if (Type.GetTypeCode(memberType) == TypeCode.Object)
{
var parameterProperties = memberType.GetProperties().Where(x => x.GetIndexParameters().Count() == 0).ToArray();
var parameterFields = memberType.GetFields();
var instanceMethods = memberType.GetMethods();
foreach (var propertyInfo in parameterProperties)
{
parameterTypes.Add(propertyInfo.Name, propertyInfo.PropertyType);
scope.CreateLazyVariable(propertyInfo.Name, new Lazy<Expression>(() =>
{
var innerParameter = scope.CreateVariable(propertyInfo.PropertyType, propertyInfo.Name);
var innerExpression = Expression.Assign(innerParameter, Expression.Property(scope.GetValueExpressionOrNull(parameterName), propertyInfo));
scope.Expressions.Add(innerExpression);
return innerParameter;
}));
}
foreach (var fieldInfo in parameterFields)
{
parameterTypes.Add(fieldInfo.Name, fieldInfo.FieldType);
scope.CreateLazyVariable(fieldInfo.Name, new Lazy<Expression>(() =>
{
var innerParameter = scope.CreateVariable(fieldInfo.FieldType, fieldInfo.Name);
var innerExpression = Expression.Assign(innerParameter, Expression.Field(scope.GetValueExpressionOrNull(parameterName), fieldInfo));
scope.Expressions.Add(innerExpression);
return innerParameter;
}));
}
foreach (var method in instanceMethods)
{
scope.InstanceMethods.Add(method, parameterName);
}
}
}
/// <summary>Resolve typed parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List<ParameterExpression> ResolveParameterTyped(ExpressionScope scope, IDictionary<string, Type> parameterTypes)
{
var parameters = new List<ParameterExpression>();
foreach (var parameter in parameterTypes)
{
parameters.Add(scope.CreateParameter(parameter.Value, parameter.Key));
}
if (parameterTypes.Count == 1)
{
var keyValue = parameterTypes.First();
if (Type.GetTypeCode(keyValue.Value) == TypeCode.Object)
{
ResolzeLazyMember(scope, parameterTypes, keyValue.Key, keyValue.Value);
}
}
return parameters;
}
/// <summary>Resolve typed parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List <ParameterExpression> ResolveParameterTyped(ExpressionScope scope, IDictionary <string, Type> parameterTypes)
{
var parameters = new List <ParameterExpression>();
foreach (var parameter in parameterTypes)
{
parameters.Add(scope.CreateParameter(parameter.Value, parameter.Key));
}
if (parameterTypes.Count == 1)
{
var keyValue = parameterTypes.First();
if (Type.GetTypeCode(keyValue.Value) == TypeCode.Object)
{
ResolzeLazyMember(scope, parameterTypes, keyValue.Key, keyValue.Value);
}
}
return(parameters);
}
private object ExecuteLambdaExpression(object dataContext, ExpressionScope scope, object[] arguments)
{
if (_body != null)
{
var lambdaScope = new ExpressionScope(scope);
// Заполнение контекста параметрами функции
if (arguments != null)
{
for (var i = 0; i < arguments.Length && i < _parameters.Count; ++i)
{
lambdaScope.DeclareVariable(_parameters[i].Name, arguments[i]);
}
}
return(_body.Execute(dataContext, lambdaScope));
}
return(null);
}
public void Initialize(object instance, object dataContext, ExpressionScope scope)
{
if (instance != null)
{
if (instance is IList)
{
var list = (IList)instance;
foreach (var item in _items)
{
var itemValue = item.Execute(dataContext, scope);
list.Add(itemValue);
}
}
else
{
var collectionType =
instance.GetType()
.GetInterfaces()
.FirstOrDefault(
i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ICollection <>));
if (collectionType != null)
{
var addMethod = collectionType.GetMethod("Add");
var elementType = collectionType.GetGenericArguments().FirstOrDefault();
if (addMethod != null && elementType != null && (elementType.IsClass || elementType.IsValueType))
{
foreach (var item in _items)
{
var itemValue = Activator.CreateInstance(elementType,
item.Execute(dataContext, scope) as object[]);
addMethod.Invoke(instance, new[] { itemValue });
}
}
}
}
}
}
/// <summary>Resolve parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterKind">The parameter kind for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List <ParameterExpression> ResolveParameter(ExpressionScope scope, EvalCompilerParameterKind parameterKind, IDictionary <string, Type> parameterTypes)
{
if (parameterTypes == null)
{
return(null);
}
List <ParameterExpression> parameterExpressions;
switch (parameterKind)
{
case EvalCompilerParameterKind.Dictionary:
parameterExpressions = ResolveParameterDictionary(scope, parameterTypes);
break;
case EvalCompilerParameterKind.Enumerable:
parameterExpressions = ResolveParameterEnumerable(scope, parameterTypes);
break;
case EvalCompilerParameterKind.SingleDictionary:
parameterExpressions = ResolveParameterSingleDictionary(scope, parameterTypes);
break;
case EvalCompilerParameterKind.Typed:
parameterExpressions = ResolveParameterTyped(scope, parameterTypes);
break;
case EvalCompilerParameterKind.Untyped:
parameterExpressions = ResolveParameterUntyped(scope, parameterTypes);
break;
default:
parameterExpressions = new List <ParameterExpression>();
break;
}
return(parameterExpressions);
}
/// <summary>Resolve single dictionary parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List <ParameterExpression> ResolveParameterSingleDictionary(ExpressionScope scope, IDictionary <string, Type> parameterTypes, bool forceFirstParameterProperty = false)
{
var parameters = new List <ParameterExpression>();
var parameterDictionary = scope.CreateParameter(typeof(IDictionary), "{0}");
parameters.Add(parameterDictionary);
foreach (var parameter in parameterTypes)
{
scope.CreateLazyVariable(parameter.Key, new Lazy <Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
Expression innerExpression = Expression.Property(parameterDictionary, DictionaryItemPropertyInfo, Expression.Constant(parameter.Key));
innerExpression = innerExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
Expression.Assign(innerParameter, innerExpression);
scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
return(innerParameter);
}));
}
if (parameterTypes.Count > 0 && forceFirstParameterProperty)
{
var keyValue = parameterTypes.First();
if (Type.GetTypeCode(keyValue.Value) == TypeCode.Object)
{
ResolzeLazyMember(scope, parameterTypes, keyValue.Key, keyValue.Value);
}
}
return(parameters);
}
/// <summary>Resolve single object parameters used for the code or expression.</summary>
/// <param name="scope">The expression scope for the code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <returns>A ParameterExpression list used in code or expression to compile.</returns>
private static List <ParameterExpression> ResolveParameterSingleObject(ExpressionScope scope, IDictionary <string, Type> parameterTypes)
{
var parameters = new List <ParameterExpression>();
var parameterExpression = scope.CreateParameter(typeof(object));
parameters.Add(parameterExpression);
var parameterObjectType = parameterTypes["{0}"];
var parameterObject = scope.CreateVariable(parameterObjectType, "{0}");
scope.Expressions.Add(Expression.Assign(parameterObject, Expression.Convert(parameterExpression, parameterObjectType)));
foreach (var parameter in parameterTypes)
{
scope.CreateLazyVariable(parameter.Key, new Lazy <Expression>(() =>
{
var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
var property = parameterObjectType.GetProperty(parameter.Key);
Expression innerExpression = property != null ?
Expression.Property(parameterObject, property) :
Expression.Field(parameterObject, parameterObjectType.GetField(parameter.Key));
innerExpression = innerExpression.Type != parameter.Value ?
Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
Expression.Assign(innerParameter, innerExpression);
scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
return(innerParameter);
}));
}
return(parameters);
}
/// <summary>
/// Evaluate a property at runtime against an unknown model type
/// </summary>
/// <param name="itemName">The name of the proeprty that will be searched for</param>
/// <param name="isCaseSenstiive">Indcates whether the expression should be evaluated with case sensitivity</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static LateBoundExpressionNode LateBound(string itemName, SourceLocation location, IMemberLocator memberLocator = null, bool isCaseSenstiive = true, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new LateBoundExpressionNode
{
Location = location,
MemberLocator = memberLocator ?? MemberLocator.Default,
ItemName = itemName,
Scope = scope
};
}
/// <summary>Compile the code or expression and return a TDelegate of type Func or Action to execute.</summary>
/// <param name="context">The eval context used to compile the code or expression.</param>
/// <param name="code">The code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <param name="resultType">Type of the compiled code or expression result.</param>
/// <returns>A TDelegate of type Func or Action that represents the compiled code or expression.</returns>
internal static EvalDelegate Compile(EvalContext context, string code, ListDictionary parameterTypes, Type resultType)
{
var cacheKey = ResolveCacheKey(context, typeof (Func<IDictionary, object>), code, parameterTypes);
EvalDelegate cachedDelegate;
if (EvalManager.CacheDelegate.TryGetValue(cacheKey, out cachedDelegate))
{
return cachedDelegate;
}
Dictionary<string, Type> parameterDict = new Dictionary<string, Type>();
foreach (DictionaryEntry parameterType in parameterTypes)
{
parameterDict.Add((string)parameterType.Key, (Type)parameterType.Value);
}
// Options
var scope = new ExpressionScope
{
AliasExtensionMethods = context.AliasExtensionMethods,
AliasNames = context.AliasNames,
AliasStaticMembers = context.AliasStaticMembers,
AliasTypes = context.AliasTypes,
BindingFlags = context.BindingFlags,
UseCaretForExponent = context.UseCaretForExponent
};
// ADD global constants
if (context.AliasGlobalConstants.Count > 0)
{
scope.Constants = new Dictionary<string, ConstantExpression>(context.AliasGlobalConstants);
}
// ADD global variables
if (context.AliasGlobalVariables.Count > 0)
{
foreach (var keyValue in context.AliasGlobalVariables)
{
#if SQLNET
scope.CreateLazyVariable(keyValue.Key, new LazySingleThread<Expression>(() =>
#else
scope.CreateLazyVariable(keyValue.Key, new Lazy<Expression>(() =>
#endif
{
var innerParameter = scope.CreateVariable(keyValue.Value.GetType(), keyValue.Key);
var innerExpression = Expression.Assign(innerParameter, Expression.Constant(keyValue.Value));
scope.Expressions.Add(innerExpression);
return innerParameter;
}));
}
}
// Resolve Parameter
var parameterExpressions = ResolveParameter(scope, parameterDict);
// CodeAnalysis
var syntaxRoot = SyntaxParser.ParseText(code);
// CodeCompiler
var expression = ExpressionParser.ParseSyntax(scope, syntaxRoot, resultType);
// Compile the expression
var compiled = Expression.Lambda<Func<IDictionary, object>>(expression, parameterExpressions).Compile();
var evalDelegate = new EvalDelegate(cacheKey, compiled);
EvalManager.CacheDelegate.TryAdd(cacheKey, evalDelegate);
return evalDelegate;
}
/// <summary>Compile the code or expression and return a TDelegate of type Func or Action to execute.</summary>
/// <typeparam name="TDelegate">Type of the delegate (Func or Action) to use to compile the code or expression.</typeparam>
/// <param name="context">The eval context used to compile the code or expression.</param>
/// <param name="code">The code or expression to compile.</param>
/// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
/// <param name="resultType">Type of the compiled code or expression result.</param>
/// <param name="parameterKind">The parameter kind for the code or expression to compile.</param>
/// <returns>A TDelegate of type Func or Action that represents the compiled code or expression.</returns>
internal static TDelegate Compile <TDelegate>(EvalContext context, string code, IDictionary <string, Type> parameterTypes, Type resultType, EvalCompilerParameterKind parameterKind)
{
var cacheKey = context.UseCache ? ResolveCacheKey(context, typeof(TDelegate), code, parameterTypes) : "";
if (context.UseCache)
{
var item = EvalManager.Cache.Get(cacheKey);
if (item != null)
{
return((TDelegate)item);
}
}
// Options
var scope = new ExpressionScope
{
AliasExtensionMethods = context.AliasExtensionMethods,
//AliasGlobalConstants = context.AliasGlobalConstants,
//AliasGlobalVariables = context.AliasGlobalVariables,
AliasNames = context.AliasNames,
AliasStaticMembers = context.AliasStaticMembers,
AliasTypes = context.AliasTypes,
BindingFlags = context.BindingFlags,
UseCaretForExponent = context.UseCaretForExponent
};
// Resolve Parameter
var parameterExpressions = ResolveParameter(scope, parameterKind, parameterTypes);
// ADD global constants
if (context.AliasGlobalConstants.Count > 0)
{
scope.Constants = new Dictionary <string, ConstantExpression>(context.AliasGlobalConstants);
}
// ADD global variables
if (context.AliasGlobalVariables.Count > 0)
{
foreach (var keyValue in context.AliasGlobalVariables)
{
scope.CreateLazyVariable(keyValue.Key, new Lazy <Expression>(() =>
{
var innerParameter = scope.CreateVariable(keyValue.Value.GetType(), keyValue.Key);
var innerExpression = Expression.Assign(innerParameter, Expression.Constant(keyValue.Value));
scope.Expressions.Add(innerExpression);
return(innerParameter);
}));
}
}
// CodeAnalysis
var syntaxRoot = SyntaxParser.ParseText(code);
// CodeCompiler
var expression = ExpressionParser.ParseSyntax(scope, syntaxRoot, resultType);
// Compile the expression
var compiled = Expression.Lambda <TDelegate>(expression, parameterExpressions).Compile();
if (context.UseCache)
{
EvalManager.Cache.AddOrGetExisting(new CacheItem(cacheKey, compiled), new CacheItemPolicy());
}
return(compiled);
}
/// <summary>
/// Evaluate the model itself e.g. Value types
/// </summary>
/// <param name="modelType">The type of the scoped model</param>
/// <param name="scope">The scope this expression evaluated in</param>
public static SelfExpressionNode Self(Type modelType, ExpressionScope scope = ExpressionScope.CurrentModelOnStack)
{
return new SelfExpressionNode
{
ModelType = modelType,
Scope = scope
};
}