protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.SelectQuery.Select.IsDistinct)
{
sequence = new SubQueryContext(sequence);
}
var arg = methodCall.Arguments[1].Unwrap();
if (arg.NodeType == ExpressionType.Lambda)
{
arg = ((LambdaExpression)arg).Body.Unwrap();
}
var expr = builder.ConvertToSql(sequence, arg);
if (methodCall.Method.Name == "Take")
{
BuildTake(builder, sequence, expr);
}
else
{
BuildSkip(builder, sequence, sequence.SelectQuery.Select.SkipValue, expr);
}
return(sequence);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.SelectQuery.Select.TakeValue != null ||
sequence.SelectQuery.Select.SkipValue != null ||
sequence.SelectQuery.Select.IsDistinct /*&& !builder.DataContextInfo.SqlProviderFlags.IsDistinctOrderBySupported*/)
{
sequence = new SubQueryContext(sequence);
}
var lambda = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var sparent = sequence.Parent;
var order = new ExpressionContext(buildInfo.Parent, sequence, lambda);
var body = lambda.Body.Unwrap();
var sql = builder.ConvertExpressions(order, body, ConvertFlags.Key);
builder.ReplaceParent(order, sparent);
if (!methodCall.Method.Name.StartsWith("Then"))
{
sequence.SelectQuery.OrderBy.Items.Clear();
}
foreach (var expr in sql)
{
var e = builder.ConvertSearchCondition(sequence, expr.Sql);
sequence.SelectQuery.OrderBy.Expr(e, methodCall.Method.Name.EndsWith("Descending"));
}
return(sequence);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0])
{
CopyTable = true
});
if (methodCall.Arguments.Count == 2)
{
if (sequence.SelectQuery.Select.TakeValue != null ||
sequence.SelectQuery.Select.SkipValue != null)
{
sequence = new SubQueryContext(sequence);
}
var condition = (LambdaExpression)methodCall.Arguments[1].Unwrap();
if (methodCall.Method.Name == "All")
{
condition = Expression.Lambda(Expression.Not(condition.Body), condition.Name, condition.Parameters);
}
sequence = builder.BuildWhere(buildInfo.Parent, sequence, condition, true);
sequence.SetAlias(condition.Parameters[0].Name);
}
return(new AllAnyContext(buildInfo.Parent, methodCall, sequence));
}
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.GetGenericArgumentsEx()[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.IsGenericTypeEx() && 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 (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.GroupBy.Items.Count > 0 ||
groupSql.Any(_ => !(_.Sql is SqlField || _.Sql is SelectQuery.Column)))
{
sequence = new SubQueryContext(sequence);
key = new KeyContext(buildInfo.Parent, keySelector, sequence);
groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
}
foreach (var sql in groupSql)
{
sequence.SelectQuery.GroupBy.Expr(sql.Sql);
}
new QueryVisitor().Visit(sequence.SelectQuery.From, e =>
{
if (e.ElementType == QueryElementType.JoinedTable)
{
var jt = (SelectQuery.JoinedTable)e;
if (jt.JoinType == SelectQuery.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);
}
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 SelectQuery())));
var union = new SelectQuery.Union(sequence2.SelectQuery, methodCall.Method.Name == "Concat");
sequence1.SelectQuery.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]));
if (sequence.SelectQuery.Select.TakeValue != null ||
sequence.SelectQuery.Select.SkipValue != null)
{
sequence = new SubQueryContext(sequence);
}
return(new ContainsContext(buildInfo.Parent, methodCall, sequence));
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var sql = sequence.SelectQuery;
if (sql.Select.TakeValue != null || sql.Select.SkipValue != null)
{
sequence = new SubQueryContext(sequence);
}
sequence.SelectQuery.Select.IsDistinct = true;
sequence.ConvertToIndex(null, 0, ConvertFlags.All);
return(sequence);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.Select.TakeValue != null ||
sequence.SelectQuery.Select.SkipValue != null ||
!sequence.SelectQuery.GroupBy.IsEmpty)
{
sequence = new SubQueryContext(sequence);
}
if (sequence.SelectQuery.OrderBy.Items.Count > 0)
{
if (sequence.SelectQuery.Select.TakeValue == null && sequence.SelectQuery.Select.SkipValue == null)
{
sequence.SelectQuery.OrderBy.Items.Clear();
}
else
{
sequence = new SubQueryContext(sequence);
}
}
var context = new AggregationContext(buildInfo.Parent, sequence, methodCall);
var sql = sequence.ConvertToSql(null, 0, ConvertFlags.Field).Select(_ => _.Sql).ToArray();
if (sql.Length == 1 && sql[0] is SelectQuery)
{
var query = (SelectQuery)sql[0];
if (query.Select.Columns.Count == 1)
{
var join = SelectQuery.OuterApply(query);
context.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
sql[0] = query.Select.Columns[0];
}
}
context.Sql = context.SelectQuery;
context.FieldIndex = context.SelectQuery.Select.Add(
new SqlFunction(methodCall.Type, methodCall.Method.Name, sql));
return(context);
}
public UnionContext(SubQueryContext sequence1, SubQueryContext sequence2, MethodCallExpression methodCall)
: base(sequence1)
{
_sequence1 = sequence1;
_sequence2 = sequence2;
_methodCall = methodCall;
_sequence2.Parent = this;
_isObject =
sequence1.IsExpression(null, 0, RequestFor.Object).Result ||
sequence2.IsExpression(null, 0, RequestFor.Object).Result;
if (_isObject)
{
_type = _methodCall.Method.GetGenericArguments()[0];
_unionParameter = Expression.Parameter(_type, "t");
}
Init();
}
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 SelectQuery()));
if (sequence.SelectQuery.Select.IsDistinct)
{
sequence = new SubQueryContext(sequence);
}
sequence.SelectQuery.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable;
sequence.SelectQuery.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));
if (sequence.SelectQuery.Select.IsDistinct)
{
sequence = new SubQueryContext(sequence);
}
var tbl = builder.BuildSequence(new BuildInfo((IBuildContext)null, into, new SelectQuery()));
sequence.SelectQuery.Insert.Into = ((TableBuilder.TableContext)tbl).SqlTable;
}
sequence.SelectQuery.Select.Columns.Clear();
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 SelectQuery()));
var except = query.SelectQuery;
sequence = new SubQueryContext(sequence);
var sql = sequence.SelectQuery;
except.ParentSelect = 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);
}
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.GetGenericArgumentsEx()[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.IsGenericTypeEx() && 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 (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.GroupBy.Items.Count > 0 ||
groupSql.Any(_ => !(_.Sql is SqlField || _.Sql is SelectQuery.Column)))
{
sequence = new SubQueryContext(sequence);
key = new KeyContext(buildInfo.Parent, keySelector, sequence);
groupSql = builder.ConvertExpressions(key, keySelector.Body.Unwrap(), ConvertFlags.Key);
}
else if (groupSql.Length == 1 && groupSql.Any(_ => _.Sql is SelectQuery.Column))
{
//var columns = (SelectQuery.Column) groupSql[0]. Sql;
//var value = columns.Expression as SqlValue;
//if (value != null && value.SystemType.Name.Equals("String"))
//{
// // var allColumns = value.Value.ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
// sequence.SelectQuery.GroupBy.Items.Add(new SqlField {Name = value.Value.ToString(),PhysicalName ="columnString" });
// }
}
foreach (var sql in groupSql)
{
sequence.SelectQuery.GroupBy.Expr(sql.Sql);
}
new QueryVisitor().Visit(sequence.SelectQuery.From, (e, table_cloumn) =>
{
if (e.ElementType == QueryElementType.JoinedTable)
{
var jt = (SelectQuery.JoinedTable)e;
if (jt.JoinType == SelectQuery.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);
}
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.SelectQuery.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 SelectQuery());
var collection = builder.BuildSequence(collectionInfo);
var leftJoin = collection is DefaultIfEmptyBuilder.DefaultIfEmptyContext;
var sql = collection.SelectQuery;
var sequenceTables = new HashSet <ISqlTableSource>(sequence.SelectQuery.From.Tables[0].GetTables());
var newQuery = null != new QueryVisitor().Find(sql, e => e == collectionInfo.SelectQuery);
var crossApply = null != new QueryVisitor().Find(sql, e =>
e.ElementType == QueryElementType.TableSource && sequenceTables.Contains((ISqlTableSource)e) ||
e.ElementType == QueryElementType.SqlField && sequenceTables.Contains(((SqlField)e).Table) ||
e.ElementType == QueryElementType.Column && sequenceTables.Contains(((SelectQuery.Column)e).Parent));
if (collection is JoinBuilder.GroupJoinSubQueryContext)
{
var groupJoin = ((JoinBuilder.GroupJoinSubQueryContext)collection).GroupJoin;
groupJoin.SelectQuery.From.Tables[0].Joins[0].JoinType = SelectQuery.JoinType.Inner;
groupJoin.SelectQuery.From.Tables[0].Joins[0].IsWeak = false;
}
if (!newQuery)
{
if (collection.SelectQuery.Select.HasModifier)
{
if (crossApply)
{
var foundJoin = context.SelectQuery.FindJoin(j => j.Table.Source == collection.SelectQuery);
if (foundJoin != null)
{
foundJoin.JoinType = leftJoin ? SelectQuery.JoinType.OuterApply : SelectQuery.JoinType.CrossApply;
collection.SelectQuery.Where.ConcatSearchCondition(foundJoin.Condition);
((ISqlExpressionWalkable)collection.SelectQuery.Where).Walk(false, e =>
{
var column = e as SelectQuery.Column;
if (column != null)
{
if (column.Parent == collection.SelectQuery)
{
return(column.UnderlyingColumn);
}
}
return(e);
});
foundJoin.Condition.Conditions.Clear();
}
}
}
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
if (!crossApply)
{
if (!leftJoin)
{
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, true);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
else
{
var join = SelectQuery.OuterApply(sql);
sequence.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
}
if (collection is TableBuilder.TableContext)
{
// if (collectionInfo.IsAssociationBuilt)
// {
// context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
// return new SelectContext(buildInfo.Parent, resultSelector, sequence, context);
// }
var table = (TableBuilder.TableContext)collection;
var isApplyJoin = collection.SelectQuery.Select.HasModifier ||
table.SqlTable.TableArguments != null && table.SqlTable.TableArguments.Length > 0;
var join = isApplyJoin
? (leftJoin ? SelectQuery.OuterApply(sql) : SelectQuery.CrossApply(sql))
: (leftJoin ? SelectQuery.LeftJoin(sql) : SelectQuery.InnerJoin(sql));
join.JoinedTable.CanConvertApply = false;
if (!isApplyJoin)
{
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 = (SelectQuery.TableSource) new QueryVisitor().Find(sequence.SelectQuery.From, e =>
{
if (e.ElementType == QueryElementType.TableSource)
{
var t = (SelectQuery.TableSource)e;
return(t.Source == collectionParent.SqlTable);
}
return(false);
});
ts.Joins.Add(join.JoinedTable);
}
else
{
//if (collectionInfo.IsAssociationBuilt)
//{
// collectionInfo.AssosiationContext.ParentAssociationJoin.IsWeak = false;
//}
//else
{
sequence.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
}
}
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
else
{
var join = leftJoin ? SelectQuery.OuterApply(sql) : SelectQuery.CrossApply(sql);
sequence.SelectQuery.From.Tables[0].Joins.Add(join.JoinedTable);
context.Collection = new SubQueryContext(collection, sequence.SelectQuery, false);
return(new SelectContext(buildInfo.Parent, resultSelector, sequence, context));
}
}
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])
{
CreateSubQuery = true
});
if (sequence.SelectQuery != buildInfo.SelectQuery)
{
// if (sequence is JoinBuilder.GroupJoinSubQueryContext)
// {
// var ctx = new CountContext(buildInfo.Parent, sequence, returnType)
// {
// SelectQuery =
// sequence.SelectQuery
// //((JoinBuilder.GroupJoinSubQueryContext)sequence).GetCounter(methodCall)
// };
//
// ctx.Sql = ctx.SelectQuery;
// ctx.FieldIndex = ctx.SelectQuery.Select.Add(SqlFunction.CreateCount(returnType, ctx.SelectQuery), "cnt");
//
// return ctx;
// }
if (sequence is GroupByBuilder.GroupByContext)
{
return(new CountContext(buildInfo.Parent, sequence, returnType)
{
Sql = SqlFunction.CreateCount(returnType, sequence.SelectQuery),
FieldIndex = -1
});
}
}
if (sequence.SelectQuery.Select.IsDistinct ||
sequence.SelectQuery.Select.TakeValue != null ||
sequence.SelectQuery.Select.SkipValue != null)
{
sequence.ConvertToIndex(null, 0, ConvertFlags.Key);
sequence = new SubQueryContext(sequence);
}
else if (!sequence.SelectQuery.GroupBy.IsEmpty)
{
if (!builder.DataContextInfo.SqlProviderFlags.IsSybaseBuggyGroupBy)
{
sequence.SelectQuery.Select.Add(new SqlValue(0));
}
else
{
foreach (var item in sequence.SelectQuery.GroupBy.Items)
{
sequence.SelectQuery.Select.Add(item);
}
}
sequence = new SubQueryContext(sequence);
}
if (sequence.SelectQuery.OrderBy.Items.Count > 0)
{
if (sequence.SelectQuery.Select.TakeValue == null && sequence.SelectQuery.Select.SkipValue == null)
{
sequence.SelectQuery.OrderBy.Items.Clear();
}
else
{
sequence = new SubQueryContext(sequence);
}
}
var context = new CountContext(buildInfo.Parent, sequence, returnType);
context.Sql = context.SelectQuery;
context.FieldIndex = context.SelectQuery.Select.Add(SqlFunction.CreateCount(returnType, context.SelectQuery), "cnt");
return(context);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var isSubQuery = sequence.SelectQuery.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.SelectQuery.Insert.Items)
{
sequence.SelectQuery.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.SelectQuery.Insert.Items,
sequence);
sequence.SelectQuery.Insert.Into = ((TableBuilder.TableContext)sequence).SqlTable;
sequence.SelectQuery.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 SelectQuery()));
UpdateBuilder.BuildSetter(
builder,
buildInfo,
(LambdaExpression)methodCall.Arguments[2].Unwrap(),
into,
sequence.SelectQuery.Insert.Items,
sequence);
sequence.SelectQuery.Select.Columns.Clear();
foreach (var item in sequence.SelectQuery.Insert.Items)
{
sequence.SelectQuery.Select.Columns.Add(new SelectQuery.Column(sequence.SelectQuery, item.Expression));
}
sequence.SelectQuery.Insert.Into = ((TableBuilder.TableContext)into).SqlTable;
break;
}
}
var insert = sequence.SelectQuery.Insert;
var q = insert.Into.Fields.Values
#if SL4
.Cast <ISqlExpression>()
#endif
.Except(insert.Items.Select(e => e.Column))
.OfType <SqlField>()
.Where(f => f.IsIdentity);
foreach (var field in q)
{
var expr = builder.DataContextInfo.CreateSqlBuilder().GetIdentityExpression(insert.Into);
if (expr != null)
{
insert.Items.Insert(0, new SelectQuery.SetExpression(field, expr));
if (methodCall.Arguments.Count == 3)
{
sequence.SelectQuery.Select.Columns.Insert(0, new SelectQuery.Column(sequence.SelectQuery, insert.Items[0].Expression));
}
}
}
sequence.SelectQuery.QueryType = QueryType.Insert;
sequence.SelectQuery.Insert.WithIdentity = methodCall.Method.Name == "InsertWithIdentity";
return(new InsertContext(buildInfo.Parent, sequence, sequence.SelectQuery.Insert.WithIdentity));
}
IBuildContext GetSubQueryContext(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo,
SelectQuery sql,
LambdaExpression innerKeyLambda,
Expression outerKeySelector,
Expression innerKeySelector,
IBuildContext outerKeyContext)
{
var subQueryContext = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SelectQuery()));
subQueryContext = new SubQueryContext(subQueryContext);
var subQueryParent = subQueryContext.Parent;
var subQueryKeyContext = new ExpressionContext(buildInfo.Parent, subQueryContext, innerKeyLambda);
// Process SubQuery.
//
var subQuerySql = ((SubQueryContext)subQueryContext).SelectQuery;
// Make join and where for the counter.
//
if (outerKeySelector.NodeType == ExpressionType.New)
{
var new1 = (NewExpression)outerKeySelector;
var new2 = (NewExpression)innerKeySelector;
for (var i = 0; i < new1.Arguments.Count; i++)
{
var arg1 = new1.Arguments[i];
var arg2 = new2.Arguments[i];
BuildSubQueryJoin(builder, outerKeyContext, arg1, arg2, subQueryKeyContext, subQuerySql);
}
}
else if (outerKeySelector.NodeType == ExpressionType.MemberInit)
{
var mi1 = (MemberInitExpression)outerKeySelector;
var mi2 = (MemberInitExpression)innerKeySelector;
for (var i = 0; i < mi1.Bindings.Count; i++)
{
if (mi1.Bindings[i].Member != mi2.Bindings[i].Member)
{
throw new LinqException("List of member inits does not match for entity type '{0}'.".Args(outerKeySelector.Type));
}
var arg1 = ((MemberAssignment)mi1.Bindings[i]).Expression;
var arg2 = ((MemberAssignment)mi2.Bindings[i]).Expression;
BuildSubQueryJoin(builder, outerKeyContext, arg1, arg2, subQueryKeyContext, subQuerySql);
}
}
else
{
BuildSubQueryJoin(builder, outerKeyContext, outerKeySelector, innerKeySelector, subQueryKeyContext, subQuerySql);
}
builder.ReplaceParent(subQueryKeyContext, subQueryParent);
subQuerySql.ParentSelect = sql;
subQuerySql.Select.Columns.Clear();
return(subQueryContext);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var isGroup = methodCall.Method.Name == "GroupJoin";
var outerContext = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0], buildInfo.SelectQuery));
var innerContext = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SelectQuery()));
var context = new SubQueryContext(outerContext);
innerContext = isGroup ? new GroupJoinSubQueryContext(innerContext) : new SubQueryContext(innerContext);
var join = isGroup ? innerContext.SelectQuery.WeakLeftJoin() : innerContext.SelectQuery.InnerJoin();
var sql = context.SelectQuery;
sql.From.Tables[0].Joins.Add(join.JoinedTable);
var selector = (LambdaExpression)methodCall.Arguments[4].Unwrap();
context.SetAlias(selector.Parameters[0].Name);
innerContext.SetAlias(selector.Parameters[1].Name);
var outerKeyLambda = ((LambdaExpression)methodCall.Arguments[2].Unwrap());
var innerKeyLambda = ((LambdaExpression)methodCall.Arguments[3].Unwrap());
var outerKeySelector = outerKeyLambda.Body.Unwrap();
var innerKeySelector = innerKeyLambda.Body.Unwrap();
var outerParent = context.Parent;
var innerParent = innerContext.Parent;
var outerKeyContext = new ExpressionContext(buildInfo.Parent, context, outerKeyLambda);
var innerKeyContext = new InnerKeyContext(buildInfo.Parent, innerContext, innerKeyLambda);
// Make join and where for the counter.
//
if (outerKeySelector.NodeType == ExpressionType.New)
{
var new1 = (NewExpression)outerKeySelector;
var new2 = (NewExpression)innerKeySelector;
for (var i = 0; i < new1.Arguments.Count; i++)
{
var arg1 = new1.Arguments[i];
var arg2 = new2.Arguments[i];
BuildJoin(builder, join, outerKeyContext, arg1, innerKeyContext, arg2);
}
}
else if (outerKeySelector.NodeType == ExpressionType.MemberInit)
{
var mi1 = (MemberInitExpression)outerKeySelector;
var mi2 = (MemberInitExpression)innerKeySelector;
for (var i = 0; i < mi1.Bindings.Count; i++)
{
if (mi1.Bindings[i].Member != mi2.Bindings[i].Member)
{
throw new LinqException("List of member inits does not match for entity type '{0}'.".Args(outerKeySelector.Type));
}
var arg1 = ((MemberAssignment)mi1.Bindings[i]).Expression;
var arg2 = ((MemberAssignment)mi2.Bindings[i]).Expression;
BuildJoin(builder, join, outerKeyContext, arg1, innerKeyContext, arg2);
}
}
else
{
BuildJoin(builder, join, outerKeyContext, outerKeySelector, innerKeyContext, innerKeySelector);
}
builder.ReplaceParent(outerKeyContext, outerParent);
builder.ReplaceParent(innerKeyContext, innerParent);
if (isGroup)
{
var inner = (GroupJoinSubQueryContext)innerContext;
inner.Join = join.JoinedTable;
inner.GetSubQueryContext = () =>
GetSubQueryContext(builder, methodCall, buildInfo, sql,
innerKeyLambda, outerKeySelector, innerKeySelector, outerKeyContext);
return(new GroupJoinContext(
buildInfo.Parent, selector, context, inner, methodCall.Arguments[1], outerKeyLambda, innerKeyLambda));
}
return(new JoinContext(buildInfo.Parent, selector, context, innerContext)
#if DEBUG
{
MethodCall = methodCall
}
#endif
);
}