public void ResolveSubStatementReferenceExpression_CopiesExpression_ForUnknownExpression()
{
var referencedExpression = 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);
Assert.That(result, Is.SameAs(referencedExpression));
}
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 ResolveSubStatementReferenceExpression_RegistersEntityTable_WithinUnknownExpression()
{
var referencedExpression = Expression.Convert(SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook)), typeof(Chef));
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);
Assert.That(result.NodeType, Is.EqualTo(ExpressionType.Convert));
var entityReference = (SqlEntityExpression)((UnaryExpression)result).Operand;
Assert.That(_context.GetSqlTableForEntityExpression(entityReference), Is.SameAs(sqlTable));
}
public void ResolveSubStatementReferenceExpression_CreatesSqlGroupingSelectExpressionWithNamedExpressions()
{
var expression = new SqlGroupingSelectExpression(
Expression.Constant("key"), Expression.Constant("element"), new[] { Expression.Constant("aggregation") });
var tableInfo = new ResolvedSubStatementTableInfo("q0", SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)));
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook));
var exprectedResult = new SqlGroupingSelectExpression(
new NamedExpression("key", Expression.Constant("key")),
new NamedExpression("element", Expression.Constant("element")),
new[] { new NamedExpression("a0", Expression.Constant("aggregation")) });
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(expression, tableInfo, sqlTable, _context);
SqlExpressionTreeComparer.CheckAreEqualTrees(result, exprectedResult);
Assert.That(_context.GetReferencedGroupSource(((SqlGroupingSelectExpression)result)), Is.SameAs(sqlTable));
}
public void ResolveSubStatementReferenceExpression_CreatesNewExpressionWithReferences_ForNewExpressions_WithoutMembers()
{
var newExpression = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new[] { new NamedExpression("const", Expression.Constant(0)) });
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(newExpression);
var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement);
var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner);
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(newExpression, tableInfo, sqlTable, _context);
var expectedResult = Expression.New(
TypeForNewExpression.GetConstructor(typeof(int)),
new Expression[] { new NamedExpression("m0", new SqlColumnDefinitionExpression(typeof(int), "q0", "const", false)) });
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
public void ResolveSubStatementReferenceExpression_CreatesEntityReference_ForEntities()
{
var entityDefinitionExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression(typeof(Cook));
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = entityDefinitionExpression,
DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook()))
}.GetSqlStatement();
var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement);
var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner);
var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(entityDefinitionExpression, tableInfo, sqlTable, _context);
Assert.That(result, Is.TypeOf(typeof(SqlEntityReferenceExpression)));
Assert.That(_context.GetSqlTableForEntityExpression((SqlEntityReferenceExpression)result), Is.SameAs(sqlTable));
var expectedResult = entityDefinitionExpression.CreateReference("q0", tableInfo.SqlStatement.SelectProjection.Type);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result);
}
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 Expression ResolveReference(SqlTableBase sqlTable, IMappingResolver mappingResolver, IMappingResolutionContext context, UniqueIdentifierGenerator generator)
{
var selectProjection = SqlStatement.SelectProjection;
return(SubStatementReferenceResolver.ResolveSubStatementReferenceExpression(selectProjection, this, sqlTable, context));
}
