public static FromExpressionInfo AnalyzeFromExpression (
Expression fromExpression,
ISqlPreparationStage stage,
UniqueIdentifierGenerator generator,
IMethodCallTransformerProvider provider,
ISqlPreparationContext context,
Func<ITableInfo, SqlTable> tableGenerator)
{
ArgumentUtility.CheckNotNull ("fromExpression", fromExpression);
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("generator", generator);
ArgumentUtility.CheckNotNull ("provider", provider);
ArgumentUtility.CheckNotNull ("context", context);
var visitor = new SqlPreparationFromExpressionVisitor (generator, stage, provider, context, tableGenerator);
visitor.VisitExpression (fromExpression);
if (visitor.FromExpressionInfo != null)
return visitor.FromExpressionInfo.Value;
var message = string.Format (
"Error parsing expression '{0}'. Expressions of type '{1}' cannot be used as the SqlTables of a from clause.",
FormattingExpressionTreeVisitor.Format (fromExpression),
fromExpression.Type.Name);
throw new NotSupportedException (message);
}
public void SetUp ()
{
_generator = new UniqueIdentifierGenerator ();
_stage = new DefaultSqlPreparationStage (
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
_handler = new AverageResultOperatorHandler ();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
}
public SqlPreparationContext (ISqlPreparationContext parentContext, SqlStatementBuilder sqlStatementBuilder)
{
ArgumentUtility.CheckNotNull ("sqlStatementBuilder", sqlStatementBuilder);
_parentContext = parentContext;
_sqlStatementBuilder = sqlStatementBuilder;
_mapping = new Dictionary<Expression, Expression>();
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateStrictMock<ISqlPreparationStage>();
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_methodCallTransformerProvider = CompoundMethodCallTransformerProvider.CreateDefault();
_visitor = new TestableSqlPreparationFromExpressionVisitor (
_generator, _stageMock, _methodCallTransformerProvider, _context, info => new SqlTable (info, JoinSemantics.Inner));
}
public TestableSqlPreparationFromExpressionVisitor (
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
IMethodCallTransformerProvider provider,
ISqlPreparationContext context,
Func<ITableInfo, SqlTable> tableGenerator)
: base (generator, stage, provider, context, tableGenerator)
{
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateMock<ISqlPreparationStage> ();
_generator = new UniqueIdentifierGenerator ();
_handler = new CastResultOperatorHandler ();
_sqlStatementBuilder = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement ())
{
DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook ()))
};
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
}
public void SetUp ()
{
_handler = new TestableResultOperatorHandler();
_resultOperator = new TestChoiceResultOperator (false);
_statementBuilder = new SqlStatementBuilder();
_statementBuilder.SelectProjection = Expression.Constant ("select");
_statementBuilder.DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook()));
_generator = new UniqueIdentifierGenerator();
_stageMock = MockRepository.GenerateMock<ISqlPreparationStage>();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
}
protected SqlPreparationExpressionVisitor (
ISqlPreparationContext context, ISqlPreparationStage stage, IMethodCallTransformerProvider provider)
{
ArgumentUtility.CheckNotNull ("context", context);
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("provider", provider);
_context = context;
_stage = stage;
_methodCallTransformerProvider = provider;
}
public void SetUp ()
{
_generator = new UniqueIdentifierGenerator ();
_stage = new DefaultSqlPreparationStage (new CompoundMethodCallTransformerProvider (), new ResultOperatorHandlerRegistry (), _generator);
_handler = new SumResultOperatorHandler ();
_sqlStatementBuilder = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement ())
{
DataInfo = new StreamedSequenceInfo (typeof (int[]), Expression.Constant (5))
};
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
}
public void SetUp ()
{
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_source = ExpressionHelper.CreateMainFromClause<Cook>();
var source = new UnresolvedTableInfo (typeof (int));
_sqlTable = new SqlTable (source, JoinSemantics.Inner);
_parentContext = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
_parentSource = ExpressionHelper.CreateMainFromClause<Cook>();
_parentSqlTable = new SqlTable (new UnresolvedTableInfo (typeof (int)), JoinSemantics.Inner);
_sqlStatementBuilder = new SqlStatementBuilder();
_contextWithParent = new SqlPreparationContext (_parentContext, _sqlStatementBuilder);
}
protected SqlPreparationFromExpressionVisitor (
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
IMethodCallTransformerProvider provider,
ISqlPreparationContext context,
Func<ITableInfo, SqlTable> tableGenerator)
: base (context, stage, provider)
{
_generator = generator;
FromExpressionInfo = null;
_tableGenerator = tableGenerator;
}
public SqlPreparationSubStatementTableFactory (
ISqlPreparationStage stage,
ISqlPreparationContext context,
UniqueIdentifierGenerator uniqueIdentifierGenerator)
{
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("context", context);
_stage = stage;
_uniqueIdentifierGenerator = uniqueIdentifierGenerator;
_context = context;
}
public void SetUp ()
{
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
var querySource = ExpressionHelper.CreateMainFromClause<Cook>();
_sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner);
_context.AddExpressionMapping (new QuerySourceReferenceExpression(querySource), new SqlTableReferenceExpression(_sqlTable));
_querySourceReferenceExpression = new QuerySourceReferenceExpression (querySource);
_stage = new DefaultSqlPreparationStage (
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), new UniqueIdentifierGenerator());
}
public static Expression TranslateExpression (
Expression expression,
ISqlPreparationContext context,
ISqlPreparationStage stage,
IMethodCallTransformerProvider provider)
{
ArgumentUtility.CheckNotNull ("expression", expression);
ArgumentUtility.CheckNotNull ("context", context);
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("provider", provider);
var visitor = new SqlPreparationExpressionVisitor (context, stage, provider);
var result = visitor.VisitExpression (expression);
return result;
}
public void SetUp ()
{
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_defaultStage = new DefaultSqlPreparationStage (
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
_mainFromClause = ExpressionHelper.CreateMainFromClause<Cook>();
_selectClause = ExpressionHelper.CreateSelectClause (_mainFromClause);
_orderByClause = ExpressionHelper.CreateOrderByClause();
_queryModel = new QueryModel (_mainFromClause, _selectClause);
_stageMock = MockRepository.GenerateStrictMock<ISqlPreparationStage>();
_visitor = new TestableSqlPreparationQueryModelVisitor (_context, _stageMock);
_visitorPartialMock = MockRepository.GeneratePartialMock<TestableSqlPreparationQueryModelVisitor> (_context, _stageMock);
}
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 static Expression TranslateExpression(
Expression expression,
ISqlPreparationContext context,
ISqlPreparationStage stage,
IMethodCallTransformerProvider provider)
{
ArgumentUtility.CheckNotNull("expression", expression);
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("provider", provider);
var visitor = new SqlPreparationExpressionVisitor(context, stage, provider);
var result = visitor.Visit(expression);
return(result);
}
public void SetUp()
{
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_defaultStage = new DefaultSqlPreparationStage(
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), _generator);
_mainFromClause = ExpressionHelper.CreateMainFromClause <Cook>();
_selectClause = ExpressionHelper.CreateSelectClause(_mainFromClause);
_orderByClause = ExpressionHelper.CreateOrderByClause();
_queryModel = new QueryModel(_mainFromClause, _selectClause);
_stageMock = MockRepository.GenerateStrictMock <ISqlPreparationStage>();
_visitor = new TestableSqlPreparationQueryModelVisitor(_context, _stageMock);
_visitorPartialMock = MockRepository.GeneratePartialMock <TestableSqlPreparationQueryModelVisitor> (_context, _stageMock);
}
public override void SetUp()
{
base.SetUp();
_stage = CreateDefaultSqlPreparationStage();
_handler = new UnionResultOperatorHandler();
var selectProjection = ExpressionHelper.CreateExpression(typeof(int));
_sqlStatementBuilder = new SqlStatementBuilder
{
DataInfo = new StreamedSequenceInfo(typeof(int[]), selectProjection),
SelectProjection = selectProjection
};
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
}
void IResultOperatorHandler.HandleResultOperator(
ResultOperatorBase resultOperator,
SqlStatementBuilder sqlStatementBuilder,
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
var castOperator = ArgumentUtility.CheckNotNullAndType <T> ("resultOperator", resultOperator);
HandleResultOperator(castOperator, sqlStatementBuilder, generator, stage, context);
}
protected SqlPreparationQueryModelVisitor (
ISqlPreparationContext parentContext,
ISqlPreparationStage stage,
UniqueIdentifierGenerator generator,
ResultOperatorHandlerRegistry resultOperatorHandlerRegistry)
{
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("generator", generator);
ArgumentUtility.CheckNotNull ("resultOperatorHandlerRegistry", resultOperatorHandlerRegistry);
_stage = stage;
_generator = generator;
_resultOperatorHandlerRegistry = resultOperatorHandlerRegistry;
_sqlStatementBuilder = new SqlStatementBuilder();
_context = new SqlPreparationContext (parentContext, _sqlStatementBuilder);
}
public static SqlStatement TransformQueryModel (
QueryModel queryModel,
ISqlPreparationContext parentPreparationContext,
ISqlPreparationStage stage,
UniqueIdentifierGenerator generator,
ResultOperatorHandlerRegistry resultOperatorHandlerRegistry)
{
ArgumentUtility.CheckNotNull ("queryModel", queryModel);
ArgumentUtility.CheckNotNull ("stage", stage);
ArgumentUtility.CheckNotNull ("generator", generator);
ArgumentUtility.CheckNotNull ("resultOperatorHandlerRegistry", resultOperatorHandlerRegistry);
var visitor = new SqlPreparationQueryModelVisitor (parentPreparationContext, stage, generator, resultOperatorHandlerRegistry);
queryModel.Accept (visitor);
return visitor.GetSqlStatement();
}
protected SqlPreparationQueryModelVisitor(
ISqlPreparationContext parentContext,
ISqlPreparationStage stage,
UniqueIdentifierGenerator generator,
ResultOperatorHandlerRegistry resultOperatorHandlerRegistry)
{
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("resultOperatorHandlerRegistry", resultOperatorHandlerRegistry);
_stage = stage;
_generator = generator;
_resultOperatorHandlerRegistry = resultOperatorHandlerRegistry;
_sqlStatementBuilder = new SqlStatementBuilder();
_context = new SqlPreparationContext(parentContext, _sqlStatementBuilder);
}
public static SqlStatement TransformQueryModel(
QueryModel queryModel,
ISqlPreparationContext parentPreparationContext,
ISqlPreparationStage stage,
UniqueIdentifierGenerator generator,
ResultOperatorHandlerRegistry resultOperatorHandlerRegistry)
{
ArgumentUtility.CheckNotNull("queryModel", queryModel);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("resultOperatorHandlerRegistry", resultOperatorHandlerRegistry);
var visitor = new SqlPreparationQueryModelVisitor(parentPreparationContext, stage, generator, resultOperatorHandlerRegistry);
queryModel.Accept(visitor);
return(visitor.GetSqlStatement());
}
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();
}
protected SqlPreparationFromExpressionVisitor(
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
IMethodCallTransformerProvider provider,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
OrderingExtractionPolicy orderingExtractionPolicy)
: base(context, stage, provider)
{
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("tableGenerator", tableGenerator);
_generator = generator;
_tableGenerator = tableGenerator;
_orderingExtractionPolicy = orderingExtractionPolicy;
FromExpressionInfo = null;
}
public void SetUp()
{
_stageMock = MockRepository.GenerateMock <ISqlPreparationStage> ();
_generator = new UniqueIdentifierGenerator();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_handler = new SkipResultOperatorHandler();
_sqlTable = new SqlTable(new UnresolvedTableInfo(typeof(Cook)), JoinSemantics.Inner);
_selectProjection = new SqlTableReferenceExpression(_sqlTable);
_ordering = new Ordering(Expression.Constant(7), OrderingDirection.Asc);
_sqlStatementBuilder = new SqlStatementBuilder
{
SelectProjection = _selectProjection,
DataInfo = new StreamedSequenceInfo(typeof(Cook[]), Expression.Constant(new Cook())),
SqlTables = { _sqlTable },
};
_tupleCtor = _tupleCtor = typeof(KeyValuePair <Cook, int>).GetConstructor(new[] { typeof(Cook), typeof(int) });
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateMock<ISqlPreparationStage> ();
_generator = new UniqueIdentifierGenerator ();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
_handler = new SkipResultOperatorHandler ();
_sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner);
_selectProjection = new SqlTableReferenceExpression (_sqlTable);
_ordering = new Ordering (Expression.Constant (7), OrderingDirection.Asc);
_sqlStatementBuilder = new SqlStatementBuilder
{
SelectProjection = _selectProjection,
DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook ())),
SqlTables = { _sqlTable },
};
_tupleCtor = _tupleCtor = typeof (KeyValuePair<Cook, int>).GetConstructor (new[] { typeof (Cook), typeof (int) });
}
public override void HandleResultOperator(
SkipResultOperator resultOperator,
SqlStatementBuilder sqlStatementBuilder,
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
EnsureNoSetOperations(sqlStatementBuilder, generator, stage, context);
// We move the statement into a subquery and change it to return the row number in addition to the original projection. Then, we use that
// row number from the outer statement to skip the desired amount of rows. We also add an order by clause to the outer statement to ensure
// that the rows come in the correct order.
// E.g., (from c in Cooks orderby c.FirstName select c.LastName).Skip (20)
// becomes
// from x in
// (from c in Cooks select new { Key = c.LastName, Value = ROW_NUMBER() OVER (c.FirstName) })
// where x.Value > 20
// orderby x.Value
// select x.Key
var originalDataInfo = sqlStatementBuilder.DataInfo;
var subStatementWithRowNumber = CreateSubStatementWithRowNumber(sqlStatementBuilder, generator, stage, context);
sqlStatementBuilder.SelectProjection = subStatementWithRowNumber.OriginalProjectionSelector;
sqlStatementBuilder.SqlTables.Add(subStatementWithRowNumber.SubStatementTable);
sqlStatementBuilder.AddWhereCondition(Expression.GreaterThan(subStatementWithRowNumber.RowNumberSelector, resultOperator.Count));
sqlStatementBuilder.Orderings.Add(new Ordering(subStatementWithRowNumber.RowNumberSelector, OrderingDirection.Asc));
sqlStatementBuilder.DataInfo = originalDataInfo;
sqlStatementBuilder.RowNumberSelector = subStatementWithRowNumber.RowNumberSelector;
sqlStatementBuilder.CurrentRowNumberOffset = resultOperator.Count;
AddMappingForItemExpression(context, originalDataInfo, subStatementWithRowNumber.OriginalProjectionSelector);
}
protected void MoveCurrentStatementToSqlTable(
SqlStatementBuilder sqlStatementBuilder,
UniqueIdentifierGenerator generator,
ISqlPreparationContext context,
Func <ITableInfo, SqlTable> tableGenerator,
ISqlPreparationStage stage)
{
// Ensure that select clause is named - usually SqlPreparationQueryModelVisitor would do this, but it hasn't done it yet
sqlStatementBuilder.SelectProjection = new NamedExpression(null, sqlStatementBuilder.SelectProjection);
var oldStatement = sqlStatementBuilder.GetStatementAndResetBuilder();
var fromExpressionInfo = stage.PrepareFromExpression(new SqlSubStatementExpression(oldStatement), context, tableGenerator);
sqlStatementBuilder.SqlTables.Add(fromExpressionInfo.SqlTable);
sqlStatementBuilder.SelectProjection = fromExpressionInfo.ItemSelector;
sqlStatementBuilder.Orderings.AddRange(fromExpressionInfo.ExtractedOrderings);
Assertion.DebugAssert(fromExpressionInfo.WhereCondition == null);
// the new statement is an identity query that selects the result of its subquery, so it starts with the same data type
sqlStatementBuilder.DataInfo = oldStatement.DataInfo;
AddMappingForItemExpression(context, oldStatement.DataInfo, fromExpressionInfo.ItemSelector);
}
public override void HandleResultOperator(
AverageResultOperator resultOperator,
SqlStatementBuilder sqlStatementBuilder,
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
ISqlPreparationContext context)
{
base.HandleResultOperator(resultOperator, sqlStatementBuilder, generator, stage, context);
// With the Average query operator, the result type determines the desired precision of the algorithm. For example, new[] { 1, 2 }.Average()
// returns a double and thus calculates an average with double precision (1.5).
// With SQL, however, the argument type determines the precision of the algorithm. I.e., AVG (intColumn) will return an integer with truncated
// average (1).
// To simulate Average behavior, we'll add a conversion of the argument expression if the types don't match.
var aggregationExpression = (AggregationExpression)sqlStatementBuilder.SelectProjection;
if (aggregationExpression.Expression.Type != aggregationExpression.Type)
{
sqlStatementBuilder.SelectProjection = new AggregationExpression(
aggregationExpression.Type,
new SqlConvertExpression(aggregationExpression.Type, aggregationExpression.Expression),
aggregationExpression.AggregationModifier);
}
}
public override void HandleResultOperator(OfTypeResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
EnsureNoGroupExpression(sqlStatementBuilder, generator, stage, context);
EnsureNoSetOperations(sqlStatementBuilder, generator, stage, context);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);
var typeCheckExpression = Expression.TypeIs(sqlStatementBuilder.SelectProjection, resultOperator.SearchedItemType);
sqlStatementBuilder.AddWhereCondition(typeCheckExpression);
sqlStatementBuilder.SelectProjection = Expression.Convert(sqlStatementBuilder.SelectProjection, resultOperator.SearchedItemType);
}
public override void HandleResultOperator(DistinctResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
EnsureNoTopExpression(sqlStatementBuilder, generator, stage, context);
EnsureNoGroupExpression(sqlStatementBuilder, generator, stage, context);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);
sqlStatementBuilder.IsDistinctQuery = true;
sqlStatementBuilder.Orderings.Clear(); //Distinct queries do not require ORDER BY clauses because LINQ's Distinct operator allows to reorder the result
}
public TestableSqlPreparationExpressionVisitorTest (ISqlPreparationContext context, ISqlPreparationStage stage, IMethodCallTransformerProvider provider)
: base (context, stage, provider)
{
}
public virtual Expression PrepareOrderByExpression (Expression expression, ISqlPreparationContext context)
{
return PrepareExpression (expression, context);
}
public override void HandleResultOperator(SingleResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
var equivalentTakeOperator = new TakeResultOperator(new SqlLiteralExpression(2));
var takeHandler = new TakeResultOperatorHandler();
takeHandler.HandleResultOperator(equivalentTakeOperator, sqlStatementBuilder, generator, stage, context);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);
}
public override void HandleResultOperator(ContainsResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
var dataInfo = sqlStatementBuilder.DataInfo;
var preparedItemExpression = stage.PrepareResultOperatorItemExpression(resultOperator.Item, context);
// No name required for the select projection inside of an IN expression
// (If the expression is a constant collection, a name would even be fatal.)
var sqlSubStatement = sqlStatementBuilder.GetStatementAndResetBuilder();
var subStatementExpression = sqlSubStatement.CreateExpression();
sqlStatementBuilder.SelectProjection = new SqlInExpression(preparedItemExpression, subStatementExpression);
UpdateDataInfo(resultOperator, sqlStatementBuilder, dataInfo);
}
public virtual FromExpressionInfo PrepareFromExpression (
Expression fromExpression,
ISqlPreparationContext context,
Func<ITableInfo, SqlTable> tableGenerator)
{
return SqlPreparationFromExpressionVisitor.AnalyzeFromExpression (
fromExpression, this, _uniqueIdentifierGenerator, _methodCallTransformerProvider, context, tableGenerator);
}
protected void EnsureNoGroupExpression(
SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
if (sqlStatementBuilder.GroupByExpression != null)
{
MoveCurrentStatementToSqlTable(sqlStatementBuilder, generator, context, info => new SqlTable(info, JoinSemantics.Inner), stage);
}
}
private void IncludeRowNumberInSelectProjection(SqlStatementBuilder sqlStatementBuilder, ISqlPreparationStage stage, ISqlPreparationContext context)
{
var rowNumberExpression = CreateRowNumberExpression(sqlStatementBuilder);
var tupleType = typeof(KeyValuePair <,>).MakeGenericType(sqlStatementBuilder.SelectProjection.Type, rowNumberExpression.Type);
Expression newSelectProjection = Expression.New(
tupleType.GetConstructors()[0],
new[] { sqlStatementBuilder.SelectProjection, rowNumberExpression },
new[] { tupleType.GetMethod("get_Key"), tupleType.GetMethod("get_Value") });
sqlStatementBuilder.SelectProjection = stage.PrepareSelectExpression(newSelectProjection, context);
}
public abstract void HandleResultOperator(
T resultOperator,
SqlStatementBuilder sqlStatementBuilder,
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
ISqlPreparationContext context);
protected void EnsureNoDistinctQuery(
SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
if (sqlStatementBuilder.IsDistinctQuery)
{
MoveCurrentStatementToSqlTable(sqlStatementBuilder, generator, context, info => new SqlTable(info, JoinSemantics.Inner), stage);
}
}
public TestableSqlPreparationQueryModelVisitor (ISqlPreparationContext context, ISqlPreparationStage stage,UniqueIdentifierGenerator generator, ResultOperatorHandlerRegistry registry)
: base (context, stage, generator, registry)
{
}
public override void HandleResultOperator(AllResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
EnsureNoGroupExpression(sqlStatementBuilder, generator, stage, context);
EnsureNoSetOperations(sqlStatementBuilder, generator, stage, context);
sqlStatementBuilder.AddWhereCondition(stage.PrepareWhereExpression(Expression.Not(resultOperator.Predicate), context));
// No name required for the select projection inside of an EXISTS expression
var sqlSubStatement = sqlStatementBuilder.GetStatementAndResetBuilder();
var subStatementExpression = new SqlSubStatementExpression(sqlSubStatement);
var sqlExistsExpression = new SqlExistsExpression(subStatementExpression);
sqlStatementBuilder.SelectProjection = stage.PrepareSelectExpression(Expression.Not(sqlExistsExpression), context);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlSubStatement.DataInfo);
}
public override void HandleResultOperator(FetchRequestBase resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
throw new NotSupportedException(
"The fetch query operator methods must be the last query operators in a LINQ query. All calls to Where, Select, Take, etc. must go before "
+ "the fetch operators."
+ Environment.NewLine
+ Environment.NewLine
+ "E.g., instead of 'QueryFactory.CreateLinqQuery<Order>().FetchMany (o => o.OrderItems).Where (o => o.OrderNumber > 1)', "
+ "write 'QueryFactory.CreateLinqQuery<Order>().Where (o => o.OrderNumber > 1).FetchMany (o => o.OrderItems)'.");
}
public override void HandleResultOperator(CastResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
sqlStatementBuilder.SelectProjection = Expression.Convert(sqlStatementBuilder.SelectProjection, resultOperator.CastItemType);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);
}
public override void HandleResultOperator(TestChoiceResultOperator resultOperator, SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context)
{
throw new NotImplementedException();
}
public TestableSqlPreparationExpressionVisitorTest(ISqlPreparationContext context, ISqlPreparationStage stage, IMethodCallTransformerProvider provider)
: base(context, stage, provider)
{
}
public virtual SqlStatement PrepareSqlStatement(QueryModel queryModel, ISqlPreparationContext parentContext)
{
return(SqlPreparationQueryModelVisitor.TransformQueryModel(queryModel, parentContext, this, _uniqueIdentifierGenerator, _resultOperatorHandlerRegistry));
}
public virtual SqlStatement PrepareSqlStatement (QueryModel queryModel, ISqlPreparationContext parentContext)
{
return SqlPreparationQueryModelVisitor.TransformQueryModel (queryModel, parentContext, this, _uniqueIdentifierGenerator, _resultOperatorHandlerRegistry);
}
public virtual Expression PrepareResultOperatorItemExpression(Expression expression, ISqlPreparationContext context)
{
return(PrepareExpression(expression, context));
}
public virtual Expression PrepareResultOperatorItemExpression (Expression expression, ISqlPreparationContext context)
{
return PrepareExpression (expression, context);
}
public virtual Expression PrepareOrderByExpression(Expression expression, ISqlPreparationContext context)
{
return(PrepareExpression(expression, context));
}
public override void HandleResultOperator(
TResultOperator resultOperator,
SqlStatementBuilder sqlStatementBuilder,
UniqueIdentifierGenerator generator,
ISqlPreparationStage stage,
ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("resultOperator", resultOperator);
ArgumentUtility.CheckNotNull("sqlStatementBuilder", sqlStatementBuilder);
ArgumentUtility.CheckNotNull("generator", generator);
ArgumentUtility.CheckNotNull("stage", stage);
ArgumentUtility.CheckNotNull("context", context);
UpdateDataInfo(resultOperator, sqlStatementBuilder, sqlStatementBuilder.DataInfo);
var source2 = GetSource2(resultOperator);
var preparedSubStatement = stage.PrepareResultOperatorItemExpression(source2, context) as SqlSubStatementExpression;
if (preparedSubStatement == null)
{
var message = string.Format(
"The '" + _operationName + "' operation is only supported for combining two query results, but a '{0}' was supplied as the "
+ "second sequence: {1}",
source2.GetType().Name,
source2);
throw new NotSupportedException(message);
}
var combinedStatement = new SetOperationCombinedStatement(preparedSubStatement.SqlStatement, _setOperation);
sqlStatementBuilder.SetOperationCombinedStatements.Add(combinedStatement);
// The set operators act as an IQuerySource, i.e., subsequent result operators can refer to its output.
// When a result operator references the set operator's output, it should simply refer to the outer statement's select projection instead.
AddMappingForItemExpression(context, sqlStatementBuilder.DataInfo, sqlStatementBuilder.SelectProjection);
// In SQL, the set operators does not allow the input sequences to contain an "ORDER BY". Therefore, we'll remove them, if any, unless a TOP
// expression is specified.
if (sqlStatementBuilder.Orderings.Any() && sqlStatementBuilder.TopExpression == null)
{
sqlStatementBuilder.Orderings.Clear();
}
// For the second source, removal of unneeded orderings is already performed by PrepareResultOperatorItemExpression.
Assertion.DebugAssert(!combinedStatement.SqlStatement.Orderings.Any() || combinedStatement.SqlStatement.TopExpression != null);
// However, if an ORDER BY _is_ included together with a TOP, then the ORDER BY is allowed again as long as the whole set-combined statement is
// moved to a substatement.
// I.e., this is invalid:
// SELECT [t0].[ID] AS [value] FROM [CookTable] AS [t0] WHERE ([t0].[FirstName] = 'Hugo')
// UNION (SELECT TOP (2) [t1].[ID] AS [value] FROM [CookTable] AS [t1] WHERE ([t1].[Name] = 'Boss') ORDER BY [t1].[ID] ASC)
// but this is valid:
// SELECT * FROM
// (
// SELECT [t0].[ID] AS [value] FROM [CookTable] AS [t0] WHERE ([t0].[FirstName] = 'Hugo')
// UNION (SELECT TOP (2) [t1].[ID] AS [value] FROM [CookTable] AS [t1] WHERE ([t1].[Name] = 'Boss') ORDER BY [t1].[ID] ASC)
// ) AS q0
if (sqlStatementBuilder.Orderings.Any() || combinedStatement.SqlStatement.Orderings.Any())
{
MoveCurrentStatementToSqlTable(
sqlStatementBuilder,
context,
ti => new SqlTable(ti, JoinSemantics.Inner),
stage,
OrderingExtractionPolicy.DoNotExtractOrderings);
}
}
protected virtual Expression PrepareExpression(Expression expression, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull("expression", expression);
return(SqlPreparationExpressionVisitor.TranslateExpression(expression, context, this, _methodCallTransformerProvider));
}
public TestableSqlPreparationQueryModelVisitor (ISqlPreparationContext context, ISqlPreparationStage stage)
: base (context, stage, new UniqueIdentifierGenerator(), ResultOperatorHandlerRegistry.CreateDefault())
{
}
protected virtual Expression PrepareExpression (Expression expression, ISqlPreparationContext context)
{
ArgumentUtility.CheckNotNull ("expression", expression);
return SqlPreparationExpressionVisitor.TranslateExpression (expression, context, this, _methodCallTransformerProvider);
}
