public void Initialization_Typed ()
{
var intExpression = new SqlLiteralExpression (10);
Assert.That (intExpression.Value, Is.EqualTo (10));
Assert.That (intExpression.Type, Is.EqualTo (typeof (int)));
var nullableIntExpression = new SqlLiteralExpression (10, true);
Assert.That (nullableIntExpression.Value, Is.EqualTo (10));
Assert.That (nullableIntExpression.Type, Is.EqualTo (typeof (int?)));
var longExpression = new SqlLiteralExpression (10L);
Assert.That (longExpression.Value, Is.EqualTo (10L));
Assert.That (longExpression.Type, Is.EqualTo (typeof (long)));
var nullableLongExpression = new SqlLiteralExpression (10L, true);
Assert.That (nullableLongExpression.Value, Is.EqualTo (10L));
Assert.That (nullableLongExpression.Type, Is.EqualTo (typeof (long?)));
var stringExpression = new SqlLiteralExpression ("a");
Assert.That (stringExpression.Value, Is.EqualTo ("a"));
Assert.That (stringExpression.Type, Is.EqualTo (typeof (string)));
Assert.That (() => new SqlLiteralExpression (null), Throws.TypeOf<ArgumentNullException>());
var doubleExpression = new SqlLiteralExpression (10.12);
Assert.That (doubleExpression.Value, Is.EqualTo (10.12));
Assert.That (doubleExpression.Type, Is.EqualTo (typeof (double)));
var nullableDoubleExpression = new SqlLiteralExpression (10.12, true);
Assert.That (nullableDoubleExpression.Value, Is.EqualTo (10.12));
Assert.That (nullableDoubleExpression.Type, Is.EqualTo (typeof (double?)));
}
public void SetUp ()
{
var leftExpression = Expression.Constant ("left");
var rightExpression = Expression.Constant ("right");
var escapeExpression = new SqlLiteralExpression (@"\");
_likeExpression = new SqlLikeExpression (leftExpression, rightExpression, escapeExpression);
}
public void SetUp ()
{
var item1 = new SqlLiteralExpression (13);
var item2 = Expression.Constant (12);
_items = new Expression[] { item1, item2 };
_collectionExpression = new SqlCollectionExpression (typeof (List<int>), _items);
}
public void VisitBinaryExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges ()
{
var left = Expression.Constant (0);
var right = Expression.Constant (1);
var binary = Expression.Equal (left, right);
var fakeResolvedLeft = new SqlLiteralExpression (2);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (left)).Return (fakeResolvedLeft);
var fakeResolvedRight = new SqlLiteralExpression (3);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (right)).Return (fakeResolvedRight);
_entityIdentityResolverMock
.Expect (mock => mock.ResolvePotentialEntityComparison (Arg<BinaryExpression>.Is.Anything))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
_compoundComparisonSplitterMock
.Expect (mock => mock.SplitPotentialCompoundComparison (Arg<BinaryExpression>.Is.Anything))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
// No revisiting
var result = _visitor.VisitExpression (binary);
_resolverMock.VerifyAllExpectations ();
_entityIdentityResolverMock.VerifyAllExpectations ();
_compoundComparisonSplitterMock.VerifyAllExpectations ();
Assert.That (result, Is.AssignableTo<BinaryExpression> ());
Assert.That (((BinaryExpression) result).Left, Is.SameAs (fakeResolvedLeft));
Assert.That (((BinaryExpression) result).Right, Is.SameAs (fakeResolvedRight));
}
public void VisitBinaryExpression()
{
var left = Expression.Constant (0);
var right = Expression.Constant (1);
var binary = Expression.Equal (left, right);
var fakeResolvedLeft = new SqlLiteralExpression (2);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (left)).Return (fakeResolvedLeft);
var fakeResolvedRight = new SqlLiteralExpression (3);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (right)).Return (fakeResolvedRight);
var fakeResolvedEntityComparison = Expression.Equal (Expression.Constant (2), Expression.Constant (3));
_entityIdentityResolverMock
.Expect (
mock => mock.ResolvePotentialEntityComparison (
Arg<BinaryExpression>.Matches (e => e.Left == fakeResolvedLeft && e.Right == fakeResolvedRight)))
.Return (fakeResolvedEntityComparison);
var fakeSplitComparison = Expression.Equal (Expression.Constant (4), Expression.Constant (5));
_compoundComparisonSplitterMock
.Expect (mock => mock.SplitPotentialCompoundComparison (fakeResolvedEntityComparison))
.Return (fakeSplitComparison);
// Result is revisited
_resolverMock.Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeSplitComparison.Left)).Return (fakeSplitComparison.Left);
_resolverMock.Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeSplitComparison.Right)).Return (fakeSplitComparison.Right);
_entityIdentityResolverMock.Expect (mock => mock.ResolvePotentialEntityComparison (fakeSplitComparison)).Return (fakeSplitComparison);
_compoundComparisonSplitterMock.Expect (mock => mock.SplitPotentialCompoundComparison (fakeSplitComparison)).Return (fakeSplitComparison);
var result = _visitor.VisitExpression (binary);
_resolverMock.VerifyAllExpectations();
_entityIdentityResolverMock.VerifyAllExpectations();
_compoundComparisonSplitterMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (fakeSplitComparison));
}
public void SetUp ()
{
_literalExpression = new SqlLiteralExpression (10);
}
public void ConvertToSqlTable_StreamedSingleValueInfo_NoSqlTables ()
{
var selectProjection = Expression.Constant (new Cook ());
var topExpression = new SqlLiteralExpression (2);
var sqlStatement =
new SqlStatementBuilder
{
DataInfo = new StreamedSingleValueInfo (typeof (Cook), false),
SelectProjection = selectProjection,
TopExpression = topExpression
}.GetSqlStatement ();
var expression = new SqlSubStatementExpression (sqlStatement);
var result = expression.ConvertToSqlTable ("q0");
Assert.That (result.JoinSemantics, Is.EqualTo (JoinSemantics.Inner));
Assert.That (result.TableInfo.GetResolvedTableInfo ().TableAlias, Is.EqualTo ("q0"));
Assert.That (result.TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo)));
var newSubStatement = ((ResolvedSubStatementTableInfo) result.TableInfo).SqlStatement;
Assert.That (newSubStatement.TopExpression, Is.SameAs (topExpression));
}
public void VisitSqlIsNotNullExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges ()
{
var inner = Expression.Constant (0);
var isNotNullExpression = new SqlIsNotNullExpression (inner);
var fakeResolvedInner = new SqlLiteralExpression (1);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (inner)).Return (fakeResolvedInner);
_entityIdentityResolverMock
.Expect (mock => mock.ResolvePotentialEntityComparison (Arg<SqlIsNotNullExpression>.Is.Anything))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
_compoundComparisonSplitterMock
.Expect (mock => mock.SplitPotentialCompoundComparison (Arg<SqlIsNotNullExpression>.Is.Anything))
.Return (null)
.WhenCalled (mi => mi.ReturnValue = mi.Arguments[0]);
// No revisiting
var result = _visitor.VisitExpression (isNotNullExpression);
_resolverMock.VerifyAllExpectations ();
_entityIdentityResolverMock.VerifyAllExpectations ();
_compoundComparisonSplitterMock.VerifyAllExpectations ();
Assert.That (result, Is.TypeOf<SqlIsNotNullExpression> ());
Assert.That (((SqlIsNotNullExpression) result).Expression, Is.SameAs (fakeResolvedInner));
}
public void VisitSqlInExpression ()
{
var left = Expression.Constant (0);
var right = Expression.Constant (1);
var inExpression = new SqlInExpression (left, right);
var fakeResolvedLeft = new SqlLiteralExpression (2);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (left)).Return (fakeResolvedLeft);
var fakeResolvedRight = new SqlLiteralExpression (3);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (right)).Return (fakeResolvedRight);
var fakeResolvedInExpression = new SqlInExpression (Expression.Constant (4), Expression.Constant (5));
_entityIdentityResolverMock
.Expect (
mock => mock.ResolvePotentialEntityComparison (
Arg<SqlInExpression>.Matches (e => e.LeftExpression == fakeResolvedLeft && e.RightExpression == fakeResolvedRight)))
.Return (fakeResolvedInExpression);
// Result is revisited
_resolverMock
.Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeResolvedInExpression.LeftExpression))
.Return (fakeResolvedInExpression.LeftExpression);
_resolverMock
.Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeResolvedInExpression.RightExpression))
.Return (fakeResolvedInExpression.RightExpression);
_entityIdentityResolverMock
.Expect (mock => mock.ResolvePotentialEntityComparison (fakeResolvedInExpression))
.Return (fakeResolvedInExpression);
var result = _visitor.VisitExpression (inExpression);
_resolverMock.VerifyAllExpectations ();
_entityIdentityResolverMock.VerifyAllExpectations ();
Assert.That (result, Is.SameAs (fakeResolvedInExpression));
}
public void VisitSqlExistsExpression ()
{
var inner = Expression.Constant (0);
var existsExpression = new SqlExistsExpression (inner);
var fakeResolvedInner = new SqlLiteralExpression (1);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (inner)).Return (fakeResolvedInner);
var fakeResolvedEntityIdentity = Expression.Constant (1);
_entityIdentityResolverMock
.Expect (mock => mock.ResolvePotentialEntity (fakeResolvedInner))
.Return (fakeResolvedEntityIdentity);
// Result is revisited
_resolverMock.Expect (mock => mock.ResolveConstantExpression (fakeResolvedEntityIdentity)).Return (fakeResolvedEntityIdentity);
_entityIdentityResolverMock.Expect (mock => mock.ResolvePotentialEntity (fakeResolvedEntityIdentity)).Return (fakeResolvedEntityIdentity);
var result = _visitor.VisitExpression (existsExpression);
_resolverMock.VerifyAllExpectations ();
_entityIdentityResolverMock.VerifyAllExpectations ();
Assert.That (result, Is.TypeOf<SqlExistsExpression>());
Assert.That (((SqlExistsExpression) result).Expression, Is.SameAs (fakeResolvedEntityIdentity));
}
public void VisitSqlLiteralExpression_Empty ()
{
var expression = new SqlLiteralExpression ("");
SqlGeneratingExpressionVisitor.GenerateSql (
expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("''"));
}
public void VisitSqlLiteralExpression_Double_CultureAgnostic ()
{
var expression = new SqlLiteralExpression (1.1);
Assert.That (expression.Value.ToString(), Is.Not.EqualTo ("1.1"));
SqlGeneratingExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("1.1"));
}
public void VisitLiteralExpression ()
{
var expression = new SqlLiteralExpression (5);
SqlGeneratingExpressionVisitor.GenerateSql (expression, _commandBuilder, _stageMock);
Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("5"));
Assert.That (_commandBuilder.GetCommandParameters(), Is.Empty);
}
public void VisitSqlLiteralExpression ()
{
var expression = new SqlLiteralExpression (1);
var result = _predicateRequiredVisitor.VisitSqlLiteralExpression (expression);
Assert.That (result, Is.SameAs (expression));
}
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 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 ResolveMemberAccess ()
{
var sourceExpression = new SqlColumnDefinitionExpression (typeof (Cook), "c", "Substitution", false);
var memberInfo = typeof (Cook).GetProperty ("Name");
var fakeResolvedExpression = new SqlLiteralExpression ("Hugo");
_resolverMock
.Expect (mock => mock.ResolveMemberExpression (sourceExpression, memberInfo))
.Return (fakeResolvedExpression);
_resolverMock.Replay();
var result = _stage.ResolveMemberAccess (sourceExpression, memberInfo, _resolverMock, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (fakeResolvedExpression));
}
public void VisitSqlExistsExpression_RevisitingTerminatesAfterInnerChanges_WithoutOuterChanges ()
{
var inner = Expression.Constant (0);
var existsExpression = new SqlExistsExpression (inner);
var fakeResolvedInner = new SqlLiteralExpression (1);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (inner)).Return (fakeResolvedInner);
_entityIdentityResolverMock
.Expect (mock => mock.ResolvePotentialEntity (fakeResolvedInner))
.Return (fakeResolvedInner);
// No revisiting!
var result = _visitor.VisitExpression (existsExpression);
_resolverMock.VerifyAllExpectations ();
_entityIdentityResolverMock.VerifyAllExpectations ();
Assert.That (result, Is.TypeOf<SqlExistsExpression> ());
Assert.That (((SqlExistsExpression) result).Expression, Is.SameAs (fakeResolvedInner));
}
public void VisitMemberExpression ()
{
var memberInfo = typeof (Cook).GetProperty ("ID");
var expression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
var memberExpression = Expression.MakeMemberAccess (expression, memberInfo);
var fakeResolvedExpression = new SqlLiteralExpression (1);
_stageMock
.Expect (mock => mock.ResolveMemberAccess (expression, memberInfo, _resolverMock, _mappingResolutionContext))
.Return (fakeResolvedExpression);
_stageMock.Replay();
var result = ResolvingExpressionVisitor.ResolveExpression (memberExpression, _resolverMock, _stageMock, _mappingResolutionContext, _generator);
_stageMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (fakeResolvedExpression));
}
public void VisitSqlIsNotNullExpression ()
{
var inner = Expression.Constant (0);
var isNotNullExpression = new SqlIsNotNullExpression (inner);
var fakeResolvedInner = new SqlLiteralExpression (1);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (inner)).Return (fakeResolvedInner);
var fakeResolvedEntityComparison = new SqlIsNotNullExpression (Expression.Constant (2));
_entityIdentityResolverMock
.Expect (mock => mock.ResolvePotentialEntityComparison (Arg<SqlIsNotNullExpression>.Matches (e => e.Expression == fakeResolvedInner)))
.Return (fakeResolvedEntityComparison);
var fakeSplitCompoundComparison = new SqlIsNotNullExpression (Expression.Constant (3));
_compoundComparisonSplitterMock
.Expect (mock => mock.SplitPotentialCompoundComparison (fakeResolvedEntityComparison))
.Return (fakeSplitCompoundComparison);
// Result is revisited
_resolverMock
.Expect (mock => mock.ResolveConstantExpression ((ConstantExpression) fakeSplitCompoundComparison.Expression))
.Return (fakeSplitCompoundComparison.Expression);
_entityIdentityResolverMock
.Expect (mock => mock.ResolvePotentialEntityComparison (fakeSplitCompoundComparison))
.Return (fakeSplitCompoundComparison);
_compoundComparisonSplitterMock
.Expect (mock => mock.SplitPotentialCompoundComparison (fakeSplitCompoundComparison))
.Return (fakeSplitCompoundComparison);
var result = _visitor.VisitExpression (isNotNullExpression);
_resolverMock.VerifyAllExpectations ();
_entityIdentityResolverMock.VerifyAllExpectations ();
_compoundComparisonSplitterMock.VerifyAllExpectations ();
Assert.That (result, Is.SameAs (fakeSplitCompoundComparison));
}
public void VisitMemberExpression_ResolvesSourceExpression ()
{
var memberInfo = typeof (Cook).GetProperty ("ID");
var expression = Expression.Constant (null, typeof (Cook));
var memberExpression = Expression.MakeMemberAccess (expression, memberInfo);
var fakeResolvedSourceExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
_resolverMock
.Expect (mock => mock.ResolveConstantExpression (expression))
.Return (fakeResolvedSourceExpression);
_resolverMock.Replay();
var fakeResolvedExpression = new SqlLiteralExpression (1);
_stageMock
.Expect (mock => mock.ResolveMemberAccess (fakeResolvedSourceExpression, memberInfo, _resolverMock, _mappingResolutionContext))
.Return (fakeResolvedExpression);
_stageMock.Replay();
_visitor.VisitExpression (memberExpression);
_resolverMock.VerifyAllExpectations();
_stageMock.VerifyAllExpectations();
}
public Expression VisitSqlLiteralExpression (SqlLiteralExpression expression)
{
// No children.
return expression;
}
public void VisitMemberExpression_RevisitsResult ()
{
var memberInfo = typeof (Cook).GetProperty ("ID");
var expression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
var memberExpression = Expression.MakeMemberAccess (expression, memberInfo);
var fakeResult1 = Expression.Constant (1);
var fakeResult2 = new SqlLiteralExpression (7);
_stageMock
.Expect (mock => mock.ResolveMemberAccess (expression, memberInfo, _resolverMock, _mappingResolutionContext))
.Return (fakeResult1);
_resolverMock
.Expect (mock => mock.ResolveConstantExpression (fakeResult1))
.Return (fakeResult2);
var result = _visitor.VisitExpression (memberExpression);
_stageMock.VerifyAllExpectations();
_resolverMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (fakeResult2));
}
public void VisitTypeBinaryExpression ()
{
var expression = Expression.Constant ("select");
var typeBinaryExpression = Expression.TypeIs (expression, typeof (Chef));
var resolvedTypeExpression = Expression.Constant ("resolved");
var resolvedRevisitedResult = new SqlLiteralExpression (0);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (expression))
.Return (expression);
_resolverMock.Expect (mock => mock.ResolveTypeCheck (expression, typeof (Chef)))
.Return (resolvedTypeExpression);
_resolverMock.Expect (mock => mock.ResolveConstantExpression (resolvedTypeExpression))
.Return (resolvedRevisitedResult);
_resolverMock.Replay();
var result = _visitor.VisitExpression (typeBinaryExpression);
_resolverMock.VerifyAllExpectations();
Assert.That (result, Is.SameAs (resolvedRevisitedResult));
}
public void ToString_String ()
{
var literalExpression = new SqlLiteralExpression ("test");
Assert.That (literalExpression.ToString (), Is.EqualTo ("\"test\""));
}
