protected LambdaExpression UpdateLambda(LambdaExpression lambda, Type delegateType, Expression body, IEnumerable<ParameterExpression> parameters)
{
if (body != lambda.Body || parameters != lambda.Parameters || delegateType != lambda.Type)
{
return Expression.Lambda(delegateType, body, parameters);
}
return lambda;
}
public override void VisitLambdaExpression (LambdaExpression lambdaExpression)
{
var blockStatement = lambdaExpression.Body as BlockStatement;
if (blockStatement != null)
StatementIssueCollector.Collect (this, blockStatement);
base.VisitLambdaExpression (lambdaExpression);
}
internal LightDelegateCreator(Interpreter interpreter, LambdaExpression lambda)
{
Debug.Assert(interpreter != null);
Debug.Assert(lambda != null);
Interpreter = interpreter;
_lambda = lambda;
}
public static Delegate Compile (LambdaExpression lambda, DebugInfoGenerator debugInfoGenerator)
{
#if MONO_INTERPRETER
return lambda.LightCompile ();
#else
throw new NotSupportedException ("System.Linq.Expression interpreter is missing");
#endif
}
public LocalLookupVariable(string name, TypeReference typeRef, Location startPos, Location endPos, bool isConst, bool isLoopVariable, Expression initializer, LambdaExpression parentLambdaExpression)
{
Name = name;
TypeRef = typeRef;
StartPos = startPos;
EndPos = endPos;
IsConst = isConst;
IsLoopVariable = isLoopVariable;
Initializer = initializer;
ParentLambdaExpression = parentLambdaExpression;
}
public override void ExtendDeclaration(IDeclarationModel declaration, CompilationModel model)
{
// this only applies to methods
var methodDecl = declaration as MethodDeclaration;
if (methodDecl == null || methodDecl.Container == null)
return;
if (!methodDecl.Definition.Symbol.IsExtensionMethod)
throw new CompilationException("The ScriptMixin attribute can only be applied to extension methods.", declaration);
// remove the function from the container
methodDecl.Container.RemoveMember(methodDecl);
// get the extension target info
var extTarget = methodDecl.Parameters[0];
var extType = extTarget.Definition.Type;
// rewrite first param as a local declaration to this context
var thisDecl = new LocalDeclarationStatement { VariableDeclaration = new VariableDeclaration() };
thisDecl.VariableDeclaration.Variables.Add(new VariableDeclarator
{
Definition = new LocalDefinition
{
Name = extTarget.Name,
Type = extType
},
EqualsValueExpression = new LiteralExpression { Text = "this" }
});
// add the declaration to the method body
methodDecl.Body.Statements.Insert(0, thisDecl);
// create a lambda using the method body.
var lambdaExpression = new LambdaExpression();
lambdaExpression.Body = methodDecl.Body;
for (int i = 1; i < methodDecl.Parameters.Count; i++)
lambdaExpression.Parameters.Add(methodDecl.Parameters[i]);
// create a global statement to set the prototype value
var target = extType.GetFullName() + ".prototype." + methodDecl.Definition.Name;
model.GlobalStatements.Add(new ExpressionStatement
{
Expression = new BinaryExpression
{
LeftExpression = new LiteralExpression { Text = target },
RightExpression = lambdaExpression,
Operator = "="
}
});
}
public static IType GetLambdaReturnType(RefactoringContext context, LambdaExpression lambda)
{
LambdaResolveResult rr = context.Resolve(lambda) as LambdaResolveResult;
if (rr == null)
return SpecialType.UnknownType;
if (rr.IsAsync) {
// Unpack Task<T>
if (rr.ReturnType.IsKnownType(KnownTypeCode.Task))
return context.Compilation.FindType(KnownTypeCode.Void);
else if (rr.ReturnType.IsKnownType(KnownTypeCode.TaskOfT) && rr.ReturnType.IsParameterized)
return rr.ReturnType.TypeArguments[0];
}
return rr.ReturnType;
}
public override void VisitLambdaExpression(LambdaExpression lambdaExpression)
{
foreach (var param in lambdaExpression.Parameters) {
var result = context.Resolve(param);
var local = result as LocalResolveResult;
anonymousParameters.Add(local.Variable);
}
base.VisitLambdaExpression(lambdaExpression);
foreach (var param in lambdaExpression.Parameters) {
var result = context.Resolve(param);
var local = result as LocalResolveResult;
anonymousParameters.Remove(local.Variable);
}
}
public void AddVariable(TypeReference typeRef, string name,
Location startPos, Location endPos, bool isConst,
bool isLoopVariable, Expression initializer,
LambdaExpression parentLambdaExpression)
{
if (name == null || name.Length == 0) {
return;
}
List<LocalLookupVariable> list;
if (!variables.ContainsKey(name)) {
variables[name] = list = new List<LocalLookupVariable>();
} else {
list = (List<LocalLookupVariable>)variables[name];
}
list.Add(new LocalLookupVariable(name, typeRef, startPos, endPos, isConst, isLoopVariable, initializer, parentLambdaExpression));
}
public override void VisitLambdaExpression(LambdaExpression lambdaExpression) {
AstNode oldMethod = _currentMethod;
bool oldIsInsideLoop = _isInsideLoop;
try {
_currentMethod = lambdaExpression;
_isInsideLoop = false;
foreach (var p in lambdaExpression.Parameters)
AddVariable(p, p.Name, p.ParameterModifier == ParameterModifier.Out || p.ParameterModifier == ParameterModifier.Ref);
base.VisitLambdaExpression(lambdaExpression);
}
finally {
_currentMethod = oldMethod;
_isInsideLoop = oldIsInsideLoop;
}
}
public static IType GetLambdaReturnType(RefactoringContext context, LambdaExpression lambda)
{
var parent = lambda.Parent;
while (parent is ParenthesizedExpression)
parent = parent.Parent;
ITypeDefinition delegateTypeDef;
if (parent is InvocationExpression) {
var invocation = (InvocationExpression)parent;
var argIndex = invocation.Arguments.TakeWhile (arg => !arg.Contains (lambda.StartLocation)).Count ();
var resolveResult = (CSharpInvocationResolveResult)context.Resolve (invocation);
delegateTypeDef = resolveResult.Arguments [argIndex].Type.GetDefinition ();
} else {
delegateTypeDef = context.Resolve (parent).Type.GetDefinition ();
}
if (delegateTypeDef == null)
return null;
var invokeMethod = delegateTypeDef.GetMethods (m => m.Name == "Invoke").FirstOrDefault ();
if (invokeMethod == null)
return null;
return invokeMethod.ReturnType;
}
public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
Expression node = context.GetNode<IdentifierExpression>();
if (node == null) {
var mr = context.GetNode<MemberReferenceExpression>();
if (mr == null || !mr.MemberNameToken.IsInside(context.Location))
yield break;
node = mr;
}
if (node == null)
yield break;
var rr = context.Resolve(node) as MethodGroupResolveResult;
if (rr == null || rr.IsError)
yield break;
var type = TypeGuessing.GetValidTypes(context.Resolver, node).FirstOrDefault(t => t.Kind == TypeKind.Delegate);
if (type == null)
yield break;
var invocationMethod = type.GetDelegateInvokeMethod();
if (invocationMethod == null)
yield break;
yield return new CodeAction(
context.TranslateString("Convert to lambda expression"),
script => {
var invocation = new InvocationExpression(node.Clone(), invocationMethod.Parameters.Select(p => new IdentifierExpression(context.GetNameProposal(p.Name))));
var lambda = new LambdaExpression {
Body = invocation
};
lambda.Parameters.AddRange(
invocation.Arguments
.Cast<IdentifierExpression>()
.Select(p => new ParameterDeclaration { Name = p.Identifier })
);
script.Replace(node, lambda);
},
node
);
}
public static EF_DataTypes Fetch(int page, int rowCount, System.Linq.Expressions.Expression <Func <EF_DataType, bool> > exp, params object[] values)
{
return(EF.DataPortal.Fetch <EF_DataTypes>(new PagigExpress {
Page = page, RowCount = rowCount, Lambda = LambdaExpression.Create <EF_DataType>(exp, values)
}));
}
// 创建 DELETE 命令
protected override Command ResolveDeleteCommand <T>(DbQueryableInfo_Delete <T> dbQuery, ResolveToken token)
{
ISqlBuilder builder = this.CreateSqlBuilder(token);
TypeRuntimeInfo typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo <T>();
builder.Append("DELETE FROM ");
builder.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
builder.Append(" ");
if (dbQuery.Entity != null)
{
if (typeRuntime.KeyInvokers == null || typeRuntime.KeyInvokers.Count == 0)
{
throw new XFrameworkException("Delete<T>(T value) require entity must have key column.");
}
object entity = dbQuery.Entity;
builder.AppendNewLine();
builder.Append("WHERE ");
foreach (var invoker in typeRuntime.KeyInvokers)
{
var column = invoker.Column;
var value = invoker.Invoke(entity);
var seg = this.DbValue.GetSqlValue(value, token, column);
builder.AppendMember(invoker.Member.Name);
builder.Append(" = ");
builder.Append(seg);
builder.Append(" AND ");
}
builder.Length -= 5;
}
else if (dbQuery.SelectInfo != null)
{
LambdaExpression lambda = null;
var sourceQuery = dbQuery.SourceQuery;
if (sourceQuery.DbExpressions != null && sourceQuery.DbExpressions.Count > 1)
{
switch (sourceQuery.DbExpressions[1].DbExpressionType)
{
case DbExpressionType.Join:
case DbExpressionType.GroupJoin:
case DbExpressionType.GroupRightJoin:
lambda = (LambdaExpression)sourceQuery.DbExpressions[1].Expressions[1];
break;
case DbExpressionType.Select:
case DbExpressionType.SelectMany:
lambda = (LambdaExpression)sourceQuery.DbExpressions[1].Expressions[0];
break;
}
}
if (lambda == null)
{
DbExpression dbExpression = dbQuery.SelectInfo.Select;
dbExpression = dbQuery.SelectInfo.Condtion;
if (dbExpression != null && dbExpression.Expressions != null)
{
lambda = (LambdaExpression)dbExpression.Expressions[0];
}
}
// 解析查询以确定是否需要嵌套
var parameter = Expression.Parameter(typeof(SQLiteRowId), lambda != null ? lambda.Parameters[0].Name : "x");
var expression = Expression.MakeMemberAccess(parameter, (_rowIdExpression.Body as MemberExpression).Member);
dbQuery.SelectInfo.Select = new DbExpression(DbExpressionType.Select, expression);
var cmd = (MapperCommand)this.ResolveSelectCommand <T>(dbQuery.SelectInfo, 1, false, null);
if (token != null && token.Extendsions == null)
{
token.Extendsions = new Dictionary <string, object>();
if (!token.Extendsions.ContainsKey("SQLiteDelete"))
{
token.Extendsions.Add("SQLiteDelete", null);
}
}
if ((cmd.NavMembers != null && cmd.NavMembers.Count > 0) || dbQuery.SelectInfo.Joins.Count > 0)
{
cmd = (MapperCommand)this.ResolveSelectCommand <T>(dbQuery.SelectInfo, 1, false, token);
builder.Append("WHERE ");
builder.AppendMember("RowID");
builder.Append(" IN(");
builder.AppendNewLine(cmd.CommandText);
builder.Append(')');
}
else
{
TableAliasCache aliases = this.PrepareTableAlias <T>(dbQuery.SelectInfo, token);
ExpressionVisitorBase visitor = null;
visitor = new JoinExpressionVisitor(this, aliases, dbQuery.SelectInfo.Joins);
visitor.Write(builder);
visitor = new WhereExpressionVisitor(this, null, dbQuery.SelectInfo.Condtion);
visitor.Write(builder);
}
}
builder.Append(';');
return(new Command(builder.ToString(), builder.Token != null ? builder.Token.Parameters : null, System.Data.CommandType.Text));
}
public Func <EventRecord, object> GetTransform(Type outputType)
{
Expression <Func <EventRecord, SystemEvent> > template = e => new SystemEvent
{
Header = new SystemHeader
{
ActivityId = e.ActivityId.HasValue ? e.ActivityId.Value : Guid.Empty,
Channel = 0,
Context = e.LogName,
Level = e.Level.Value,
EventId = (ushort)e.Id,
Keywords = e.Keywords.HasValue ? (ulong)e.Keywords.Value : (ulong)0,
Opcode = e.Opcode.HasValue ? (byte)e.Opcode.Value : (byte)0,
ProcessId = e.ProcessId.HasValue ? (uint)e.ProcessId.Value : 0,
ProviderId = e.ProviderId.HasValue ? e.ProviderId.Value : Guid.Empty,
RelatedActivityId = e.RelatedActivityId.HasValue ? e.RelatedActivityId.Value : Guid.Empty,
Task = e.Task.HasValue ? (ushort)e.Task.Value : (ushort)0,
ThreadId = e.ThreadId.HasValue ? (uint)e.ThreadId.Value : (uint)0,
Timestamp = e.TimeCreated.HasValue ? e.TimeCreated.Value : DateTime.MinValue,
Version = e.Version.HasValue ? e.Version.Value : (byte)0
}
};
if (outputType == typeof(SystemEvent))
{
return(template.Compile());
}
LambdaExpression ex = template;
var mi = (MemberInitExpression)ex.Body;
var bindings = new List <MemberBinding>(mi.Bindings);
ParameterExpression record = ex.Parameters[0];
PropertyInfo[] properties = outputType.GetProperties();
int index = 0;
foreach (PropertyInfo p in properties)
{
var attribute = p.GetAttribute <EventFieldAttribute>();
if (attribute == null)
{
continue;
}
// the following is to handle value maps, that were emitted as enumerations
Type t;
if (p.PropertyType.IsEnum)
{
t = p.PropertyType;
}
else
{
t = GetSimpleType(attribute.OriginalType);
}
MemberAssignment b = Expression.Bind(p, Expression.Convert(
Expression.Property(
Expression.Call(
Expression.Property(record,
typeof(EventRecord).GetProperty(
"Properties")),
typeof(IList <EventProperty>).GetMethod("get_Item"),
Expression.Constant(index++)),
typeof(EventProperty).GetProperty("Value")),
t));
bindings.Add(b);
}
NewExpression n = Expression.New(outputType);
MemberInitExpression m = Expression.MemberInit(n, bindings.ToArray());
UnaryExpression cast = Expression.Convert(m, typeof(object));
Expression <Func <EventRecord, object> > exp = Expression.Lambda <Func <EventRecord, object> >(cast, ex.Parameters);
return(exp.Compile());
}
public ActivationExpression(LambdaExpression expression, Func <Tuple, TResult> compiledExpression, IArgumentMap argumentMap)
{
_expression = expression;
_compiledExpression = compiledExpression;
_argumentMap = argumentMap;
}
/// <summary>
/// Create istance of MvbBindable on this Binder
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TK"></typeparam>
/// <param name="property"></param>
/// <param name="newIstance"></param>
public void SetMvbBindableInstance <T, TK>(Expression <Func <T, TK> > property, Func <TK> newIstance) where T : MvbBase where TK : IMvbBindable
{
var bindableInstance = newIstance.Invoke();
var propertyTree = new Queue <string>();
#region PROPERTY TREE
LambdaExpression lambda = property;
MemberExpression memberExpression;
if (lambda.Body is UnaryExpression)
{
var unaryExpression = (UnaryExpression)lambda.Body;
memberExpression = (MemberExpression)unaryExpression.Operand;
}
else
{
memberExpression = (MemberExpression)lambda.Body;
}
//Check composite ex binder.MyObject.MyProperty => MyObject.MyProperty
var propName = ((PropertyInfo)memberExpression.Member).Name;
var body = lambda.Body.ToString();
var bodySplitted = body.Split('.');
var isComposite = bodySplitted.Length > 2;
if (!isComposite)
{
propertyTree.Enqueue(propName);
}
else
{
var splittedlist = bodySplitted.ToList();
splittedlist.RemoveAt(0);
foreach (var s in splittedlist)
{
propertyTree.Enqueue(s);
}
}
var theDeepProperty = string.Join(".", propertyTree);
#endregion
var vmtype = this._vmInstance.GetType();
if (vmtype != typeof(T))
{
throw new Exception($"Wrong type instance. instance must be of type: {vmtype}");
}
PropertyInfo propertyOnObj = null;
object lastParent = this._vmInstance;
while (propertyTree.Any())
{
var propertyName = propertyTree.Dequeue();
var parentTypeInfo = lastParent.GetType().GetTypeInfo();
propertyOnObj = parentTypeInfo.DeclaredProperties.Single(s => s.Name == propertyName);
if (propertyTree.Count > 0)
{
lastParent = propertyOnObj.GetValue(lastParent);
}
}
if (propertyOnObj == null)
{
throw new Exception("Deep property not found!");
}
var oldObj = propertyOnObj.GetValue(lastParent, null) as IMvbBindable;
// Clear and Active PropertyChanged
//Clear ols handler
oldObj?.ClearHandler();
//set new object
propertyOnObj.SetValue(lastParent, bindableInstance);
//Active PropertyChanged if not null
if (bindableInstance == null)
{
return;
}
bindableInstance.PropertyChanged += (sender, args) =>
{
var registerName = $"{theDeepProperty}.{args.PropertyName}";
this.Run(registerName);
};
//Activate sub collections
this.ActiveListenerOnObservableCollection(bindableInstance, propertyOnObj.Name);
}
public static HR_EmpPositionBill Fetch(System.Linq.Expressions.Expression <Func <HR_EmpPositionBill, bool> > exp, params object[] values)
{
LambdaExpression lambda = LambdaExpression.Create <HR_EmpPositionBill>(exp, values);
return(EF.DataPortal.Fetch <HR_EmpPositionBill>(lambda));
}
public static PM_AllotModSubs Fetch(System.Linq.Expressions.Expression <Func <PM_AllotModSub, bool> > exp, params object[] values)
{
LambdaExpression lambda = LambdaExpression.Create <PM_AllotModSub>(exp, values);
return(EF.DataPortal.Fetch <PM_AllotModSubs>(lambda));
}
protected override ShapedQueryExpression?TranslateThenBy(
ShapedQueryExpression source,
LambdaExpression keySelector,
bool ascending)
=> null;
protected override ShapedQueryExpression?TranslateAverage(
ShapedQueryExpression source,
LambdaExpression selector,
Type resultType)
=> null;
protected override ShapedQueryExpression?TranslateLastOrDefault(
ShapedQueryExpression source,
LambdaExpression predicate,
Type returnType,
bool returnDefault)
=> null;
protected override ShapedQueryExpression?TranslateSelectMany(
ShapedQueryExpression source,
LambdaExpression selector)
=> null;
protected override ShapedQueryExpression?TranslateGroupBy(
ShapedQueryExpression source,
LambdaExpression keySelector,
LambdaExpression elementSelector,
LambdaExpression resultSelector)
=> null;
public void SetSelect(LambdaExpression selectExpression)
{
Select = selectExpression;
}
public static LambdaExpression CombineCollectionPropertySelectorWithPredicate(LambdaExpression propertySelector, LambdaExpression propertyPredicate, CollectionBehavior collectionBehavior = CollectionBehavior.All)
{
// x => ids.Contains(x.Id)
// x => Collection.Any(ids.Contains(x.Id))
var memberExpression = propertySelector.Body as MemberExpression;
var propertyInfo = ((PropertyInfo)memberExpression.Member);
var containingType = propertyInfo.DeclaringType;
if (memberExpression == null)
{
throw new ArgumentException("propertySelector");
}
var rootPredicateType = typeof(Func <,>).GetGenericTypeDefinition().MakeGenericType(containingType, typeof(bool));
MethodInfo filterMethodInfo;
if (collectionBehavior == CollectionBehavior.All)
{
filterMethodInfo = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public).Single(mi => mi.Name == "All" && mi.GetParameters().Count() == 2).MakeGenericMethod(propertyInfo.PropertyType.ToSingleType());
}
else
{
filterMethodInfo = typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public).Single(mi => mi.Name == "Any" && mi.GetParameters().Count() == 2).MakeGenericMethod(propertyInfo.PropertyType.ToSingleType());
}
var collectionCall = Expression.Call(null, filterMethodInfo, memberExpression, propertyPredicate);
return(Expression.Lambda(rootPredicateType, collectionCall, propertySelector.Parameters));
}
protected virtual void CreateArguments (ResolveContext ec, Parameter parameter, ref Arguments args)
{
args = new Arguments (2);
LambdaExpression selector = new LambdaExpression (loc);
block.SetParameter (parameter);
selector.Block = block;
selector.Block.AddStatement (new ContextualReturn (expr));
args.Add (new Argument (selector));
}
/// <summary>
/// Creates a <see cref="BinaryExpression"/> that represents raising an expression to a power and assigning the result back to the expression.
/// </summary>
/// <param name="left">An <see cref="Expression"/> to set the <see cref="P:BinaryExpression.Left"/> property equal to.</param>
/// <param name="right">An <see cref="Expression"/> to set the <see cref="P:BinaryExpression.Right"/> property equal to.</param>
/// <param name="method">A <see cref="MethodInfo"/> to set the <see cref="P:BinaryExpression.Method"/> property equal to.</param>
/// <param name="conversion">A <see cref="LambdaExpression"/> to set the <see cref="P:BinaryExpression.Conversion"/> property equal to.</param>
/// <returns>A <see cref="BinaryExpression"/> that has the <see cref="P:Expression.NodeType"/> property equal to <see cref="F:ExpressionType.PowerAssign"/>
/// and the <see cref="P:BinaryExpression.Left"/>, <see cref="P:BinaryExpression.Right"/>, <see cref="P:BinaryExpression.Method"/>,
/// and <see cref="P:BinaryExpression.Conversion"/> properties set to the specified values.
/// </returns>
public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion) {
RequiresCanRead(left, "left");
RequiresCanWrite(left, "left");
RequiresCanRead(right, "right");
if (method == null) {
Type mathType = typeof(System.Math);
method = mathType.GetMethod("Pow", BindingFlags.Static | BindingFlags.Public);
if (method == null) {
throw Error.BinaryOperatorNotDefined(ExpressionType.PowerAssign, left.Type, right.Type);
}
}
return GetMethodBasedAssignOperator(ExpressionType.PowerAssign, left, right, method, conversion, true);
}
protected override void CreateArguments (ResolveContext ec, Parameter parameter, ref Arguments args)
{
args = new Arguments (4);
if (IdentifierType != null)
expr = CreateCastExpression (expr);
args.Add (new Argument (expr));
outer_selector.SetParameter (parameter.Clone ());
var lambda = new LambdaExpression (outer_selector.StartLocation);
lambda.Block = outer_selector;
args.Add (new Argument (lambda));
inner_selector.SetParameter (new ImplicitLambdaParameter (identifier.Name, identifier.Location));
lambda = new LambdaExpression (inner_selector.StartLocation);
lambda.Block = inner_selector;
args.Add (new Argument (lambda));
base.CreateArguments (ec, parameter, ref args);
}
internal CoalesceConversionBinaryExpression(Expression left, Expression right, LambdaExpression conversion)
: base(left, right) {
_conversion = conversion;
}
public static PM_AllotModSubs Fetch(int page, int rowCount, System.Linq.Expressions.Expression <Func <PM_AllotModSub, bool> > exp, params object[] values)
{
return(EF.DataPortal.Fetch <PM_AllotModSubs>(new PagigExpress {
Page = page, RowCount = rowCount, Lambda = LambdaExpression.Create <PM_AllotModSub>(exp, values)
}));
}
private static BinaryExpression GetUserDefinedAssignOperatorOrThrow(ExpressionType binaryType, string name, Expression left, Expression right, LambdaExpression conversion, bool liftToNull) {
BinaryExpression b = GetUserDefinedBinaryOperatorOrThrow(binaryType, name, left, right, liftToNull);
if (conversion == null) {
// return type must be assignable back to the left type
if (!TypeUtils.AreReferenceAssignable(left.Type, b.Type)) {
throw Error.UserDefinedOpMustHaveValidReturnType(binaryType, b.Method.Name);
}
} else {
// add the conversion to the result
ValidateOpAssignConversionLambda(conversion, b.Left, b.Method, b.NodeType);
b = new OpAssignMethodConversionBinaryExpression(b.NodeType, b.Left, b.Right, b.Left.Type, b.Method, conversion);
}
return b;
}
public override void VisitLambdaExpression(LambdaExpression lambdaExpression)
{
new LambdaBlock(this, lambdaExpression).Emit();
}
// LambdaExpression
public override bool Walk(LambdaExpression node) { return false; }
public override void VisitLambdaExpression(LambdaExpression lambdaExpression)
{
// ignore lambdas
}
// LambdaExpression
public virtual bool Walk(LambdaExpression node) { return true; }
// 创建 UPDATE 命令
protected override Command ResolveUpdateCommand <T>(DbQueryableInfo_Update <T> dbQuery, ResolveToken token)
{
ISqlBuilder builder = this.CreateSqlBuilder(token);
var typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo <T>();
builder.Append("UPDATE ");
builder.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
builder.Append(" SET");
builder.AppendNewLine();
if (dbQuery.Entity != null)
{
object entity = dbQuery.Entity;
ISqlBuilder whereBuilder = this.CreateSqlBuilder(token);
bool useKey = false;
int length = 0;
foreach (var invoker in typeRuntime.Invokers)
{
var column = invoker.Column;
if (column != null && column.IsIdentity)
{
goto gotoLabel; // fix issue# 自增列同时又是主键
}
if (column != null && column.NoMapped)
{
continue;
}
if (invoker.Column != null && column.DbType is SqlDbType && (SqlDbType)column.DbType == SqlDbType.Timestamp)
{
continue; // 行版本号
}
if (invoker.ForeignKey != null)
{
continue;
}
if (invoker.Member.MemberType == System.Reflection.MemberTypes.Method)
{
continue;
}
builder.AppendMember(invoker.Member.Name);
builder.Append(" = ");
gotoLabel:
var value = invoker.Invoke(entity);
var seg = this.DbValue.GetSqlValueWidthDefault(value, token, column);
if (column == null || !column.IsIdentity)
{
builder.Append(seg);
length = builder.Length;
builder.Append(',');
builder.AppendNewLine();
}
if (column != null && column.IsKey)
{
useKey = true;
whereBuilder.AppendMember(invoker.Member.Name);
whereBuilder.Append(" = ");
whereBuilder.Append(seg);
whereBuilder.Append(" AND ");
}
}
if (!useKey)
{
throw new XFrameworkException("Update<T>(T value) require entity must have key column.");
}
builder.Length = length;
whereBuilder.Length -= 5;
builder.AppendNewLine();
builder.Append("WHERE ");
builder.Append(whereBuilder);
}
else if (dbQuery.Expression != null)
{
// SELECT 表达式
LambdaExpression lambda = dbQuery.Expression as LambdaExpression;
var body = lambda.Body;
Expression expression = null;
if (body.NodeType == ExpressionType.MemberInit)
{
var memberInit = body as MemberInitExpression;
var bindings = new List <MemberBinding>(memberInit.Bindings);
foreach (var invoker in typeRuntime.KeyInvokers)
{
var member = Expression.MakeMemberAccess(lambda.Parameters[0], invoker.Member);
var binding = Expression.Bind(invoker.Member, member);
if (!bindings.Any(x => x.Member == invoker.Member))
{
bindings.Add(binding);
}
}
expression = Expression.MemberInit(memberInit.NewExpression, bindings);
}
else if (body.NodeType == ExpressionType.New)
{
var newExpression = body as NewExpression;
var bindings = new List <MemberBinding>();
for (int i = 0; i < newExpression.Members.Count; i++)
{
var invoker = typeRuntime.GetInvoker(newExpression.Members[i].Name);
var binding = Expression.Bind(invoker.Member, newExpression.Arguments[i].Type != invoker.DataType
? Expression.Convert(newExpression.Arguments[i], invoker.DataType)
: newExpression.Arguments[i]);
bindings.Add(binding);
}
foreach (var invoker in typeRuntime.KeyInvokers)
{
var member = Expression.MakeMemberAccess(lambda.Parameters[0], invoker.Member);
var binding = Expression.Bind(invoker.Member, member);
if (!bindings.Any(x => x.Member == invoker.Member))
{
bindings.Add(binding);
}
}
var newExpression2 = Expression.New(typeRuntime.ConstructInvoker.Constructor);
expression = Expression.MemberInit(newExpression2, bindings);
}
// 解析查询以确定是否需要嵌套
dbQuery.SelectInfo.Select = new DbExpression(DbExpressionType.Select, expression);
var cmd = (MapperCommand)this.ResolveSelectCommand <T>(dbQuery.SelectInfo, 1, false, null);
if ((cmd.NavMembers != null && cmd.NavMembers.Count > 0) || dbQuery.SelectInfo.Joins.Count > 0)
{
if (typeRuntime.KeyInvokers == null || typeRuntime.KeyInvokers.Count == 0)
{
throw new XFrameworkException("Update<T>(Expression<Func<T, object>> updateExpression) require entity must have key column.");
}
// SET 字段
var visitor = new SQLiteUpdateExpressionVisitor <T>(this, null, dbQuery, null);
visitor.ParseCommand = this.ResolveSelectCommand;
visitor.Write(builder);
// WHERE部分
builder.AppendNewLine();
builder.Append("WHERE EXISTS");
visitor.VisitArgument(dbQuery.SelectInfo.Select.Expressions[0], true);
}
else
{
// 直接 SQL 的 UPDATE 语法
TableAliasCache aliases = this.PrepareTableAlias <T>(dbQuery.SelectInfo, token);
var visitor = new SQLiteUpdateExpressionVisitor <T>(this, aliases, dbQuery, null);
visitor.ParseCommand = this.ResolveSelectCommand;
visitor.Write(builder);
var visitor2 = new WhereExpressionVisitor(this, null, dbQuery.SelectInfo.Condtion);
visitor2.Write(builder);
}
}
builder.Append(';');
return(new Command(builder.ToString(), builder.Token != null ? builder.Token.Parameters : null, System.Data.CommandType.Text));
}
public virtual void VisitLambdaExpression (LambdaExpression lambdaExpression)
{
VisitChildren (lambdaExpression);
}
/// <summary>
/// Adds mapping attribute to a member, specified using lambda expression.
/// </summary>
/// <param name="func">Target member, specified using lambda expression.</param>
/// <param name="attribute">Mapping attribute to add to specified member.</param>
/// <returns>Returns current fluent entity mapping builder.</returns>
public EntityMappingBuilder <T> HasAttribute(LambdaExpression func, Attribute attribute)
{
_builder.HasAttribute(func, attribute);
return(this);
}
bool LambdaNeedsParenthesis(LambdaExpression lambdaExpression)
{
if (lambdaExpression.Parameters.Count != 1) {
return true;
}
var p = lambdaExpression.Parameters.Single();
return !(p.Type.IsNull && p.ParameterModifier == ParameterModifier.None);
}
protected override ShapedQueryExpression?TranslateCount(
ShapedQueryExpression source,
LambdaExpression predicate)
=> null;
public static EF_DataTypes Fetch(System.Linq.Expressions.Expression <Func <EF_DataType, bool> > exp, params object[] values)
{
LambdaExpression lambda = LambdaExpression.Create <EF_DataType>(exp, values);
return(EF.DataPortal.Fetch <EF_DataTypes>(lambda));
}
internal static Expression Create(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression conversion) {
if (nodeType == ExpressionType.Assign) {
Debug.Assert(method == null && TypeUtils.AreEquivalent(type, left.Type));
return new AssignBinaryExpression(left, right);
}
if (conversion != null) {
Debug.Assert(method == null && TypeUtils.AreEquivalent(type, right.Type) && nodeType == ExpressionType.Coalesce);
return new CoalesceConversionBinaryExpression(left, right, conversion);
}
if (method != null) {
return new MethodBinaryExpression(nodeType, left, right, type, method);
}
if (type == typeof(bool)) {
return new LogicalBinaryExpression(nodeType, left, right);
}
return new SimpleBinaryExpression(nodeType, left, right, type);
}
public static WhereExpression ResolveWhere(LambdaExpression whereExpression, string prefix = null)
{
var where = new WhereExpression(whereExpression, prefix, ProviderOption);
return(where);
}
internal OpAssignMethodConversionBinaryExpression(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression conversion)
: base(nodeType, left, right, type, method) {
_conversion = conversion;
}
internal override Expression VisitLambda(LambdaExpression lambda)
{
throw new NotSupportedException(SR.ALinqLambdaNotSupported);
}
public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method, LambdaExpression conversion) {
switch (binaryType) {
case ExpressionType.Add:
return Add(left, right, method);
case ExpressionType.AddChecked:
return AddChecked(left, right, method);
case ExpressionType.Subtract:
return Subtract(left, right, method);
case ExpressionType.SubtractChecked:
return SubtractChecked(left, right, method);
case ExpressionType.Multiply:
return Multiply(left, right, method);
case ExpressionType.MultiplyChecked:
return MultiplyChecked(left, right, method);
case ExpressionType.Divide:
return Divide(left, right, method);
case ExpressionType.Modulo:
return Modulo(left, right, method);
case ExpressionType.Power:
return Power(left, right, method);
case ExpressionType.And:
return And(left, right, method);
case ExpressionType.AndAlso:
return AndAlso(left, right, method);
case ExpressionType.Or:
return Or(left, right, method);
case ExpressionType.OrElse:
return OrElse(left, right, method);
case ExpressionType.LessThan:
return LessThan(left, right, liftToNull, method);
case ExpressionType.LessThanOrEqual:
return LessThanOrEqual(left, right, liftToNull, method);
case ExpressionType.GreaterThan:
return GreaterThan(left, right, liftToNull, method);
case ExpressionType.GreaterThanOrEqual:
return GreaterThanOrEqual(left, right, liftToNull, method);
case ExpressionType.Equal:
return Equal(left, right, liftToNull, method);
case ExpressionType.NotEqual:
return NotEqual(left, right, liftToNull, method);
case ExpressionType.ExclusiveOr:
return ExclusiveOr(left, right, method);
case ExpressionType.Coalesce:
return Coalesce(left, right, conversion);
case ExpressionType.ArrayIndex:
return ArrayIndex(left, right);
case ExpressionType.RightShift:
return RightShift(left, right, method);
case ExpressionType.LeftShift:
return LeftShift(left, right, method);
case ExpressionType.Assign:
return Assign(left, right);
case ExpressionType.AddAssign:
return AddAssign(left, right, method, conversion);
case ExpressionType.AndAssign:
return AndAssign(left, right, method, conversion);
case ExpressionType.DivideAssign:
return DivideAssign(left, right, method, conversion);
case ExpressionType.ExclusiveOrAssign:
return ExclusiveOrAssign(left, right, method, conversion);
case ExpressionType.LeftShiftAssign:
return LeftShiftAssign(left, right, method, conversion);
case ExpressionType.ModuloAssign:
return ModuloAssign(left, right, method, conversion);
case ExpressionType.MultiplyAssign:
return MultiplyAssign(left, right, method, conversion);
case ExpressionType.OrAssign:
return OrAssign(left, right, method, conversion);
case ExpressionType.PowerAssign:
return PowerAssign(left, right, method, conversion);
case ExpressionType.RightShiftAssign:
return RightShiftAssign(left, right, method, conversion);
case ExpressionType.SubtractAssign:
return SubtractAssign(left, right, method, conversion);
case ExpressionType.AddAssignChecked:
return AddAssignChecked(left, right, method, conversion);
case ExpressionType.SubtractAssignChecked:
return SubtractAssignChecked(left, right, method, conversion);
case ExpressionType.MultiplyAssignChecked:
return MultiplyAssignChecked(left, right, method, conversion);
default:
throw Error.UnhandledBinary(binaryType);
}
}
public static FI_PerFreeTaxItems Fetch(int page, int rowCount, System.Linq.Expressions.Expression <Func <FI_PerFreeTaxItem, bool> > exp, params object[] values)
{
return(EF.DataPortal.Fetch <FI_PerFreeTaxItems>(new PagigExpress {
Page = page, RowCount = rowCount, Lambda = LambdaExpression.Create <FI_PerFreeTaxItem>(exp, values)
}));
}
public override void PostWalk(LambdaExpression node) { }
public static FI_PerFreeTaxItems Fetch(System.Linq.Expressions.Expression <Func <FI_PerFreeTaxItem, bool> > exp, params object[] values)
{
LambdaExpression lambda = LambdaExpression.Create <FI_PerFreeTaxItem>(exp, values);
return(EF.DataPortal.Fetch <FI_PerFreeTaxItems>(lambda));
}
public virtual void PostWalk(LambdaExpression node) { }
private static LambdaExpression BindOrderByClause(FilterBinder binder, OrderByClause orderBy, Type elementType)
{
LambdaExpression orderByLambda = binder.BindExpression(orderBy.Expression, orderBy.RangeVariable, elementType);
return(orderByLambda);
}
public void VisitLambdaExpression(LambdaExpression lambdaExpression)
{
StartNode(lambdaExpression);
if (lambdaExpression.IsAsync) {
WriteKeyword(LambdaExpression.AsyncModifierRole);
Space();
}
if (LambdaNeedsParenthesis(lambdaExpression)) {
WriteCommaSeparatedListInParenthesis(lambdaExpression.Parameters, policy.SpaceWithinMethodDeclarationParentheses);
} else {
lambdaExpression.Parameters.Single().AcceptVisitor(this);
}
Space();
WriteToken(LambdaExpression.ArrowRole);
Space();
lambdaExpression.Body.AcceptVisitor(this);
EndNode(lambdaExpression);
}
protected override Expression VisitLambdaExpression(LambdaExpression expression)
{
return(expression);
}
static LambdaExpression BuildLambda(string variableName, Expression expression)
{
var lambda = new LambdaExpression();
lambda.Parameters.Add(new ParameterDeclaration() {
Name = variableName
});
lambda.Body = expression.Clone();
return lambda;
}
public override void VisitLambdaExpression(LambdaExpression lambdaExpression)
{
VisitNewDeclarationSpace(lambdaExpression);
}
protected override void CreateArguments (ResolveContext ec, Parameter parameter, ref Arguments args)
{
base.CreateArguments (ec, parameter, ref args);
if (element_selector != null) {
LambdaExpression lambda = new LambdaExpression (element_selector.Location);
element_block.SetParameter (parameter.Clone ());
lambda.Block = element_block;
lambda.Block.AddStatement (new ContextualReturn (element_selector));
args.Add (new Argument (lambda));
}
}
public bool IsAssumptionWrong(LambdaExpression assumption)
{
return(_failedAssumptions.Contains(assumption));
}
protected override void CreateArguments (ResolveContext ec, Parameter parameter, ref Arguments args)
{
if (args == null) {
if (IdentifierType != null)
expr = CreateCastExpression (expr);
base.CreateArguments (ec, parameter, ref args);
}
Expression result_selector_expr;
QueryBlock result_block;
var target = GetIntoVariable ();
var target_param = new ImplicitLambdaParameter (target.Name, target.Location);
//
// When select follows use it as a result selector
//
if (next is Select) {
result_selector_expr = next.Expr;
result_block = next.block;
result_block.SetParameters (parameter, target_param);
next = next.next;
} else {
result_selector_expr = CreateRangeVariableType (ec, parameter, target, new SimpleName (target.Name, target.Location));
result_block = new QueryBlock (ec.Compiler, block.Parent, block.StartLocation);
result_block.SetParameters (parameter, target_param);
}
LambdaExpression result_selector = new LambdaExpression (Location);
result_selector.Block = result_block;
result_selector.Block.AddStatement (new ContextualReturn (result_selector_expr));
args.Add (new Argument (result_selector));
}
public static HR_EmpPositionBills Fetch(int page, int rowCount, System.Linq.Expressions.Expression <Func <HR_EmpPositionBill, bool> > exp, params object[] values)
{
return(EF.DataPortal.Fetch <HR_EmpPositionBills>(new PagigExpress {
Page = page, RowCount = rowCount, Lambda = LambdaExpression.Create <HR_EmpPositionBill>(exp, values)
}));
}
