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); }