public void ProcessNames_NoSqlEntityExpression_SameExpression ()
{
var expression = new NamedExpression ("test", Expression.Constant ("test"));
var result = _namedExpressionCombiner.ProcessNames (expression);
Assert.That (result, Is.SameAs (expression));
}
public void ProcessNames_ReturnsNamedExpression_OuterNameIsNull ()
{
var expression = new NamedExpression (null, new NamedExpression ("inner", Expression.Constant ("test")));
var result = _namedExpressionCombiner.ProcessNames (expression);
Assert.That (result, Is.TypeOf (typeof (NamedExpression)));
Assert.That (((NamedExpression) result).Name, Is.EqualTo ("inner"));
}
public void VisitNamedExpression_NameIsNotNull ()
{
var columnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false);
var expression = new NamedExpression ("test", columnExpression);
SqlGeneratingSelectExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("[c].[Name] AS [test]"));
}
public override Expression VisitNamedExpression (NamedExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
var result = base.VisitNamedExpression (expression);
SetInMemoryProjectionForNamedExpression (expression.Type, Expression.Constant (GetNextColumnID (expression.Name ?? NamedExpression.DefaultName)));
return result;
}
public override Expression VisitNamedExpression (NamedExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
VisitExpression (expression.Expression);
CommandBuilder.Append (" AS ");
CommandBuilder.AppendIdentifier (expression.Name ?? NamedExpression.DefaultName);
return expression;
}
public Expression VisitNamedExpression (NamedExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
return new SqlColumnDefinitionExpression (
expression.Type,
_tableInfo.TableAlias,
expression.Name ?? NamedExpression.DefaultName,
false);
}
public void CreateWithNames ()
{
var result = SqlGroupingSelectExpression.CreateWithNames (_keyExpression, _elementExpression);
var expectedKeyExpression = new NamedExpression ("key", _keyExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedKeyExpression, result.KeyExpression);
var expectedElementExpression = new NamedExpression ("element", _elementExpression);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedElementExpression, result.ElementExpression);
}
public void AddAggregationExpressionWithName ()
{
var name = _sqlGroupingSelectExpression.AddAggregationExpressionWithName (_aggregateExpression2);
Assert.That (_sqlGroupingSelectExpression.AggregationExpressions.Count, Is.EqualTo (2));
Assert.That (name, Is.EqualTo ("a1"));
var expectedNamedExpression = new NamedExpression ("a1", _aggregateExpression2);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedNamedExpression, _sqlGroupingSelectExpression.AggregationExpressions[1]);
}
public void ResolveSubStatementReferenceExpression_CreatesColumnExpression_ForNamedExpression ()
{
var referencedExpression = new NamedExpression ("test", Expression.Constant (0));
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement (referencedExpression);
var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement);
var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner);
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (
referencedExpression, tableInfo, sqlTable, _context);
var expectedResult = new SqlColumnDefinitionExpression (typeof (int), "q0", "test", false);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateStrictMock<ISqlGenerationStage> ();
_commandBuilder = new SqlCommandBuilder ();
_visitor = new TestableSqlGeneratingOuterSelectExpressionVisitor (_commandBuilder, _stageMock);
_namedIntExpression = new NamedExpression ("test", Expression.Constant (0));
_nameColumnExpression = new SqlColumnDefinitionExpression (typeof (string), "c", "Name", false);
_entityExpression = new SqlEntityDefinitionExpression (
typeof (Cook),
"c",
"test",
e => e,
new SqlColumnDefinitionExpression (typeof (int), "c", "ID", true),
_nameColumnExpression,
new SqlColumnDefinitionExpression (typeof (string), "c", "FirstName", false)
);
}
public void SetUp ()
{
_dataInfo = new StreamedScalarValueInfo (typeof (int));
_resolvedElementExpressionReference = new SqlColumnDefinitionExpression (typeof (string), "q0", "element", false);
_resolvedSelectProjection = new NamedExpression (
null,
new AggregationExpression (typeof (int), _resolvedElementExpressionReference, AggregationModifier.Min));
_associatedGroupingSelectExpression = new SqlGroupingSelectExpression (
new NamedExpression ("key", Expression.Constant ("k")),
new NamedExpression ("element", Expression.Constant ("e")));
_resolvedJoinedGroupingSubStatement = SqlStatementModelObjectMother.CreateSqlStatement (_associatedGroupingSelectExpression);
_resolvedJoinedGroupingTable = new SqlTable (
new ResolvedJoinedGroupingTableInfo (
"q1",
_resolvedJoinedGroupingSubStatement,
_associatedGroupingSelectExpression,
"q0"), JoinSemantics.Inner);
_simplifiableResolvedSqlStatement = new SqlStatement (
_dataInfo,
_resolvedSelectProjection,
new[] { _resolvedJoinedGroupingTable },
null,
null,
new Ordering[0],
null,
false,
Expression.Constant (0),
Expression.Constant (0));
_simplifiableUnresolvedProjection = new AggregationExpression (
typeof (int),
new SqlTableReferenceExpression (_resolvedJoinedGroupingTable),
AggregationModifier.Count);
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage> ();
_context = new MappingResolutionContext();
_groupAggregateSimplifier = new GroupAggregateSimplifier (_stageMock, _context);
}
public virtual Expression VisitSqlConvertedBooleanExpression (SqlConvertedBooleanExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
var namedExpression = expression.Expression as NamedExpression;
if (namedExpression != null)
{
// Since ADO.NET returns bit columns as actual boolean values (not as integer values), we need to convert the NamedExpression back to be
// of type bool/bool? instead of int/int?.
var conversionToBool = GetBitConversionExpression (
sourceType: namedExpression.Type, targetType: expression.Type, convertedExpression: namedExpression.Expression);
var newNamedExpression = new NamedExpression (namedExpression.Name, conversionToBool);
return VisitExpression (newNamedExpression);
}
else
{
VisitExpression (expression.Expression);
return expression;
}
}
public void VisitNamedExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges ()
{
var innerExpression = Expression.Constant (0);
var namedExpression = new NamedExpression ("Name", innerExpression);
var fakeResolvedInnerExpression = new SqlLiteralExpression (1);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (innerExpression)).Return (fakeResolvedInnerExpression);
_namedExpressionCombinerMock
.Expect (mock => mock.ProcessNames (Arg<NamedExpression>.Is.Anything))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
// No revisiting
var result = _visitor.VisitExpression (namedExpression);
_resolverMock.VerifyAllExpectations ();
_namedExpressionCombinerMock.VerifyAllExpectations ();
Assert.That (result, Is.TypeOf<NamedExpression> ());
Assert.That (((NamedExpression) result).Name, Is.EqualTo ("Name"));
Assert.That (((NamedExpression) result).Expression, Is.SameAs (fakeResolvedInnerExpression));
}
public void VisitQuerySourceReferenceExpression_WithExtractedOrderings ()
{
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook));
var sqlTableReferenceExpression = new SqlTableReferenceExpression (sqlTable);
var selectProjection = new NamedExpression("test", Expression.MakeMemberAccess (sqlTableReferenceExpression, typeof (Cook).GetProperty ("Name")));
var orderingExpression = Expression.MakeMemberAccess (sqlTableReferenceExpression, typeof (Cook).GetProperty ("ID"));
var sqlStatement = new SqlStatementBuilder
{
DataInfo = new StreamedSequenceInfo(typeof (DateTime[]), Expression.Constant (new DateTime (2000, 1, 1))),
SelectProjection = selectProjection,
SqlTables = { sqlTable },
Orderings =
{ new Ordering (orderingExpression, OrderingDirection.Asc) }
}.GetSqlStatement();
var fakeSelectExpression = Expression.Constant (new KeyValuePair<string, int>("test", 5));
var fakeWhereExpression = Expression.Constant (true);
var innerSequenceExpression = new SqlSubStatementExpression (sqlStatement);
var joinClause = new JoinClause (
"x",
typeof (Cook[]),
innerSequenceExpression,
Expression.Constant (new Cook ()),
Expression.Constant (new Cook ()));
var groupJoinClause = new GroupJoinClause ("g", typeof (Cook[]), joinClause);
var querySourceReferenceExpression = new QuerySourceReferenceExpression (groupJoinClause);
_stageMock
.Expect (mock => mock.PrepareSelectExpression(Arg<Expression>.Is.Anything, Arg<ISqlPreparationContext>.Is.Anything))
.Return (fakeSelectExpression);
_stageMock
.Expect (mock => mock.PrepareWhereExpression (Arg<Expression>.Matches (e => e is BinaryExpression), Arg.Is (_context)))
.WhenCalled (
mi =>
SqlExpressionTreeComparer.CheckAreEqualTrees (
Expression.Equal (groupJoinClause.JoinClause.OuterKeySelector, groupJoinClause.JoinClause.InnerKeySelector),
(Expression) mi.Arguments[0]))
.Return (fakeWhereExpression);
_stageMock.Replay ();
_visitor.VisitQuerySourceReferenceExpression (querySourceReferenceExpression);
_stageMock.VerifyAllExpectations ();
Assert.That (_visitor.FromExpressionInfo != null); // inline condition because of ReSharper
var fromExpressionInfo = (FromExpressionInfo) _visitor.FromExpressionInfo;
Assert.That (fromExpressionInfo.ExtractedOrderings.Count, Is.EqualTo(1));
Assert.That (fromExpressionInfo.ExtractedOrderings[0].Expression, Is.AssignableTo(typeof(MemberExpression)));
Assert.That (((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression)));
Assert.That (
((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable, Is.TypeOf (typeof (SqlTable)));
Assert.That (
((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo)));
var resolvedSubStatementtableInfo =
(ResolvedSubStatementTableInfo) ((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Expression).SqlTable).TableInfo;
Assert.That (resolvedSubStatementtableInfo.SqlStatement.SelectProjection, Is.SameAs(fakeSelectExpression));
Assert.That (resolvedSubStatementtableInfo.SqlStatement.Orderings.Count, Is.EqualTo (0));
Assert.That (((MemberExpression) fromExpressionInfo.ExtractedOrderings[0].Expression).Member, Is.EqualTo(typeof(KeyValuePair<,>).MakeGenericType(typeof(string), typeof(int)).GetProperty("Value")));
Assert.That (fromExpressionInfo.ItemSelector, Is.AssignableTo (typeof (MemberExpression)));
Assert.That (((MemberExpression) fromExpressionInfo.ItemSelector).Expression, Is.TypeOf(typeof(SqlTableReferenceExpression)));
Assert.That (((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ItemSelector).Expression).SqlTable, Is.TypeOf (typeof (SqlTable)));
Assert.That (
((SqlTable) ((SqlTableReferenceExpression) ((MemberExpression) fromExpressionInfo.ItemSelector).Expression).SqlTable).TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo)));
Assert.That (((MemberExpression) fromExpressionInfo.ItemSelector).Member, Is.EqualTo (typeof (KeyValuePair<,>).MakeGenericType (typeof (string), typeof (int)).GetProperty ("Key")));
}
public void ProcessNames_SqlGroupingSelectExpression ()
{
var keyExpression = new NamedExpression ("key", Expression.Constant ("key"));
var elementExpression = new NamedExpression ("element", Expression.Constant ("element"));
var aggregationExpression = new NamedExpression ("a0", Expression.Constant ("aggregation"));
var groupingSelectExpression = new SqlGroupingSelectExpression (keyExpression, elementExpression, new[]{aggregationExpression});
var expression = new NamedExpression ("outer", groupingSelectExpression);
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook));
_context.AddGroupReferenceMapping (groupingSelectExpression, sqlTable);
var expectedResult = new SqlGroupingSelectExpression (
new NamedExpression ("outer_key", Expression.Constant ("key")),
new NamedExpression ("outer_element", Expression.Constant ("element")),
new[]{new NamedExpression("outer_a0", Expression.Constant("aggregation"))});
var result = _namedExpressionCombiner.ProcessNames (expression);
SqlExpressionTreeComparer.CheckAreEqualTrees (result, expectedResult);
Assert.That (_context.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable));
}
public void ProcessNames_MethodCallExpression_NoObject ()
{
var argument = ExpressionHelper.CreateExpression (typeof (string));
var expression = Expression.Call (
ReflectionUtility.GetMethod (() => int.Parse ("arg")),
argument);
var namedExpression = new NamedExpression ("test", expression);
var result = _namedExpressionCombiner.ProcessNames (namedExpression);
Assert.That (result, Is.AssignableTo (typeof (MethodCallExpression)));
Assert.That (((MethodCallExpression) result).Arguments.Count, Is.EqualTo (1));
Assert.That (((MethodCallExpression) result).Object, Is.Null);
}
public Expression VisitNamedExpression (NamedExpression expression)
{
var newInnerExpression = VisitExpression (expression.Expression);
if (newInnerExpression is SqlConvertedBooleanExpression)
{
var convertedBooleanExpression = (SqlConvertedBooleanExpression) newInnerExpression;
var innerNamedExpression = new NamedExpression (expression.Name, convertedBooleanExpression.Expression);
return VisitExpression (new SqlConvertedBooleanExpression (innerNamedExpression));
}
if (newInnerExpression != expression.Expression)
return new NamedExpression (expression.Name, newInnerExpression);
return expression;
}
public Expression VisitNamedExpression (NamedExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
var baseVisitedExpression = (NamedExpression) VisitExtensionExpression (expression);
var result = _namedExpressionCombiner.ProcessNames (baseVisitedExpression);
if (result != baseVisitedExpression)
return VisitExpression (result);
return baseVisitedExpression;
}
public void ProcessNames_ConvertChecked ()
{
var namedExpression = new NamedExpression (
"outer",
Expression.ConvertChecked (new NamedExpression ("inner", Expression.Constant (1)),
typeof (double)));
var result = _namedExpressionCombiner.ProcessNames (namedExpression);
var expectedResult = Expression.ConvertChecked (new NamedExpression ("outer_inner", Expression.Constant (1)), typeof (double));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
}
public void CreateNewExpressionWithNamedArguments_ArgumentsAlreadyNamedCorrectly_WithGetters ()
{
var innerExpression = new NamedExpression ("A", Expression.Constant (0));
var memberInfo = (MemberInfo) typeof (TypeForNewExpression).GetProperty ("A").GetGetMethod();
var expression = Expression.New (TypeForNewExpression.GetConstructor (typeof (int)), new[] { innerExpression }, memberInfo);
var result = NamedExpression.CreateNewExpressionWithNamedArguments (expression);
Assert.That (result, Is.SameAs (expression));
}
public void CreateNewExpressionWithNamedArguments_ArgumentsAlreadyNamedCorrectly ()
{
var innerExpression = new NamedExpression("m0", Expression.Constant (0));
var expression = Expression.New (TypeForNewExpression.GetConstructor (typeof (int)), new[] { innerExpression });
var result = NamedExpression.CreateNewExpressionWithNamedArguments (expression);
Assert.That (result, Is.SameAs (expression));
}
public void ResolvePotentialEntity_NamedExpression_WithNoEntity_IsLeftUnchanged ()
{
var namedExpression = new NamedExpression ("X", Expression.Constant (0));
var result = _entityIdentityResolver.ResolvePotentialEntity (namedExpression);
Assert.That (result, Is.SameAs (namedExpression));
}
public Expression ProcessNames (NamedExpression outerExpression)
{
ArgumentUtility.CheckNotNull ("outerExpression", outerExpression);
// We cannot implement this as an expression visitor because expression visitors have no fallback case, i.e., there is no good possibility
// to catch all cases not explicitly handled by a visitor. We need that catch-all case, however, and don't want to automatically visit the
// expressions' children.
if (outerExpression.Expression is NewExpression)
{
var newExpression = (NewExpression) outerExpression.Expression;
var preparedArguments = newExpression.Arguments.Select (expr => ProcessNames (new NamedExpression (outerExpression.Name, expr)));
if (newExpression.Members != null && newExpression.Members.Count>0)
return Expression.New (newExpression.Constructor, preparedArguments, newExpression.Members);
else
return Expression.New (newExpression.Constructor, preparedArguments);
}
else if (outerExpression.Expression is MethodCallExpression)
{
var methodCallExpression = (MethodCallExpression) outerExpression.Expression;
var namedInstance = methodCallExpression.Object != null ? new NamedExpression (outerExpression.Name, methodCallExpression.Object) : null;
var namedArguments = methodCallExpression.Arguments.Select ((a, i) => new NamedExpression (outerExpression.Name, a));
return Expression.Call (
namedInstance != null ? ProcessNames (namedInstance) : null,
methodCallExpression.Method,
namedArguments.Select (ProcessNames));
}
else if (outerExpression.Expression is SqlEntityExpression)
{
var entityExpression = (SqlEntityExpression) outerExpression.Expression;
string newName = CombineNames (outerExpression.Name, entityExpression.Name);
return _mappingResolutionContext.UpdateEntityAndAddMapping (entityExpression, entityExpression.Type, entityExpression.TableAlias, newName);
}
else if (outerExpression.Expression is NamedExpression)
{
var namedExpression = (NamedExpression) outerExpression.Expression;
var newName = CombineNames (outerExpression.Name, namedExpression.Name);
return ProcessNames (new NamedExpression (newName, namedExpression.Expression));
}
else if (outerExpression.Expression is SqlGroupingSelectExpression)
{
var groupingSelectExpression = (SqlGroupingSelectExpression) outerExpression.Expression;
var newKeyExpression = ProcessNames (new NamedExpression (outerExpression.Name, groupingSelectExpression.KeyExpression));
var newElementExpression = ProcessNames (new NamedExpression (outerExpression.Name, groupingSelectExpression.ElementExpression));
var newAggregationExpressions =
groupingSelectExpression.AggregationExpressions.Select (e => ProcessNames (new NamedExpression (outerExpression.Name, e)));
return _mappingResolutionContext.UpdateGroupingSelectAndAddMapping (
groupingSelectExpression, newKeyExpression, newElementExpression, newAggregationExpressions);
}
else if (outerExpression.Expression.NodeType == ExpressionType.Convert || outerExpression.Expression.NodeType == ExpressionType.ConvertChecked)
{
var unaryExpression = (UnaryExpression) outerExpression.Expression;
var innerNamedExpression = new NamedExpression (outerExpression.Name, unaryExpression.Operand);
return Expression.MakeUnary (
unaryExpression.NodeType,
ProcessNames (innerNamedExpression),
unaryExpression.Type,
unaryExpression.Method);
}
else
return outerExpression;
}
public void ProcessNames_SqlEntityExpression ()
{
var entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), "test2");
var namedExpression = new NamedExpression ("test", entityExpression);
var tableRegisteredForEntity = SqlStatementModelObjectMother.CreateSqlTable ();
_context.AddSqlEntityMapping (entityExpression, tableRegisteredForEntity);
var result = _namedExpressionCombiner.ProcessNames (namedExpression);
Assert.That (result, Is.Not.SameAs (namedExpression));
Assert.That (result, Is.TypeOf (typeof (SqlEntityDefinitionExpression)));
Assert.That (((SqlEntityDefinitionExpression) result).Name, Is.EqualTo ("test_test2"));
Assert.That (_context.GetSqlTableForEntityExpression ((SqlEntityExpression) result), Is.SameAs (tableRegisteredForEntity));
}
public void CreateNewExpressionWithNamedArguments_ArgumentsAlreadyNamedWithDifferentName ()
{
var innerExpression = new NamedExpression ("test", Expression.Constant (0));
var expression = Expression.New (TypeForNewExpression.GetConstructor (typeof (int)), new[] { innerExpression });
var result = NamedExpression.CreateNewExpressionWithNamedArguments (expression);
var expectedResult = Expression.New (
TypeForNewExpression.GetConstructor (typeof (int)), new[] { new NamedExpression ("m0", innerExpression) });
Assert.That (result, Is.Not.SameAs (expression));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
}
public void ProcessNames_MethodCallExpression_NamedExpressionsInsideArgumentsCombined ()
{
var instance = ExpressionHelper.CreateExpression (typeof (int));
var argument = ExpressionHelper.CreateExpression (typeof (string));
var expression = Expression.Call (
new NamedExpression ("inner", instance),
ReflectionUtility.GetMethod (() => 5.ToString ("arg")),
new NamedExpression ("inner", argument));
var namedExpression = new NamedExpression ("outer", expression);
var result = _namedExpressionCombiner.ProcessNames (namedExpression);
Assert.That (result, Is.AssignableTo (typeof (MethodCallExpression)));
Assert.That (((MethodCallExpression) result).Arguments.Count, Is.EqualTo (1));
Assert.That (((MethodCallExpression) result).Arguments[0], Is.TypeOf (typeof (NamedExpression)));
Assert.That (((NamedExpression) ((MethodCallExpression) result).Arguments[0]).Name, Is.EqualTo ("outer_inner"));
Assert.That (((NamedExpression) ((MethodCallExpression) result).Arguments[0]).Expression, Is.SameAs (argument));
Assert.That (((MethodCallExpression) result).Object, Is.TypeOf (typeof (NamedExpression)));
Assert.That (((NamedExpression) ((MethodCallExpression) result).Object).Name, Is.EqualTo ("outer_inner"));
Assert.That (((NamedExpression) ((MethodCallExpression) result).Object).Expression, Is.SameAs (instance));
}
public void SetUp ()
{
_wrappedExpression = Expression.Constant (1);
_namedExpression = new NamedExpression ("test", _wrappedExpression);
}
public void ResolveSubStatementReferenceExpression_CreatesSqlGroupingReferenceExpression_ForSqlGroupingSelectExpression ()
{
var groupingSelectExpression = new SqlGroupingSelectExpression (
SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), "key"),
new NamedExpression ("element", Expression.Constant (0)),
new[] { new NamedExpression ("a0", Expression.Constant (1)) });
var sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook)))
{
SelectProjection = groupingSelectExpression,
DataInfo = new StreamedSequenceInfo (typeof (IGrouping<int, int>[]), Expression.Constant (null, typeof (IGrouping<int, int>)))
}.GetSqlStatement ();
var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement);
var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner);
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (groupingSelectExpression, tableInfo, sqlTable, _context);
Assert.That (result, Is.TypeOf (typeof (SqlGroupingSelectExpression)));
var referencedKeyExpression = ((SqlGroupingSelectExpression) result).KeyExpression;
var expectedReferencedKeyExpression = new NamedExpression("key", new SqlEntityReferenceExpression (
typeof (Cook),
"q0",
null,
(SqlEntityExpression) groupingSelectExpression.KeyExpression));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedKeyExpression, referencedKeyExpression);
var referencedElementExpression = ((SqlGroupingSelectExpression) result).ElementExpression;
var expectedReferencedElementExpression = new NamedExpression("element", new SqlColumnDefinitionExpression (typeof (int), "q0", "element", false));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedElementExpression, referencedElementExpression);
Assert.That (((SqlGroupingSelectExpression) result).AggregationExpressions.Count, Is.EqualTo (1));
var referencedAggregationExpression = ((SqlGroupingSelectExpression) result).AggregationExpressions[0];
var expectedReferencedAggregationExpression = new NamedExpression("a0", new SqlColumnDefinitionExpression (typeof (int), "q0", "a0", false));
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedAggregationExpression, referencedAggregationExpression);
Assert.That (_context.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable));
}
public void VisitNamedExpression ()
{
var innerExpression = Expression.Constant (0);
var namedExpression = new NamedExpression ("Name", innerExpression);
var fakeResolvedInnerExpression = new SqlLiteralExpression (1);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (innerExpression)).Return (fakeResolvedInnerExpression);
var fakeCombinedExpression = new NamedExpression ("Name2", Expression.Constant (2));
_namedExpressionCombinerMock
.Expect (mock => mock.ProcessNames (Arg<NamedExpression>.Matches (e => e.Name == "Name" && e.Expression == fakeResolvedInnerExpression)))
.Return (fakeCombinedExpression);
// Result is revisited.
var fakeResolvedInnerExpression2 = new SqlLiteralExpression (3);
_resolverMock
.Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeCombinedExpression.Expression))
.Return (fakeResolvedInnerExpression2);
_namedExpressionCombinerMock
.Expect (mock => mock.ProcessNames (Arg<NamedExpression>.Matches (e => e.Name == "Name2" && e.Expression == fakeResolvedInnerExpression2)))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
var result = _visitor.VisitExpression (namedExpression);
_resolverMock.VerifyAllExpectations ();
_namedExpressionCombinerMock.VerifyAllExpectations ();
Assert.That (result, Is.TypeOf<NamedExpression> ());
Assert.That (((NamedExpression) result).Name, Is.EqualTo ("Name2"));
Assert.That (((NamedExpression) result).Expression, Is.SameAs (fakeResolvedInnerExpression2));
}
public void ProcessNames_Convert_WithMethod ()
{
var convertMethod = typeof (Convert).GetMethod ("ToDouble", new[] { typeof (int) });
var namedExpression = new NamedExpression (
"outer",
Expression.Convert (
new NamedExpression (
"inner",
Expression.Constant (1)),
typeof (double),
convertMethod));
var result = _namedExpressionCombiner.ProcessNames (namedExpression);
var expectedResult = Expression.Convert (new NamedExpression ("outer_inner", Expression.Constant (1)), typeof (double), convertMethod);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result);
}
