private SqlCommandData GenerateSqlCommand(QueryModel queryModel)
{
ISqlPreparationContext preparationContext = new SqlPreparationContext(new SqlStatementBuilder());
IMappingResolutionContext mappingResolutionContext = new MappingResolutionContext();
var generator = new UniqueIdentifierGenerator();
var preparationStage = new DefaultSqlPreparationStage(_methodCallTransformerProvider, _resultOperatorHandlerRegistry, generator);
var preparedStatement = preparationStage.PrepareSqlStatement(queryModel, preparationContext);
var resolutionStage = new DefaultMappingResolutionStage(_mappingResolver, generator);
var resolvedStatement = resolutionStage.ResolveSqlStatement(preparedStatement, mappingResolutionContext);
var builder = new SqlCommandBuilder();
var generationStage = new DefaultSqlGenerationStage();
generationStage.GenerateTextForOuterSqlStatement(builder, resolvedStatement);
var command = builder.GetCommand();
if (_showQuery)
{
Console.WriteLine(command.CommandText);
Console.WriteLine(string.Join(", ", command.Parameters.Select(p => p.Name + "=" + p.Value)));
Console.WriteLine(command.GetInMemoryProjection <object>());
}
return(command);
}
public void GenerateTextForSelectExpression()
{
var stage = new DefaultSqlGenerationStage();
stage.GenerateTextForSelectExpression(_commandBuilder, _sqlStatement.SelectProjection);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[t].[ID],[t].[Name],[t].[City]"));
}
public void GenerateTextForFromTable()
{
var stage = new DefaultSqlGenerationStage();
stage.GenerateTextForFromTable(_commandBuilder, _sqlStatement.SqlTables[0], true);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[Table] AS [t]"));
}
public void GenerateTextForOrdering()
{
var ordering = new Ordering(Expression.Constant(1), OrderingDirection.Asc);
var stage = new DefaultSqlGenerationStage();
stage.GenerateTextForOrdering(_commandBuilder, ordering);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("(SELECT @1) ASC"));
}
public void GenerateTextForOuterSelectExpression()
{
var stage = new DefaultSqlGenerationStage();
stage.GenerateTextForOuterSelectExpression(_commandBuilder, _sqlStatement.SelectProjection, SetOperationsMode.StatementIsSetCombined);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("[t].[ID],[t].[Name],[t].[City]"));
Assert.That(_commandBuilder.GetInMemoryProjectionBody(), Is.Not.Null);
}
public void GenerateTextForSqlStatement()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(
_entityExpression, new[] { new SqlTable(new ResolvedSimpleTableInfo(typeof(int), "Table", "t"), JoinSemantics.Inner) });
var stage = new DefaultSqlGenerationStage();
stage.GenerateTextForSqlStatement(_commandBuilder, sqlStatement);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t]"));
}
public void GenerateTextForOuterSelectExpression_PassesOnSetOperationsMode()
{
var stage = new DefaultSqlGenerationStage();
var projectionWithMethodCall = Expression.Call(MemberInfoFromExpressionUtility.GetMethod(() => SomeMethod(null)), _sqlStatement.SelectProjection);
Assert.That(
() => stage.GenerateTextForOuterSelectExpression(_commandBuilder, projectionWithMethodCall, SetOperationsMode.StatementIsSetCombined),
Throws.TypeOf <NotSupportedException>());
Assert.That(
() => stage.GenerateTextForOuterSelectExpression(_commandBuilder, projectionWithMethodCall, SetOperationsMode.StatementIsNotSetCombined),
Throws.Nothing);
}
protected SqlCommandData GenerateSql(QueryModel queryModel)
{
var generator = new UniqueIdentifierGenerator();
var resultOperatorHandlerRegistry = ResultOperatorHandlerRegistry.CreateDefault();
var defaultSqlPreparationStage = new DefaultSqlPreparationStage(CompoundMethodCallTransformerProvider.CreateDefault(), resultOperatorHandlerRegistry, generator);
var sqlStatement = defaultSqlPreparationStage.PrepareSqlStatement(queryModel, null);
var resolver = new MappingResolverStub();
var mappingResolutionStage = new DefaultMappingResolutionStage(resolver, generator);
var mappingResolutionContext = new MappingResolutionContext();
var newSqlStatement = mappingResolutionStage.ResolveSqlStatement(sqlStatement, mappingResolutionContext);
var commandBuilder = new SqlCommandBuilder();
var sqlGenerationStage = new DefaultSqlGenerationStage();
sqlGenerationStage.GenerateTextForOuterSqlStatement(commandBuilder, newSqlStatement);
return(commandBuilder.GetCommand());
}
public void GenerateTextForOuterSqlStatement()
{
var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(
_entityExpression, new[] { new SqlTable(new ResolvedSimpleTableInfo(typeof(int), "Table", "t"), JoinSemantics.Inner) });
var stage = new DefaultSqlGenerationStage();
stage.GenerateTextForOuterSqlStatement(_commandBuilder, sqlStatement);
Assert.That(_commandBuilder.GetCommandText(), Is.EqualTo("SELECT [t].[ID],[t].[Name],[t].[City] FROM [Table] AS [t]"));
var inMemoryProjection = _commandBuilder.GetInMemoryProjectionBody();
Assert.That(inMemoryProjection, Is.AssignableTo(typeof(MethodCallExpression)));
var methodCallExpression = (MethodCallExpression)inMemoryProjection;
Assert.That(methodCallExpression.Method, Is.EqualTo((typeof(IDatabaseResultRow).GetMethod("GetEntity").MakeGenericMethod(sqlStatement.SelectProjection.Type))));
Assert.That(methodCallExpression.Arguments.Count, Is.EqualTo(1));
Assert.That(((ColumnID[])((ConstantExpression)methodCallExpression.Arguments[0]).Value)[0].ColumnName, Is.EqualTo("ID"));
Assert.That(((ColumnID[])((ConstantExpression)methodCallExpression.Arguments[0]).Value)[1].ColumnName, Is.EqualTo("Name"));
Assert.That(((ColumnID[])((ConstantExpression)methodCallExpression.Arguments[0]).Value)[2].ColumnName, Is.EqualTo("City"));
}
private void CallGenerateTextForNonSelectExpression(DefaultSqlGenerationStage mock, Expression expression)
{
PrivateInvoke.InvokeNonPublicMethod(mock, "GenerateTextForNonSelectExpression", _commandBuilder, expression);
}
