public void CreateSqlTableForSubStatement_WithoutOrderings()
{
var statementWithoutOrderings = SqlStatementModelObjectMother.CreateSqlStatementWithCook();
var result = _factory.CreateSqlTableForStatement(
statementWithoutOrderings,
info => new SqlTable(info, JoinSemantics.Inner),
OrderingExtractionPolicy.ExtractOrderingsIntoProjection);
_stageMock.VerifyAllExpectations();
var tableInfo = result.SqlTable.TableInfo;
Assert.That(tableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var subStatement = ((ResolvedSubStatementTableInfo)tableInfo).SqlStatement;
Assert.That(subStatement, Is.SameAs(statementWithoutOrderings));
Assert.That(result.WhereCondition, Is.Null);
Assert.That(result.ExtractedOrderings, Is.Empty);
var expectedItemSelector = new SqlTableReferenceExpression(result.SqlTable);
SqlExpressionTreeComparer.CheckAreEqualTrees(expectedItemSelector, result.ItemSelector);
}
public void CreateSqlTableForSubStatement_WithOrderings_WithTopExpression()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
TopExpression = Expression.Constant("top"),
Orderings = { new Ordering(Expression.Constant("order1"), OrderingDirection.Asc) }
};
var statement = builder.GetSqlStatement();
var fakeSelectProjection = Expression.Constant(new KeyValuePair <Cook, string> ());
_stageMock
.Expect(mock => mock.PrepareSelectExpression(Arg <Expression> .Is.Anything, Arg <ISqlPreparationContext> .Matches(c => c == _context)))
.Return(fakeSelectProjection);
_stageMock.Replay();
var result = _factory.CreateSqlTableForStatement(statement, info => new SqlTable(info, JoinSemantics.Inner));
_stageMock.VerifyAllExpectations();
var sqlTable = (SqlTable)result.SqlTable;
Assert.That(sqlTable.TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
Assert.That(((ResolvedSubStatementTableInfo)sqlTable.TableInfo).SqlStatement.Orderings.Count, Is.EqualTo(1));
Assert.That(result.ExtractedOrderings.Count, Is.EqualTo(1));
}
public void CreateSqlTableForSubStatement_WithOrderingsAndTopExpression_AndDoNotExtractOrderingsPolicy_ReturnsTableWithOrderings_WithOriginalProjection()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
TopExpression = Expression.Constant("top"),
Orderings = { new Ordering(Expression.Constant("order1"), OrderingDirection.Asc) }
};
var statementWithOrderingsAndTopExpression = builder.GetSqlStatement();
var result = _factory.CreateSqlTableForStatement(
statementWithOrderingsAndTopExpression,
info => new SqlTable(info, JoinSemantics.Inner),
OrderingExtractionPolicy.DoNotExtractOrderings);
_stageMock.VerifyAllExpectations();
Assert.That(result.ExtractedOrderings, Is.Empty);
var tableInfo = result.SqlTable.TableInfo;
Assert.That(tableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
var subStatement = ((ResolvedSubStatementTableInfo)tableInfo).SqlStatement;
Assert.That(subStatement.Orderings, Is.Not.Empty);
Assert.That(subStatement.SelectProjection, Is.SameAs(statementWithOrderingsAndTopExpression.SelectProjection));
}
public void VisitSqlSubStatementExpression_WithOrderingsAndNoTopExpression()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
SelectProjection = new NamedExpression("test", Expression.Constant("test")),
Orderings = { new Ordering(Expression.Constant("order1"), OrderingDirection.Asc) }
};
var statement = builder.GetSqlStatement();
var sqlSubStatementExpression = new SqlSubStatementExpression(statement);
var stage = new DefaultSqlPreparationStage(_methodCallTransformerProvider, new ResultOperatorHandlerRegistry(), _generator);
var result = SqlPreparationFromExpressionVisitor.AnalyzeFromExpression(
sqlSubStatementExpression,
stage,
_generator,
_methodCallTransformerProvider,
_context,
info => new SqlTable(info, JoinSemantics.Inner));
var sqlTable = (SqlTable)result.SqlTable;
Assert.That(sqlTable.TableInfo, Is.TypeOf(typeof(ResolvedSubStatementTableInfo)));
Assert.That(((ResolvedSubStatementTableInfo)sqlTable.TableInfo).SqlStatement.Orderings.Count, Is.EqualTo(0));
}
public void SetUp()
{
_generator = new UniqueIdentifierGenerator();
_stageMock = new DefaultSqlPreparationStage(
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
_handler = new OfTypeResultOperatorHandler();
_sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook());
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
}
public override void SetUp()
{
base.SetUp();
_stage = CreateDefaultSqlPreparationStage();
_handler = new OfTypeResultOperatorHandler();
_sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook());
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
}
public void ApplySelectionContext_SqlStatement()
{
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
SelectProjection = Expression.Constant(true)
}.GetSqlStatement();
var result = _stage.ApplySelectionContext(sqlStatement, SqlExpressionContext.SingleValueRequired, _mappingResolutionContext);
Assert.That(result, Is.Not.SameAs(sqlStatement));
Assert.That(result.SelectProjection, Is.TypeOf(typeof(SqlConvertedBooleanExpression)));
}
public void VisitSqlSubStatmentExpression_NoTopExpression_ReturnsSame()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook());
builder.Orderings.Clear();
var sqlStatement = builder.GetSqlStatement();
var subStatementExpression = new SqlSubStatementExpression(sqlStatement);
var result = SqlPreparationExpressionVisitor.TranslateExpression(subStatementExpression, _context, _stageMock, _methodCallTransformerProvider);
Assert.That(result, Is.SameAs(subStatementExpression));
}
public void VisitSqlStatement_NoExpressionChanged_SameSqlStatementIsReturned()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatementWithCook();
_stageMock
.Expect(mock => mock.ApplyContext(sqlStatement.SelectProjection, SqlExpressionContext.ValueRequired, _mappingResolutionContext))
.Return(sqlStatement.SelectProjection);
_stageMock.Replay();
var result = SqlContextSelectionAdjuster.ApplyContext(sqlStatement, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result.SelectProjection, Is.TypeOf(typeof(SqlTableReferenceExpression)));
Assert.That(result.DataInfo, Is.SameAs(sqlStatement.DataInfo));
}
public void VisitSqlStatement_CopiesIsDistinctQueryFlag()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
IsDistinctQuery = true
};
var sqlStatement = builder.GetSqlStatement();
_stageMock
.Expect(mock => mock.ApplyContext(sqlStatement.SelectProjection, SqlExpressionContext.ValueRequired, _mappingResolutionContext))
.Return(sqlStatement.SelectProjection);
_stageMock.Replay();
var result = SqlContextSelectionAdjuster.ApplyContext(sqlStatement, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result.IsDistinctQuery, Is.True);
}
public void VisitSqlSubStatmentExpression_HasTopExpression_ReturnsNew()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook());
builder.Orderings.Add(new Ordering(Expression.Constant("order"), OrderingDirection.Asc));
var sqlStatement = builder.GetSqlStatement();
builder.Orderings.Clear();
var expectedStatement = builder.GetSqlStatement();
var subStatementExpression = new SqlSubStatementExpression(sqlStatement);
var result = SqlPreparationExpressionVisitor.TranslateExpression(subStatementExpression, _context, _stageMock, _methodCallTransformerProvider);
Assert.That(result, Is.Not.SameAs(subStatementExpression));
Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression)));
Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.EqualTo(expectedStatement));
}
public void ResolveTableInfo_SubStatementTableInfo_SubStatementModified()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatementWithCook();
var sqlSubStatementTableInfo = new ResolvedSubStatementTableInfo("c", sqlStatement);
_stageMock
.Expect(mock => mock.ResolveSqlStatement(sqlStatement, _mappingResolutionContext))
.Return(_sqlStatement);
_resolverMock.Replay();
var result = (ResolvedSubStatementTableInfo)ResolvingTableInfoVisitor.ResolveTableInfo(sqlSubStatementTableInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(sqlSubStatementTableInfo));
Assert.That(result.SqlStatement, Is.SameAs(_sqlStatement));
Assert.That(result.TableAlias, Is.EqualTo(sqlSubStatementTableInfo.TableAlias));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateStrictMock <ISqlPreparationStage>();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_generator = new UniqueIdentifierGenerator();
_factory = new SqlPreparationSubStatementTableFactory(_stageMock, _context, _generator);
var builderForStatementWithOrderings = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
Orderings =
{
new Ordering(Expression.Constant("order1"), OrderingDirection.Desc),
new Ordering(Expression.Constant("order2"), OrderingDirection.Asc),
}
};
_statementWithOrderings = builderForStatementWithOrderings.GetSqlStatement();
}
public void VisitSqlSubStatementExpression()
{
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
SelectProjection = new NamedExpression("test", Expression.Constant("test"))
}.GetSqlStatement();
var sqlSubStatementExpression = new SqlSubStatementExpression(sqlStatement);
var stage = new DefaultSqlPreparationStage(_methodCallTransformerProvider, new ResultOperatorHandlerRegistry(), _generator);
var result = SqlPreparationFromExpressionVisitor.AnalyzeFromExpression(
sqlSubStatementExpression,
stage,
_generator,
_methodCallTransformerProvider,
_context,
info => new SqlTable(info, JoinSemantics.Inner));
Assert.That(((SqlTable)result.SqlTable).TableInfo, Is.InstanceOf(typeof(ResolvedSubStatementTableInfo)));
}
public void VisitSqlInExpression()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatementWithCook();
var sqlSubStatementExpression = new SqlSubStatementExpression(sqlStatement);
var sqlInExpression = new SqlInExpression(Expression.Constant(1), sqlSubStatementExpression);
_stageMock
.Expect(
mock =>
mock.GenerateTextForSqlStatement(
Arg.Is(_commandBuilder), Arg <SqlStatement> .Is.Anything))
.WhenCalled(mi => ((SqlCommandBuilder)mi.Arguments[0]).Append("test"));
_stageMock.Replay();
SqlGeneratingExpressionVisitor.GenerateSql(
sqlInExpression, _commandBuilder, _stageMock);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("@1 IN (test)"));
_stageMock.VerifyAllExpectations();
}
public void VisitSqlSubStatementExpression_WithNonBooleanSqlGroupingSelectExpression()
{
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
SelectProjection =
new NamedExpression(
"test", new SqlGroupingSelectExpression(Expression.Constant("key"), Expression.Constant("element")))
}.GetSqlStatement();
var sqlSubStatementExpression = new SqlSubStatementExpression(sqlStatement);
var stage = new DefaultSqlPreparationStage(_methodCallTransformerProvider, new ResultOperatorHandlerRegistry(), _generator);
var result = SqlPreparationFromExpressionVisitor.AnalyzeFromExpression(
sqlSubStatementExpression,
stage,
_generator,
_methodCallTransformerProvider,
_context,
_tableGenerator,
_someOrderingExtractionPolicy);
Assert.That(result.SqlTable.TableInfo, Is.InstanceOf(typeof(ResolvedSubStatementTableInfo)));
}
public void VisitSqlStatement_ExpressionsAndStreamedSequenceDataTypeChanged()
{
var builder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook());
builder.DataInfo = new StreamedSequenceInfo(typeof(IQueryable <>).MakeGenericType(builder.SelectProjection.Type), builder.SelectProjection);
var sqlStatement = builder.GetSqlStatement();
var fakeResult = Expression.Constant("test");
_stageMock
.Expect(mock => mock.ApplyContext(sqlStatement.SelectProjection, SqlExpressionContext.ValueRequired, _mappingResolutionContext))
.Return(fakeResult);
_stageMock.Replay();
var result = SqlContextSelectionAdjuster.ApplyContext(sqlStatement, SqlExpressionContext.ValueRequired, _stageMock, _mappingResolutionContext);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.Not.SameAs(sqlStatement));
Assert.That(result.SelectProjection, Is.SameAs(fakeResult));
Assert.That(result.DataInfo, Is.TypeOf(typeof(StreamedSequenceInfo)));
Assert.That(((StreamedSequenceInfo)result.DataInfo).ResultItemType, Is.EqualTo(typeof(string)));
Assert.That(result.DataInfo.DataType, Is.EqualTo(typeof(IQueryable <>).MakeGenericType(fakeResult.Type)));
}
public void VisitSqlSubStatementExpression_WithDoNotExtractOrderingsPolicy()
{
var sqlStatement = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatementWithCook())
{
SelectProjection = new NamedExpression("test", Expression.Constant("test")),
Orderings = { SqlStatementModelObjectMother.CreateOrdering() }
}.GetSqlStatement();
var sqlSubStatementExpression = new SqlSubStatementExpression(sqlStatement);
var stage = new DefaultSqlPreparationStage(_methodCallTransformerProvider, new ResultOperatorHandlerRegistry(), _generator);
var result = SqlPreparationFromExpressionVisitor.AnalyzeFromExpression(
sqlSubStatementExpression,
stage,
_generator,
_methodCallTransformerProvider,
_context,
_tableGenerator,
OrderingExtractionPolicy.DoNotExtractOrderings);
Assert.That(result.SqlTable.TableInfo, Is.InstanceOf(typeof(ResolvedSubStatementTableInfo)));
Assert.That(((ResolvedSubStatementTableInfo)result.SqlTable.TableInfo).SqlStatement.Orderings.Count, Is.EqualTo(0));
Assert.That(result.ExtractedOrderings, Is.Empty);
}
public void VisitSqlStatement_PrdicateRequired_ThrowsException()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatementWithCook();
SqlContextSelectionAdjuster.ApplyContext(sqlStatement, SqlExpressionContext.PredicateRequired, _stageMock, _mappingResolutionContext);
}
