public void VisitNewExpression_ForObjectID_GeneratesNullCheckInInMemoryProjection()
{
var constructorInfo = typeof(ObjectID).GetConstructor(new[] { typeof(string), typeof(object) });
Assertion.IsNotNull(constructorInfo);
var newObjectIDExpression = Expression.New(
constructorInfo,
new SqlColumnDefinitionExpression(typeof(string), "t0", "CustomerClassID", false),
Expression.Convert(new SqlColumnDefinitionExpression(typeof(Guid), "t0", "CustomerID", false), typeof(object)));
var compoundExpression = NamedExpression.CreateNewExpressionWithNamedArguments(newObjectIDExpression);
ExtendedSqlGeneratingOuterSelectExpressionVisitor.GenerateSql(compoundExpression, _commandBuilder, _stageMock, _someSetOperationsMode);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[t0].[CustomerClassID] AS [m0],[t0].[CustomerID] AS [m1]"));
Expression <Func <IDatabaseResultRow, ObjectID> > expectedInMemoryProjection =
row => ExtendedSqlGeneratingOuterSelectExpressionVisitor.GetObjectIDOrNull(
row.GetValue <string> (new ColumnID("m0", 0)),
row.GetValue <object> (new ColumnID("m1", 1)));
var expectedInMemoryProjectionBody = PartialEvaluatingExpressionVisitor.EvaluateIndependentSubtrees(
expectedInMemoryProjection.Body,
new TestEvaluatableExpressionFilter());
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedInMemoryProjectionBody, _commandBuilder.GetInMemoryProjectionBody());
}
private Expression CreateIdentityExpression(Type entityType, Expression[] primaryKeyValues)
{
Type genericTupleType;
switch (primaryKeyValues.Length)
{
case 0:
throw new NotSupportedException(string.Format("Entities without identity members are not supported by re-linq. ({0})", entityType));
case 1:
return(primaryKeyValues.Single());
case 2:
genericTupleType = typeof(CompoundIdentityTuple <,>);
break;
default:
throw new NotSupportedException(string.Format("Primary keys with more than 2 members are not supported. ({0})", entityType));
}
var ctor = genericTupleType.MakeGenericType(primaryKeyValues.Select(e => e.Type).ToArray()).GetConstructors().Single();
Assertion.DebugAssert(ctor != null);
var tupleConstructionExpression = Expression.New(
ctor,
primaryKeyValues,
ctor.GetParameters().Select((pi, i) => (MemberInfo)ctor.DeclaringType.GetProperty("Item" + (i + 1))));
return(NamedExpression.CreateNewExpressionWithNamedArguments(tupleConstructionExpression));
}
// NewExpressions are referenced by creating a new NewExpression holding references to the original arguments. We need to explicitly name each
// argument reference, otherwise all of them would be called "value"...
protected override Expression VisitNewExpression(NewExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
var resolvedArguments = expression.Arguments.Select(expr => ResolveChildExpression(expr));
return(NamedExpression.CreateNewExpressionWithNamedArguments(expression, resolvedArguments));
}
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));
}
private static Expression CreateMetaIDExpression(Expression valueExpression, Expression classIDColumn)
{
var metaIDCtor = typeof(MetaID).GetConstructor(new[] { typeof(int), typeof(string) });
Trace.Assert(metaIDCtor != null);
var newExpression = Expression.New(metaIDCtor, new[] { valueExpression, classIDColumn }, new[] { typeof(MetaID).GetProperty("Value"), typeof(MetaID).GetProperty("ClassID") });
return(NamedExpression.CreateNewExpressionWithNamedArguments(newExpression));
}
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_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);
}
private static Expression CreateCompoundObjectIDExpression(Expression classIDExpression, Expression valueExpression)
{
var objectIDCtor = typeof(ObjectID).GetConstructor(new[] { typeof(string), typeof(object) });
Assertion.IsNotNull(objectIDCtor);
var valueMember = typeof(ObjectID).GetProperty("Value");
var classIDMember = typeof(ObjectID).GetProperty("ClassID");
var objectIDConstruction = Expression.New(
objectIDCtor,
new[] { classIDExpression, Expression.Convert(valueExpression, typeof(object)) },
new[] { classIDMember, valueMember });
return(NamedExpression.CreateNewExpressionWithNamedArguments(objectIDConstruction));
}
public void CreateNewExpressionWithNamedArguments_DedicatedArguments()
{
var memberInfo = (MemberInfo)typeof(TypeForNewExpression).GetProperty("A");
var originalArgument = ExpressionHelper.CreateExpression(typeof(int));
var expression = Expression.New(TypeForNewExpression.GetConstructor(typeof(int)), new[] { originalArgument }, memberInfo);
var processedArgument = ExpressionHelper.CreateExpression(typeof(int));
var result = NamedExpression.CreateNewExpressionWithNamedArguments(expression, new[] { processedArgument });
var expectedResult = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)), new[] { new NamedExpression("A", processedArgument) }, memberInfo);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void CreateNewExpressionWithNamedArguments_WithPropertyCalledGet()
{
var innerExpression = Expression.Constant(0);
var memberInfo = (MemberInfo)typeof(TypeForNewExpression).GetProperty("get_");
var expression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new[] { innerExpression },
memberInfo);
var result = NamedExpression.CreateNewExpressionWithNamedArguments(expression);
var expectedResult = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)), new[] { new NamedExpression("get_", innerExpression) }, memberInfo);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void GenerateTextForOuterSelectExpression_UsesExtendedVisitor()
{
var constructorInfo = typeof(ObjectID).GetConstructor(new[] { typeof(string), typeof(object) });
Assertion.IsNotNull(constructorInfo);
var newObjectIDExpression = Expression.New(
constructorInfo,
new SqlColumnDefinitionExpression(typeof(string), "t0", "CustomerClassID", false),
Expression.Convert(new SqlColumnDefinitionExpression(typeof(Guid), "t0", "CustomerID", false), typeof(object)));
var compoundExpression = NamedExpression.CreateNewExpressionWithNamedArguments(newObjectIDExpression);
var someSetOperationsMode = SetOperationsMode.StatementIsSetCombined;
_stage.GenerateTextForOuterSelectExpression(_commandBuilder, compoundExpression, someSetOperationsMode);
Assert.That(_commandBuilder.GetInMemoryProjectionBody().NodeType, Is.EqualTo(ExpressionType.Call));
var getObjectIDOrNullMethod =
MemberInfoFromExpressionUtility.GetMethod(() => ExtendedSqlGeneratingOuterSelectExpressionVisitor.GetObjectIDOrNull(null, null));
Assert.That(((MethodCallExpression)_commandBuilder.GetInMemoryProjectionBody()).Method, Is.EqualTo(getObjectIDOrNullMethod));
}
protected override Expression VisitNew(NewExpression expression)
{
ArgumentUtility.CheckNotNull("expression", expression);
return(NamedExpression.CreateNewExpressionWithNamedArguments(expression, expression.Arguments.Select(Visit)));
}
