protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var returnType = methodCall.Method.ReturnType; var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); if (sequence.SqlQuery != buildInfo.SqlQuery) { if (sequence is JoinBuilder.GroupJoinSubQueryContext) { var ctx = new CountContext(buildInfo.Parent, sequence, returnType) { SqlQuery = ((JoinBuilder.GroupJoinSubQueryContext)sequence).GetCounter(methodCall) }; ctx.Sql = ctx.SqlQuery; ctx.FieldIndex = ctx.SqlQuery.Select.Add(SqlFunction.CreateCount(returnType, ctx.SqlQuery), "cnt"); return(ctx); } if (sequence is GroupByBuilder.GroupByContext) { return(new CountContext(buildInfo.Parent, sequence, returnType) { Sql = SqlFunction.CreateCount(returnType, sequence.SqlQuery), FieldIndex = -1 }); } } if (sequence.SqlQuery.Select.IsDistinct || sequence.SqlQuery.Select.TakeValue != null || sequence.SqlQuery.Select.SkipValue != null || !sequence.SqlQuery.GroupBy.IsEmpty) { sequence.ConvertToIndex(null, 0, ConvertFlags.Key); sequence = new SubQueryContext(sequence); } if (sequence.SqlQuery.OrderBy.Items.Count > 0) { if (sequence.SqlQuery.Select.TakeValue == null && sequence.SqlQuery.Select.SkipValue == null) { sequence.SqlQuery.OrderBy.Items.Clear(); } else { sequence = new SubQueryContext(sequence); } } var context = new CountContext(buildInfo.Parent, sequence, returnType); context.Sql = context.SqlQuery; context.FieldIndex = context.SqlQuery.Select.Add(SqlFunction.CreateCount(returnType, context.SqlQuery), "cnt"); return(context); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence1 = new SubQueryContext(builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]))); var sequence2 = new SubQueryContext(builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SqlQuery()))); var union = new SqlQuery.Union(sequence2.SqlQuery, methodCall.Method.Name == "Concat"); sequence1.SqlQuery.Unions.Add(union); return(new UnionContext(sequence1, sequence2, methodCall)); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); var extract = (LambdaExpression)methodCall.Arguments[1].Unwrap(); var update = methodCall.Arguments[2].Unwrap(); if (sequence.SqlQuery.Insert.Into == null) { sequence.SqlQuery.Insert.Into = (SqlTable)sequence.SqlQuery.From.Tables[0].Source; sequence.SqlQuery.From.Tables.Clear(); } if (update.NodeType == ExpressionType.Lambda) { UpdateBuilder.ParseSet( builder, buildInfo, extract, (LambdaExpression)update, sequence, sequence.SqlQuery.Insert.Into, sequence.SqlQuery.Insert.Items); } else { UpdateBuilder.ParseSet( builder, buildInfo, extract, update, sequence, sequence.SqlQuery.Insert.Items); } return(sequence); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); var query = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SqlQuery())); var except = query.SqlQuery; sequence = new SubQueryContext(sequence); var sql = sequence.SqlQuery; except.ParentSql = sql; if (methodCall.Method.Name == "Except") { sql.Where.Not.Exists(except); } else { sql.Where.Exists(except); } var keys1 = sequence.ConvertToSql(null, 0, ConvertFlags.Key); var keys2 = query.ConvertToSql(null, 0, ConvertFlags.Key); if (keys1.Length != keys2.Length) { throw new InvalidOperationException(); } for (var i = 0; i < keys1.Length; i++) { except.Where .Expr(keys1[i].Sql) .Equal .Expr(keys2[i].Sql); } return(sequence); }
public override IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo) { throw new NotImplementedException(); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); var isSubQuery = sequence.SqlQuery.Select.IsDistinct; if (isSubQuery) { sequence = new SubQueryContext(sequence); } switch (methodCall.Arguments.Count) { case 1: // static int Insert<T> (this IValueInsertable<T> source) // static int Insert<TSource,TTarget>(this ISelectInsertable<TSource,TTarget> source) { foreach (var item in sequence.SqlQuery.Insert.Items) { sequence.SqlQuery.Select.Expr(item.Expression); } break; } case 2: // static int Insert<T>(this Table<T> target, Expression<Func<T>> setter) { UpdateBuilder.BuildSetter( builder, buildInfo, (LambdaExpression)methodCall.Arguments[1].Unwrap(), sequence, sequence.SqlQuery.Insert.Items, sequence); sequence.SqlQuery.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable; sequence.SqlQuery.From.Tables.Clear(); break; } case 3: // static int Insert<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target, Expression<Func<TSource,TTarget>> setter) { var into = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SqlQuery())); UpdateBuilder.BuildSetter( builder, buildInfo, (LambdaExpression)methodCall.Arguments[2].Unwrap(), into, sequence.SqlQuery.Insert.Items, sequence); sequence.SqlQuery.Select.Columns.Clear(); foreach (var item in sequence.SqlQuery.Insert.Items) { sequence.SqlQuery.Select.Columns.Add(new SqlQuery.Column(sequence.SqlQuery, item.Expression)); } sequence.SqlQuery.Insert.Into = ((TableBuilder.TableContext)into).SqlTable; break; } } var insert = sequence.SqlQuery.Insert; var q = insert.Into.Fields.Values.Cast <ISqlExpression>().Except(insert.Items.Select(e => e.Column)) .OfType <SqlField>() .Where(f => f.IsIdentity); foreach (var field in q) { var expr = builder.SqlProvider.GetIdentityExpression(insert.Into, field, false); if (expr != null) { insert.Items.Insert(0, new SqlQuery.SetExpression(field, expr)); if (methodCall.Arguments.Count == 3) { sequence.SqlQuery.Select.Columns.Insert(0, new SqlQuery.Column(sequence.SqlQuery, insert.Items[0].Expression)); } } } sequence.SqlQuery.QueryType = QueryType.Insert; sequence.SqlQuery.Insert.WithIdentity = methodCall.Method.Name == "InsertWithIdentity"; return(new InsertContext(buildInfo.Parent, sequence, sequence.SqlQuery.Insert.WithIdentity)); }
public override IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo) { if (expression == null && buildInfo != null) { if (buildInfo.Parent is SelectManyBuilder.SelectManyContext) { var sm = (SelectManyBuilder.SelectManyContext)buildInfo.Parent; var ctype = typeof(ContextHelper <>).MakeGenericType(_key.Lambda.Parameters[0].Type); var helper = (IContextHelper)Activator.CreateInstance(ctype); var expr = helper.GetContext( Sequence.Expression, _key.Lambda.Parameters[0], Expression.PropertyOrField(sm.Lambda.Parameters[0], "Key"), _key.Lambda.Body); return(Builder.BuildSequence(new BuildInfo(buildInfo, expr))); } //if (buildInfo.Parent == this) { var ctype = typeof(ContextHelper <>).MakeGenericType(_key.Lambda.Parameters[0].Type); var helper = (IContextHelper)Activator.CreateInstance(ctype); var expr = helper.GetContext( _sequenceExpr, _key.Lambda.Parameters[0], Expression.PropertyOrField(buildInfo.Expression, "Key"), _key.Lambda.Body); var ctx = Builder.BuildSequence(new BuildInfo(buildInfo, expr)); ctx.SqlQuery.Properties.Add(Tuple.Create("from_group_by", SqlQuery)); return(ctx); } //return this; } if (level != 0) { var levelExpression = expression.GetLevelExpression(level); if (levelExpression.NodeType == ExpressionType.MemberAccess) { var ma = (MemberExpression)levelExpression; if (ma.Member.Name == "Key" && ma.Member.DeclaringType == _groupingType) { return(levelExpression == expression? _key.GetContext(null, 0, buildInfo) : _key.GetContext(expression, level + 1, buildInfo)); } } } throw new NotImplementedException(); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); if (methodCall.Arguments.Count == 2) { sequence = builder.BuildWhere(buildInfo.Parent, sequence, (LambdaExpression)methodCall.Arguments[1].Unwrap(), false); } sequence.SqlQuery.QueryType = QueryType.Delete; return(new DeleteContext(buildInfo.Parent, sequence)); }
protected override bool CanBuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { if (!methodCall.IsQueryable("GroupBy")) { return(false); } var body = ((LambdaExpression)methodCall.Arguments[1].Unwrap()).Body.Unwrap(); if (body.NodeType == ExpressionType.MemberInit) { var mi = (MemberInitExpression)body; bool throwExpr; if (mi.NewExpression.Arguments.Count > 0 || mi.Bindings.Count == 0) { throwExpr = true; } else { throwExpr = mi.Bindings.Any(b => b.BindingType != MemberBindingType.Assignment); } if (throwExpr) { throw new NotSupportedException(string.Format("Explicit construction of entity type '{0}' in group by is not allowed.", body.Type)); } } return(methodCall.Arguments[methodCall.Arguments.Count - 1].Unwrap().NodeType == ExpressionType.Lambda); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequenceExpr = methodCall.Arguments[0]; var sequence = builder.BuildSequence(new BuildInfo(buildInfo, sequenceExpr)); var groupingType = methodCall.Type.GetGenericArguments()[0]; var keySelector = (LambdaExpression)methodCall.Arguments[1].Unwrap(); var elementSelector = (LambdaExpression)methodCall.Arguments[2].Unwrap(); if (methodCall.Arguments[0].NodeType == ExpressionType.Call) { var call = (MethodCallExpression)methodCall.Arguments[0]; if (call.Method.Name == "Select") { var type = ((LambdaExpression)call.Arguments[1].Unwrap()).Body.Type; if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ExpressionBuilder.GroupSubQuery <,>)) { sequence = new SubQueryContext(sequence); } } } var key = new KeyContext(buildInfo.Parent, keySelector, sequence); var groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key); if (groupSql.Any(_ => !(_.Sql is SqlField || _.Sql is SqlQuery.Column))) { sequence = new SubQueryContext(sequence); key = new KeyContext(buildInfo.Parent, keySelector, sequence); groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key); } sequence.SqlQuery.GroupBy.Items.Clear(); foreach (var sql in groupSql) { sequence.SqlQuery.GroupBy.Expr(sql.Sql); } new QueryVisitor().Visit(sequence.SqlQuery.From, e => { if (e.ElementType == QueryElementType.JoinedTable) { var jt = (SqlQuery.JoinedTable)e; if (jt.JoinType == SqlQuery.JoinType.Inner) { jt.IsWeak = false; } } }); var element = new SelectContext(buildInfo.Parent, elementSelector, sequence /*, key*/); var groupBy = new GroupByContext(buildInfo.Parent, sequenceExpr, groupingType, sequence, key, element); return(groupBy); }
public override IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo) { if (Collection != null) { if (expression == null) { return(Collection.GetContext(expression, level, buildInfo)); } var root = expression.GetRootObject(); if (root != Lambda.Parameters[0]) { return(Collection.GetContext(expression, level, buildInfo)); } } return(base.GetContext(expression, level, buildInfo)); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); var collectionSelector = (LambdaExpression)methodCall.Arguments[1].Unwrap(); var resultSelector = (LambdaExpression)methodCall.Arguments[2].Unwrap(); if (!sequence.SqlQuery.GroupBy.IsEmpty) { sequence = new SubQueryContext(sequence); } var context = new SelectManyContext(buildInfo.Parent, collectionSelector, sequence); var expr = collectionSelector.Body.Unwrap(); var collectionInfo = new BuildInfo(context, expr, new SqlQuery()); var collection = builder.BuildSequence(collectionInfo); var leftJoin = collection is DefaultIfEmptyBuilder.DefaultIfEmptyContext; var sql = collection.SqlQuery; var sequenceTable = sequence.SqlQuery.From.Tables[0].Source; var newQuery = null != new QueryVisitor().Find(sql, e => e == collectionInfo.SqlQuery); var crossApply = null != new QueryVisitor().Find(sql, e => e == sequenceTable || e.ElementType == QueryElementType.SqlField && sequenceTable == ((SqlField)e).Table || e.ElementType == QueryElementType.Column && sequenceTable == ((SqlQuery.Column)e).Parent); if (collection is JoinBuilder.GroupJoinSubQueryContext) { var groupJoin = ((JoinBuilder.GroupJoinSubQueryContext)collection).GroupJoin; groupJoin.SqlQuery.From.Tables[0].Joins[0].JoinType = SqlQuery.JoinType.Inner; groupJoin.SqlQuery.From.Tables[0].Joins[0].IsWeak = false; } if (!newQuery) { context.Collection = new SubQueryContext(collection, sequence.SqlQuery, false); return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context)); } if (!crossApply) { if (!leftJoin) { context.Collection = new SubQueryContext(collection, sequence.SqlQuery, true); return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context)); } else { var join = SqlQuery.OuterApply(sql); sequence.SqlQuery.From.Tables[0].Joins.Add(join.JoinedTable); context.Collection = new SubQueryContext(collection, sequence.SqlQuery, false); return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context)); } } if (collection is TableBuilder.TableContext) { var table = (TableBuilder.TableContext)collection; var join = table.SqlTable.TableArguments != null && table.SqlTable.TableArguments.Length > 0 ? leftJoin ? SqlQuery.OuterApply(sql) : SqlQuery.CrossApply(sql) : leftJoin?SqlQuery.LeftJoin(sql) : SqlQuery.InnerJoin(sql); join.JoinedTable.Condition.Conditions.AddRange(sql.Where.SearchCondition.Conditions); sql.Where.SearchCondition.Conditions.Clear(); var collectionParent = collection.Parent as TableBuilder.TableContext; // Association. // if (collectionParent != null && collectionInfo.IsAssociationBuilt) { var ts = (SqlQuery.TableSource) new QueryVisitor().Find(sequence.SqlQuery.From, e => { if (e.ElementType == QueryElementType.TableSource) { var t = (SqlQuery.TableSource)e; return(t.Source == collectionParent.SqlTable); } return(false); }); ts.Joins.Add(join.JoinedTable); } else { sequence.SqlQuery.From.Tables[0].Joins.Add(join.JoinedTable); } context.Collection = new SubQueryContext(collection, sequence.SqlQuery, false); return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context)); } else { var join = leftJoin ? SqlQuery.OuterApply(sql) : SqlQuery.CrossApply(sql); sequence.SqlQuery.From.Tables[0].Joins.Add(join.JoinedTable); context.Collection = new SubQueryContext(collection, sequence.SqlQuery, false); return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context)); } }
protected override bool CanBuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { return (methodCall.IsQueryable("SelectMany") && methodCall.Arguments.Count == 3 && ((LambdaExpression)methodCall.Arguments[1].Unwrap()).Parameters.Count == 1); }
public virtual IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo) { if (expression == null) { return(this); } if (IsScalar) { return(ProcessScalar( expression, level, (ctx, ex, l) => ctx.GetContext(ex, l, buildInfo), () => { throw new InvalidOperationException(); })); } else { var levelExpression = expression.GetLevelExpression(level); switch (levelExpression.NodeType) { case ExpressionType.MemberAccess: { if (levelExpression == expression && Sequence.Length == 1 && !(Sequence[0] is GroupByBuilder.GroupByContext)) { var memberExpression = GetMemberExpression( ((MemberExpression)levelExpression).Member, levelExpression == expression, levelExpression.Type); //var sequence = GetSequence(memberExpression, 0); //return sequence.GetContext(memberExpression, 1, new BuildInfo(buildInfo, memberExpression)); var ctx = GetContext(memberExpression, 0, new BuildInfo(this, memberExpression, buildInfo.SqlQuery)); if (ctx != null) { return(ctx); } } var context = ProcessMemberAccess( expression, (MemberExpression)levelExpression, level, (n, ctx, ex, l, _) => n == 0 ? null : ctx.GetContext(ex, l, buildInfo)); if (context == null) { throw new InvalidOperationException(); } return(context); } case ExpressionType.Parameter: { var sequence = GetSequence(expression, level); var parameter = Lambda.Parameters[Sequence.Length == 0 ? 0 : Array.IndexOf(Sequence, sequence)]; if (levelExpression == expression) { if (levelExpression == parameter) { return(sequence.GetContext(null, 0, buildInfo)); } } else if (level == 0) { return(sequence.GetContext(expression, 1, buildInfo)); } break; } } if (level == 0) { var sequence = GetSequence(expression, level); return(sequence.GetContext(expression, level + 1, buildInfo)); } } throw new InvalidOperationException(); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); switch (methodCall.Arguments.Count) { case 1: // int Update<T>(this IUpdateable<T> source) break; case 2: // int Update<T>(this IQueryable<T> source, Expression<Func<T,T>> setter) { BuildSetter( builder, buildInfo, (LambdaExpression)methodCall.Arguments[1].Unwrap(), sequence, sequence.SqlQuery.Update.Items, sequence); break; } case 3: { var expr = methodCall.Arguments[1].Unwrap(); if (expr is LambdaExpression) { // int Update<T>(this IQueryable<T> source, Expression<Func<T,bool>> predicate, Expression<Func<T,T>> setter) // sequence = builder.BuildWhere(buildInfo.Parent, sequence, (LambdaExpression)methodCall.Arguments[1].Unwrap(), false); BuildSetter( builder, buildInfo, (LambdaExpression)methodCall.Arguments[2].Unwrap(), sequence, sequence.SqlQuery.Update.Items, sequence); } else { // static int Update<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target, Expression<Func<TSource,TTarget>> setter) // var into = builder.BuildSequence(new BuildInfo(buildInfo, expr, new SqlQuery())); BuildSetter( builder, buildInfo, (LambdaExpression)methodCall.Arguments[2].Unwrap(), into, sequence.SqlQuery.Update.Items, sequence); var sql = sequence.SqlQuery; sql.Select.Columns.Clear(); foreach (var item in sql.Update.Items) { sql.Select.Columns.Add(new SqlQuery.Column(sql, item.Expression)); } sql.Update.Table = ((TableBuilder.TableContext)into).SqlTable; } break; } } sequence.SqlQuery.QueryType = QueryType.Update; return(new UpdateContext(buildInfo.Parent, sequence)); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); var isSubQuery = sequence.SqlQuery.Select.IsDistinct; if (isSubQuery) { sequence = new SubQueryContext(sequence); } switch (methodCall.Arguments.Count) { case 1: // static int Insert<T> (this IValueInsertable<T> source) // static int Insert<TSource,TTarget>(this ISelectInsertable<TSource,TTarget> source) { foreach (var item in sequence.SqlQuery.Insert.Items) { sequence.SqlQuery.Select.Expr(item.Expression); } break; } case 2: // static int Insert<T>(this Table<T> target, Expression<Func<T>> setter) { UpdateBuilder.BuildSetter( builder, buildInfo, (LambdaExpression)methodCall.Arguments[1].Unwrap(), sequence, sequence.SqlQuery.Insert.Items, sequence); sequence.SqlQuery.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable; sequence.SqlQuery.From.Tables.Clear(); break; } case 3: // static int Insert<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target, Expression<Func<TSource,TTarget>> setter) { var into = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SqlQuery())); UpdateBuilder.BuildSetter( builder, buildInfo, (LambdaExpression)methodCall.Arguments[2].Unwrap(), into, sequence.SqlQuery.Insert.Items, sequence); sequence.SqlQuery.Select.Columns.Clear(); foreach (var item in sequence.SqlQuery.Insert.Items) { sequence.SqlQuery.Select.Columns.Add(new SqlQuery.Column(sequence.SqlQuery, item.Expression)); } sequence.SqlQuery.Insert.Into = ((TableBuilder.TableContext)into).SqlTable; break; } } sequence.SqlQuery.QueryType = QueryType.Insert; sequence.SqlQuery.Insert.WithIdentity = methodCall.Method.Name == "InsertWithIdentity"; return(new InsertContext(buildInfo.Parent, sequence, sequence.SqlQuery.Insert.WithIdentity)); }
internal static void ParseSet( ExpressionBuilder builder, BuildInfo buildInfo, LambdaExpression extract, LambdaExpression update, IBuildContext select, SqlTable table, List <SqlQuery.SetExpression> items) { var ext = extract.Body; while (ext.NodeType == ExpressionType.Convert || ext.NodeType == ExpressionType.ConvertChecked) { ext = ((UnaryExpression)ext).Operand; } if (ext.NodeType != ExpressionType.MemberAccess || ext.GetRootObject() != extract.Parameters[0]) { throw new LinqException("Member expression expected for the 'Set' statement."); } var body = (MemberExpression)ext; var member = body.Member; if (member is MethodInfo) { member = TypeHelper.GetPropertyByMethod((MethodInfo)member); } var members = body.GetMembers(); var name = members .Skip(1) .Select(ex => { var me = ex as MemberExpression; if (me == null) { return(null); } var m = me.Member; if (m is MethodInfo) { m = TypeHelper.GetPropertyByMethod((MethodInfo)m); } return(m); }) .Where(m => m != null && !TypeHelper.IsNullableValueMember(m)) .Select(m => m.Name) .Aggregate((s1, s2) => s1 + "." + s2); if (table != null && !table.Fields.ContainsKey(name)) { throw new LinqException("Member '{0}.{1}' is not a table column.", member.DeclaringType.Name, name); } var column = table != null ? table.Fields[name] : select.ConvertToSql( body, 1, ConvertFlags.Field)[0].Sql; //Expression.MakeMemberAccess(Expression.Parameter(member.DeclaringType, "p"), member), 1, ConvertFlags.Field)[0].Sql; var sp = select.Parent; var ctx = new ExpressionContext(buildInfo.Parent, select, update); var expr = builder.ConvertToSqlExpression(ctx, update.Body); builder.ReplaceParent(ctx, sp); if (expr is SqlParameter && update.Body.Type.IsEnum) { ((SqlParameter)expr).SetEnumConverter(update.Body.Type, builder.MappingSchema); } items.Add(new SqlQuery.SetExpression(column, expr)); }
protected override bool CanBuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { return(methodCall.IsQueryable("Insert", "InsertWithIdentity")); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); var extract = (LambdaExpression)methodCall.Arguments[1].Unwrap(); var update = methodCall.Arguments[2].Unwrap(); if (update.NodeType == ExpressionType.Lambda) { ParseSet( builder, buildInfo, extract, (LambdaExpression)update, sequence, sequence.SqlQuery.Update.Table, sequence.SqlQuery.Update.Items); } else { ParseSet( builder, buildInfo, extract, update, sequence, sequence.SqlQuery.Update.Items); } return(sequence); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var source = methodCall.Arguments[0].Unwrap(); var into = methodCall.Arguments[1].Unwrap(); IBuildContext sequence; // static IValueInsertable<T> Into<T>(this IDataContext dataContext, Table<T> target) // if (source.NodeType == ExpressionType.Constant && ((ConstantExpression)source).Value == null) { sequence = builder.BuildSequence(new BuildInfo((IBuildContext)null, into, new SqlQuery())); sequence.SqlQuery.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable; sequence.SqlQuery.From.Tables.Clear(); } // static ISelectInsertable<TSource,TTarget> Into<TSource,TTarget>(this IQueryable<TSource> source, Table<TTarget> target) // else { sequence = builder.BuildSequence(new BuildInfo(buildInfo, source)); var tbl = builder.BuildSequence(new BuildInfo((IBuildContext)null, into, new SqlQuery())); sequence.SqlQuery.Insert.Into = ((TableBuilder.TableContext)tbl).SqlTable; } sequence.SqlQuery.Select.Columns.Clear(); return(sequence); }
protected override bool CanBuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { return (methodCall.IsQueryable(MethodNames) && methodCall.Arguments.Count == 1); }
protected override bool CanBuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { return(methodCall.IsQueryable("Value")); }
public override IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo) { throw new InvalidOperationException(); }
protected override bool CanBuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { return(methodCall.Arguments.Count == 2 && methodCall.IsQueryable("Except", "Intersect")); }
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo) { var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])); var take = 0; if (!buildInfo.IsSubQuery || builder.SqlProvider.IsSubQueryTakeSupported) { switch (methodCall.Method.Name) { case "First": case "FirstOrDefault": take = 1; break; case "Single": case "SingleOrDefault": if (!buildInfo.IsSubQuery) { take = 2; } break; } } if (take != 0) { builder.BuildTake(sequence, new SqlValue(take)); } return(new FirstSingleContext(buildInfo.Parent, sequence, methodCall)); }
protected override SequenceConvertInfo Convert( ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo, ParameterExpression param) { return(null); }
public override IBuildContext GetContext(Expression expression, int level, BuildInfo buildInfo) { return(Sequence.GetContext(expression, level, buildInfo)); }