public void SetUp()
{
_sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = new NamedExpression("test", Expression.Constant(5)),
DataInfo = new StreamedSequenceInfo(typeof(int[]), Expression.Constant(0))
}.GetSqlStatement();
_tableInfo = new ResolvedSubStatementTableInfo("c", _sqlStatement);
}
public void ResolveSqlStatement()
{
var constantExpression = Expression.Constant(new Restaurant());
var whereCondition = Expression.Constant(true);
var topExpression = Expression.Constant("top");
var groupExpression = Expression.Constant("group");
var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Desc);
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = constantExpression,
DataInfo = new StreamedSequenceInfo(typeof(Restaurant[]), constantExpression),
WhereCondition = whereCondition,
GroupByExpression = groupExpression,
TopExpression = topExpression,
};
builder.Orderings.Add(ordering);
var sqlStatement = builder.GetSqlStatement();
var fakeExpression = Expression.Constant(new Cook());
var fakeWhereCondition = Expression.Constant(true);
var fakeGroupExpression = Expression.Constant("group");
var fakeTopExpression = Expression.Constant("top");
var fakeOrderExpression = Expression.Constant("order");
_stageMock
.Expect(mock => mock.ResolveSelectExpression(Arg.Is(constantExpression), Arg <SqlStatementBuilder> .Is.Anything, Arg.Is(_mappingResolutionContext)))
.Return(fakeExpression);
_stageMock
.Expect(mock => mock.ResolveWhereExpression(whereCondition, _mappingResolutionContext))
.Return(fakeWhereCondition);
_stageMock
.Expect(mock => mock.ResolveGroupByExpression(groupExpression, _mappingResolutionContext))
.Return(fakeGroupExpression);
_stageMock
.Expect(mock => mock.ResolveTopExpression(topExpression, _mappingResolutionContext))
.Return(fakeTopExpression);
_stageMock
.Expect(mock => mock.ResolveOrderingExpression(ordering.Expression, _mappingResolutionContext))
.Return(fakeOrderExpression);
_stageMock
.Expect(mock => mock.ResolveTableInfo(((SqlTable)sqlStatement.SqlTables[0]).TableInfo, _mappingResolutionContext))
.Return(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"));
_stageMock.Replay();
var resolveSqlStatement = _visitor.ResolveSqlStatement(sqlStatement);
_stageMock.VerifyAllExpectations();
Assert.That(resolveSqlStatement.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo)));
Assert.That(((StreamedSequenceInfo)resolveSqlStatement.DataInfo).DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(typeof(Cook))));
Assert.That(resolveSqlStatement.SelectProjection, Is.SameAs(fakeExpression));
Assert.That(resolveSqlStatement.WhereCondition, Is.SameAs(fakeWhereCondition));
Assert.That(resolveSqlStatement.TopExpression, Is.SameAs(fakeTopExpression));
Assert.That(resolveSqlStatement.GroupByExpression, Is.SameAs(fakeGroupExpression));
Assert.That(resolveSqlStatement.Orderings[0].Expression, Is.SameAs(fakeOrderExpression));
Assert.That(sqlStatement.Orderings[0].Expression, Is.SameAs(ordering.Expression));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateMock <IMappingResolutionStage>();
_resolverMock = MockRepository.GenerateMock <IMappingResolver>();
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo(typeof(Cook));
_resolvedTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo(typeof(Cook));
_generator = new UniqueIdentifierGenerator();
_sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
_mappingResolutionContext = new MappingResolutionContext();
}
public void Initialization_ItemTypeWithCovariantSubstatement()
{
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = new NamedExpression("test", Expression.Constant(5)),
DataInfo = new StreamedSequenceInfo(typeof(object[]), Expression.Constant(0))
}.GetSqlStatement();
var tableInfo = new ResolvedSubStatementTableInfo("c", sqlStatement);
Assert.That(tableInfo.ItemType, Is.EqualTo(typeof(object)));
}
public void ResolveSqlStatement_WithNoChanges_ShouldLeaveAllObjectsTheSame()
{
var constantExpression = Expression.Constant(new Restaurant());
var whereCondition = Expression.Constant(true);
var topExpression = Expression.Constant("top");
var groupExpression = Expression.Constant("group");
var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Desc);
var setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement();
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = constantExpression,
DataInfo = new StreamedSequenceInfo(typeof(Restaurant[]), constantExpression),
WhereCondition = whereCondition,
GroupByExpression = groupExpression,
TopExpression = topExpression,
SetOperationCombinedStatements = { setOperationCombinedStatement }
};
builder.Orderings.Add(ordering);
var sqlStatement = builder.GetSqlStatement();
_stageMock
.Expect(mock => mock.ResolveSelectExpression(Arg.Is(constantExpression), Arg <SqlStatementBuilder> .Is.Anything, Arg.Is(_mappingResolutionContext)))
.Return(constantExpression);
_stageMock
.Expect(mock => mock.ResolveWhereExpression(whereCondition, _mappingResolutionContext))
.Return(whereCondition);
_stageMock
.Expect(mock => mock.ResolveGroupByExpression(groupExpression, _mappingResolutionContext))
.Return(groupExpression);
_stageMock
.Expect(mock => mock.ResolveTopExpression(topExpression, _mappingResolutionContext))
.Return(topExpression);
_stageMock
.Expect(mock => mock.ResolveOrderingExpression(ordering.Expression, _mappingResolutionContext))
.Return(ordering.Expression);
_stageMock
.Expect(mock => mock.ResolveTableInfo(sqlStatement.SqlTables[0].TableInfo, _mappingResolutionContext))
.Return((IResolvedTableInfo)sqlStatement.SqlTables[0].TableInfo);
_stageMock
.Expect(mock => mock.ResolveSqlStatement(setOperationCombinedStatement.SqlStatement, _mappingResolutionContext))
.Return(setOperationCombinedStatement.SqlStatement);
_stageMock.Replay();
var resolvedSqlStatement = _visitor.ResolveSqlStatement(sqlStatement);
_stageMock.VerifyAllExpectations();
Assert.That(resolvedSqlStatement, Is.EqualTo(sqlStatement));
}
public void ResolveTableInfo()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
var fakeResolvedSubStatementTableInfo = new ResolvedSubStatementTableInfo("c", sqlStatement);
_resolverMock
.Expect(mock => mock.ResolveTableInfo(_unresolvedTableInfo, _uniqueIdentifierGenerator))
.Return(fakeResolvedSubStatementTableInfo);
_resolverMock.Replay();
var result = _stage.ResolveTableInfo(_sqlTable.TableInfo, _mappingResolutionContext);
_resolverMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(fakeResolvedSubStatementTableInfo));
}
public void ApplyContext_ResolvedSubStatementTableInfo_SameTableInfo()
{
var subStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
var subStatementTableInfo = new ResolvedSubStatementTableInfo("c", subStatement);
_stageMock
.Expect(mock => mock.ApplySelectionContext(subStatement, SqlExpressionContext.ValueRequired, _mappingresolutionContext))
.Return(subStatement);
_stageMock.Replay();
var result = SqlContextTableInfoVisitor.ApplyContext(subStatementTableInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext);
Assert.That(result, Is.SameAs(subStatementTableInfo));
_stageMock.VerifyAllExpectations();
}
public void GenerateSql_InnerJoinSemantics_NonFirstTable_SubstatementTableInfo()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement);
var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner);
_stageMock
.Expect(mock => mock.GenerateTextForSqlStatement(_commandBuilder, sqlStatement))
.WhenCalled(mi => ((ISqlCommandBuilder)mi.Arguments[0]).Append("[Table] AS [t]"));
_stageMock.Replay();
SqlTableAndJoinTextGenerator.GenerateSql(sqlTable, _commandBuilder, _stageMock, isFirstTable: false);
_stageMock.VerifyAllExpectations();
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo(" CROSS APPLY ([Table] AS [t]) AS [q0]"));
}
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 VisitSqlSubStatementExpression()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
var subStatementExpression = new SqlSubStatementExpression(sqlStatement);
_stageMock
.Expect(
mock =>
mock.GenerateTextForSqlStatement(_commandBuilder, sqlStatement))
.WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("SELECT [t].[Name] FROM [Table] AS [t]"));
_stageMock.Replay();
SqlGeneratingExpressionVisitor.GenerateSql(subStatementExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("(SELECT [t].[Name] FROM [Table] AS [t])"));
_stageMock.VerifyAllExpectations();
}
public void VisitResolvedJoinedGroupingTableInfo()
{
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook[])))
{
DataInfo = new StreamedSequenceInfo(typeof(IQueryable <Cook>), Expression.Constant(new Cook()))
}.GetSqlStatement();
var resolvedSubTableInfo = SqlStatementModelObjectMother.CreateResolvedJoinedGroupingTableInfo(sqlStatement);
_stageMock
.Expect(mock => mock.GenerateTextForSqlStatement(_commandBuilder, sqlStatement))
.WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("XXX"));
_stageMock.Replay();
_generator.VisitSubStatementTableInfo(resolvedSubTableInfo);
_stageMock.VerifyAllExpectations();
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("(XXX) AS [cook]"));
}
public void ApplyContext_TableInfo()
{
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)))
{
SelectProjection = Expression.Constant(true),
DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook()))
}.GetSqlStatement();
var tableInfo = new ResolvedSubStatementTableInfo("c", sqlStatement);
var result = _stage.ApplyContext(tableInfo, SqlExpressionContext.ValueRequired, _mappingResolutionContext);
Assert.That(result, Is.Not.SameAs(tableInfo));
Assert.That(((ResolvedSubStatementTableInfo)result).SqlStatement.SelectProjection, Is.TypeOf(typeof(SqlConvertedBooleanExpression)));
Assert.That(
((ConstantExpression)((SqlConvertedBooleanExpression)((ResolvedSubStatementTableInfo)result).SqlStatement.SelectProjection).Expression).
Value,
Is.EqualTo(1));
}
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 ApplyContext_ResolvedJoinedGroupingTableInfo_NewTableInfo()
{
var subStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
var joinedGroupingTableInfo = SqlStatementModelObjectMother.CreateResolvedJoinedGroupingTableInfo(subStatement);
var returnedStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
_stageMock
.Expect(mock => mock.ApplySelectionContext(subStatement, SqlExpressionContext.ValueRequired, _mappingresolutionContext))
.Return(returnedStatement);
_stageMock.Replay();
var result = (ResolvedJoinedGroupingTableInfo)SqlContextTableInfoVisitor.ApplyContext(joinedGroupingTableInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(joinedGroupingTableInfo));
Assert.That(result.GroupSourceTableAlias, Is.EqualTo(joinedGroupingTableInfo.GroupSourceTableAlias));
Assert.That(result.AssociatedGroupingSelectExpression, Is.SameAs(joinedGroupingTableInfo.AssociatedGroupingSelectExpression));
Assert.That(result.SqlStatement, Is.SameAs(returnedStatement));
Assert.That(result.TableAlias, Is.EqualTo(joinedGroupingTableInfo.TableAlias));
}
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));
}
