public SqlPreparationContext (ISqlPreparationContext parentContext, SqlStatementBuilder sqlStatementBuilder) { ArgumentUtility.CheckNotNull ("sqlStatementBuilder", sqlStatementBuilder); _parentContext = parentContext; _sqlStatementBuilder = sqlStatementBuilder; _mapping = new Dictionary<Expression, Expression>(); }
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 virtual Expression ResolveSelectExpression (Expression expression, SqlStatementBuilder sqlStatementBuilder, IMappingResolutionContext context) { ArgumentUtility.CheckNotNull ("expression", expression); ArgumentUtility.CheckNotNull ("sqlStatementBuilder", sqlStatementBuilder); ArgumentUtility.CheckNotNull ("context", context); var resolvedExpression = ResolvingSelectExpressionVisitor.ResolveExpression (expression, _resolver, this, context, _uniqueIdentifierGenerator, sqlStatementBuilder); return ApplyContext (resolvedExpression, SqlExpressionContext.ValueRequired, context); }
public void Initialization_NoSequenceData_ThrowsExeption () { var sqlStatement = new SqlStatementBuilder () { SelectProjection = Expression.Constant (new Cook ()), DataInfo = new StreamedScalarValueInfo(typeof(Cook)) }.GetSqlStatement (); new ResolvedSubStatementTableInfo ("c", sqlStatement); }
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 () { _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 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 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 (); }
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); }
public void BuildSelectPart_NoEntityExpression () { var sqlStatement = new SqlStatementBuilder { SelectProjection = new SqlColumnDefinitionExpression (typeof (string), "t", "FirstName", false), DataInfo = new TestStreamedValueInfo (typeof (object)) }.GetSqlStatement (); _stageMock.Expect ( mock => mock.GenerateTextForSelectExpression (_commandBuilder, sqlStatement.SelectProjection)) .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("[t].[FirstName]")); _stageMock.Replay(); _generator.BuildSelectPart (sqlStatement, _commandBuilder, false); Assert.That (_commandBuilder.GetCommandText(), Is.EqualTo ("SELECT [t].[FirstName]")); _stageMock.VerifyAllExpectations(); }
public static Expression ResolveExpression ( Expression expression, IMappingResolver resolver, IMappingResolutionStage stage, IMappingResolutionContext context, UniqueIdentifierGenerator generator, SqlStatementBuilder sqlStatementBuilder) { ArgumentUtility.CheckNotNull ("expression", expression); ArgumentUtility.CheckNotNull ("resolver", resolver); ArgumentUtility.CheckNotNull ("stage", stage); ArgumentUtility.CheckNotNull ("context", context); ArgumentUtility.CheckNotNull ("generator", generator); ArgumentUtility.CheckNotNull ("sqlStatementBuilder", sqlStatementBuilder); var entityIdentityResolver = new EntityIdentityResolver (stage, resolver, context); var comparisonSplitter = new CompoundExpressionComparisonSplitter (); var namedExpressionCombiner = new NamedExpressionCombiner (context); var groupAggregateSimplifier = new GroupAggregateSimplifier (stage, context); var visitor1 = new ResolvingSelectExpressionVisitor ( resolver, stage, context, generator, entityIdentityResolver, comparisonSplitter, namedExpressionCombiner, groupAggregateSimplifier, false, sqlStatementBuilder); var result1 = visitor1.VisitExpression (expression); var visitor2 = new ResolvingSelectExpressionVisitor ( resolver, stage, context, generator, entityIdentityResolver, comparisonSplitter, namedExpressionCombiner, groupAggregateSimplifier, true, sqlStatementBuilder); var result2 = visitor2.VisitExpression (result1); return result2; }
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 Initialization_WithDefaultValues () { var statementBuilder = new SqlStatementBuilder(); Assert.That (statementBuilder.DataInfo, Is.Null); Assert.That (statementBuilder.TopExpression, Is.Null); Assert.That (statementBuilder.IsDistinctQuery, Is.False); Assert.That (statementBuilder.SelectProjection, Is.Null); Assert.That (statementBuilder.SqlTables, Is.Empty); Assert.That (statementBuilder.Orderings, Is.Empty); Assert.That (statementBuilder.WhereCondition, Is.Null); Assert.That (statementBuilder.RowNumberSelector, Is.Null); Assert.That (statementBuilder.CurrentRowNumberOffset, Is.Null); Assert.That (statementBuilder.GroupByExpression, Is.Null); }
public SqlStatement VisitSqlStatement (SqlStatement sqlStatement, SqlExpressionContext expressionContext) { ArgumentUtility.CheckNotNull ("sqlStatement", sqlStatement); if (expressionContext == SqlExpressionContext.PredicateRequired) throw new InvalidOperationException ("A SqlStatement cannot be used as a predicate."); var statementBuilder = new SqlStatementBuilder (sqlStatement); var newSelectProjection = _stage.ApplyContext (sqlStatement.SelectProjection, expressionContext, _mappingResolutionContext); statementBuilder.SelectProjection = newSelectProjection; statementBuilder.RecalculateDataInfo (sqlStatement.SelectProjection); var newSqlStatement = statementBuilder.GetSqlStatement(); return newSqlStatement.Equals (sqlStatement) ? sqlStatement : newSqlStatement; }
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); }
private SqlTable CreateSqlCompatibleSubStatementTable ( SqlStatement originalStatement, Expression newSelectProjection, Func<ITableInfo, SqlTable> tableCreator) { // create a new statement equal to the original one, but with the tuple as its select projection var builder = new SqlStatementBuilder (originalStatement) { SelectProjection = newSelectProjection }; builder.RecalculateDataInfo (originalStatement.SelectProjection); // clear orderings unless required for TopExpression if (originalStatement.TopExpression == null) builder.Orderings.Clear(); var newSqlStatement = builder.GetSqlStatement(); // put new statement into a sub-statement table var subStatementTableInfo = new ResolvedSubStatementTableInfo (_uniqueIdentifierGenerator.GetUniqueIdentifier ("q"), newSqlStatement); return tableCreator (subStatementTableInfo); }
private SqlStatement ConvertValueStatementToSequenceStatement() { var newDataInfo = new StreamedSequenceInfo(typeof(IEnumerable <>).MakeGenericType(SqlStatement.DataInfo.DataType), SqlStatement.SelectProjection); var adjustedStatementBuilder = new SqlStatementBuilder(SqlStatement) { DataInfo = newDataInfo }; if (SqlStatement.DataInfo is StreamedSingleValueInfo && SqlStatement.SqlTables.Count != 0) { // A sub-statement might use a different TopExpression than 1 (or none at all) in order to provoke a SQL error when more than one item is // returned. When we convert the statement to a sequence statement, however, we must ensure that the exact "only 1 value is returned" // semantics is ensured because we can't provoke a SQL error (but instead would return strange result sets). adjustedStatementBuilder.TopExpression = new SqlLiteralExpression(1); } return(adjustedStatementBuilder.GetSqlStatement()); }
public void ResolveSelectExpression () { var expression = Expression.Constant (true); var sqlStatementBuilder = new SqlStatementBuilder(); var fakeResult = Expression.Constant (0); _resolverMock .Expect (mock => mock.ResolveConstantExpression (expression)) .Return (fakeResult); _resolverMock .Expect (mock => mock.ResolveConstantExpression (fakeResult)) .Return (fakeResult); _resolverMock.Replay(); var result = _stage.ResolveSelectExpression (expression, sqlStatementBuilder, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That (result, Is.TypeOf (typeof (ConstantExpression))); Assert.That (((ConstantExpression) result).Value, Is.EqualTo (0)); }
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 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 HandleResultOperator () { var predicate = Expression.Constant (true); var preparedPredicate = Expression.Constant (false); var resultOperator = new AllResultOperator(predicate); var sqlStatement = _sqlStatementBuilder.GetSqlStatement(); var fakePreparedSelectProjection = Expression.Constant (false); _stageMock .Expect (mock => mock.PrepareWhereExpression ( Arg<Expression>.Matches(e => e.NodeType == ExpressionType.Not && (((UnaryExpression) e).Operand == predicate)), Arg<ISqlPreparationContext>.Matches(c=>c==_context))) .Return (preparedPredicate); _stageMock .Expect (mock => mock.PrepareSelectExpression (Arg<Expression>.Matches (e => e.NodeType == ExpressionType.Not), Arg.Is (_context))) .WhenCalled ( mi => { var selectProjection = (Expression) mi.Arguments[0]; var expectedSubStatement = new SqlStatementBuilder (sqlStatement) { WhereCondition = preparedPredicate }.GetSqlStatement(); var expectedExistsExpression = new SqlExistsExpression (new SqlSubStatementExpression (expectedSubStatement)); var expectedExpression = Expression.Not (expectedExistsExpression); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedExpression, selectProjection); }) .Return (fakePreparedSelectProjection); _stageMock.Replay(); _handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context); _stageMock.VerifyAllExpectations (); Assert.That (_sqlStatementBuilder.DataInfo, Is.TypeOf (typeof (StreamedScalarValueInfo))); Assert.That (((StreamedScalarValueInfo) _sqlStatementBuilder.DataInfo).DataType, Is.EqualTo (typeof (Boolean))); Assert.That (_sqlStatementBuilder.SelectProjection, Is.SameAs (fakePreparedSelectProjection)); }
public void Initialization_WithExistingSqlStatement () { var isDistinctQuery = BooleanObjectMother.GetRandomBoolean(); var selectProjection = Expression.Constant ("select"); var whereCondition = Expression.Constant (true); var topExpression = Expression.Constant ("top"); var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner); var ordering = new Ordering (Expression.Constant ("order"), OrderingDirection.Desc); var rowNumberSelector = Expression.Constant("selector"); var currentRowNumberOffset = Expression.Constant(1); var groupExpression = Expression.Constant ("group"); var sqlStatement = new SqlStatement ( new TestStreamedValueInfo (typeof (int)), selectProjection, new[] { sqlTable }, whereCondition, groupExpression, new[] { ordering }, topExpression, isDistinctQuery, rowNumberSelector, currentRowNumberOffset); var testedBuilder = new SqlStatementBuilder (sqlStatement); Assert.That (testedBuilder.SelectProjection, Is.SameAs (selectProjection)); Assert.That (testedBuilder.TopExpression, Is.SameAs (topExpression)); Assert.That (testedBuilder.SqlTables[0], Is.SameAs (sqlTable)); Assert.That (testedBuilder.Orderings[0], Is.SameAs (ordering)); Assert.That (testedBuilder.WhereCondition, Is.EqualTo (whereCondition)); Assert.That (testedBuilder.IsDistinctQuery, Is.EqualTo (isDistinctQuery)); Assert.That (testedBuilder.DataInfo, Is.SameAs (sqlStatement.DataInfo)); Assert.That (testedBuilder.RowNumberSelector, Is.SameAs (sqlStatement.RowNumberSelector)); Assert.That (testedBuilder.CurrentRowNumberOffset, Is.SameAs (currentRowNumberOffset)); Assert.That (testedBuilder.GroupByExpression, Is.SameAs (groupExpression)); }
private Expression CheckAndSimplifyEntityWithinSubStatement (SqlSubStatementExpression sqlSubStatementExpression) { var newSelectProjection = ResolvePotentialEntity (sqlSubStatementExpression.SqlStatement.SelectProjection); if (newSelectProjection != sqlSubStatementExpression.SqlStatement.SelectProjection) { var newSubStatement = new SqlStatementBuilder (sqlSubStatementExpression.SqlStatement) { SelectProjection = newSelectProjection }; newSubStatement.RecalculateDataInfo (sqlSubStatementExpression.SqlStatement.SelectProjection); return newSubStatement.GetSqlStatement ().CreateExpression (); } return sqlSubStatementExpression; }
protected ResolvingSelectExpressionVisitor ( IMappingResolver resolver, IMappingResolutionStage stage, IMappingResolutionContext context, UniqueIdentifierGenerator generator, IEntityIdentityResolver entityIdentityResolver, ICompoundExpressionComparisonSplitter comparisonSplitter, INamedExpressionCombiner namedExpressionCombiner, IGroupAggregateSimplifier groupAggregateSimplifier, bool resolveEntityRefMemberExpressions, SqlStatementBuilder sqlStatementBuilder) : base ( resolver, stage, context, generator, entityIdentityResolver, comparisonSplitter, namedExpressionCombiner, groupAggregateSimplifier, resolveEntityRefMemberExpressions) { _sqlStatementBuilder = sqlStatementBuilder; }
public override string ToString() { var statementBuilder = new SqlStatementBuilder(this); return(statementBuilder.ToString()); }
private SqlStatement ConvertValueStatementToSequenceStatement () { var newDataInfo = new StreamedSequenceInfo (typeof (IEnumerable<>).MakeGenericType (SqlStatement.DataInfo.DataType), SqlStatement.SelectProjection); var adjustedStatementBuilder = new SqlStatementBuilder (SqlStatement) { DataInfo = newDataInfo }; if (SqlStatement.DataInfo is StreamedSingleValueInfo && SqlStatement.SqlTables.Count!=0) { // A sub-statement might use a different TopExpression than 1 (or none at all) in order to provoke a SQL error when more than one item is // returned. When we convert the statement to a sequence statement, however, we must ensure that the exact "only 1 value is returned" // semantics is ensured because we can't provoke a SQL error (but instead would return strange result sets). adjustedStatementBuilder.TopExpression = new SqlLiteralExpression (1); } return adjustedStatementBuilder.GetSqlStatement(); }
public override string ToString () { var statementBuilder = new SqlStatementBuilder (this); return statementBuilder.ToString(); }
public void ConvertToSqlTable_StreamedSingleValueInfoWithReturnsTrueIfEmpty_JoinSemanticIsChanged () { var selectProjection = Expression.Constant (new Cook ()); var sqlStatement = new SqlStatementBuilder { DataInfo = new StreamedSingleValueInfo (typeof (Cook), true), SelectProjection = selectProjection, TopExpression = new SqlLiteralExpression (2), SqlTables = { new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner) } }.GetSqlStatement (); var expression = new SqlSubStatementExpression (sqlStatement); var result = expression.ConvertToSqlTable ("q0"); Assert.That (result.JoinSemantics, Is.EqualTo (JoinSemantics.Left)); Assert.That (result.TableInfo.GetResolvedTableInfo ().TableAlias, Is.EqualTo ("q0")); Assert.That (result.TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo))); var newSubStatement = ((ResolvedSubStatementTableInfo) result.TableInfo).SqlStatement; var expectedSubStatement = new SqlStatementBuilder (sqlStatement) { DataInfo = new StreamedSequenceInfo (typeof (IEnumerable<Cook>), sqlStatement.SelectProjection), TopExpression = newSubStatement.TopExpression }.GetSqlStatement (); SqlExpressionTreeComparer.CheckAreEqualTrees (new SqlLiteralExpression (1), newSubStatement.TopExpression); Assert.That (newSubStatement, Is.EqualTo (expectedSubStatement)); }
protected override Expression VisitMemberExpression (MemberExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var newInnerExpression = VisitExpression (expression.Expression); var innerExpressionAsSqlCaseExpression = newInnerExpression as SqlCaseExpression; if (innerExpressionAsSqlCaseExpression != null) { var originalCases = innerExpressionAsSqlCaseExpression.Cases; var originalElseCase = innerExpressionAsSqlCaseExpression.ElseCase; var newCases = originalCases.Select (c => new SqlCaseExpression.CaseWhenPair (c.When, Expression.MakeMemberAccess (c.Then, expression.Member))); var newElseCase = originalElseCase != null ? Expression.MakeMemberAccess (originalElseCase, expression.Member) : null; // If there is no else case, ensure that the resulting type is nullable var caseExpressionType = newElseCase == null && expression.Type.IsValueType && Nullable.GetUnderlyingType (expression.Type) == null ? typeof (Nullable<>).MakeGenericType (expression.Type) : expression.Type; var newSqlCaseExpression = new SqlCaseExpression (caseExpressionType, newCases, newElseCase); return VisitExpression (newSqlCaseExpression); } if (newInnerExpression.NodeType == ExpressionType.Coalesce) { var innerExpressionAsBinaryExpression = (BinaryExpression) newInnerExpression; var newConditionalExpression = Expression.Condition ( new SqlIsNotNullExpression (innerExpressionAsBinaryExpression.Left), Expression.MakeMemberAccess (innerExpressionAsBinaryExpression.Left, expression.Member), Expression.MakeMemberAccess (innerExpressionAsBinaryExpression.Right, expression.Member)); return VisitExpression (newConditionalExpression); } var innerExpressionAsSqlSubStatementExpression = newInnerExpression as SqlSubStatementExpression; if (innerExpressionAsSqlSubStatementExpression != null) { var sqlStatementBuilder = new SqlStatementBuilder (innerExpressionAsSqlSubStatementExpression.SqlStatement); var namedExpression = (NamedExpression) sqlStatementBuilder.SelectProjection; sqlStatementBuilder.SelectProjection = new NamedExpression ( namedExpression.Name, VisitExpression (Expression.MakeMemberAccess (namedExpression.Expression, expression.Member))); sqlStatementBuilder.RecalculateDataInfo (innerExpressionAsSqlSubStatementExpression.SqlStatement.SelectProjection); return new SqlSubStatementExpression (sqlStatementBuilder.GetSqlStatement()); } var memberAsPropertyInfo = expression.Member as PropertyInfo; if (memberAsPropertyInfo != null) { var methodInfo = memberAsPropertyInfo.GetGetMethod(); if (methodInfo != null) { var methodCallExpression = Expression.Call (expression.Expression, methodInfo); var tranformer = _methodCallTransformerProvider.GetTransformer(methodCallExpression); if (tranformer != null) { var tranformedExpression = tranformer.Transform (methodCallExpression); return VisitExpression (tranformedExpression); } } } return base.VisitMemberExpression (expression); }
public virtual Expression VisitSqlSubStatementExpression (SqlSubStatementExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); if (expression.SqlStatement.Orderings.Count > 0 && expression.SqlStatement.TopExpression == null) { var builder = new SqlStatementBuilder (expression.SqlStatement); builder.Orderings.Clear(); return new SqlSubStatementExpression (builder.GetSqlStatement()); } return expression; }
public ITableInfo VisitUnresolvedGroupReferenceTableInfo (UnresolvedGroupReferenceTableInfo tableInfo) { var groupSourceSubStatementTableInfo = tableInfo.ReferencedGroupSource.GetResolvedTableInfo() as ResolvedSubStatementTableInfo; if (groupSourceSubStatementTableInfo == null) { var message = string.Format ( "This SQL generator only supports sequences in from expressions if they are members of an entity or if they come from a GroupBy operator. " + "Sequence: '{0}'", tableInfo); throw new NotSupportedException (message); } var groupingSelectExpression = groupSourceSubStatementTableInfo.SqlStatement.SelectProjection as SqlGroupingSelectExpression; if (groupingSelectExpression == null) { throw new NotSupportedException ( "When a sequence retrieved by a subquery is used in a from expression, the subquery must end with a GroupBy operator."); } var elementSelectingStatementBuilder = new SqlStatementBuilder (groupSourceSubStatementTableInfo.SqlStatement) { GroupByExpression = null }; var currentKeyExpression = Expression.MakeMemberAccess ( new SqlTableReferenceExpression (tableInfo.ReferencedGroupSource), groupingSelectExpression.Type.GetProperty ("Key")); var groupKeyJoinCondition = _stage.ResolveWhereExpression ( Expression.OrElse ( Expression.AndAlso (new SqlIsNullExpression (groupingSelectExpression.KeyExpression), new SqlIsNullExpression (currentKeyExpression)), Expression.AndAlso ( Expression.AndAlso ( new SqlIsNotNullExpression (groupingSelectExpression.KeyExpression), new SqlIsNotNullExpression (currentKeyExpression)), Expression.Equal (groupingSelectExpression.KeyExpression, currentKeyExpression))), _context); elementSelectingStatementBuilder.AddWhereCondition (groupKeyJoinCondition); elementSelectingStatementBuilder.SelectProjection = groupingSelectExpression.ElementExpression; elementSelectingStatementBuilder.RecalculateDataInfo (groupingSelectExpression); return new ResolvedJoinedGroupingTableInfo ( _generator.GetUniqueIdentifier("q"), elementSelectingStatementBuilder.GetSqlStatement(), groupingSelectExpression, groupSourceSubStatementTableInfo.TableAlias); }
public void ConvertToSqlTable () { var selectProjection = Expression.Constant (new Cook()); var sqlStatement = new SqlStatementBuilder { DataInfo = new StreamedSingleValueInfo (typeof (Cook), false), SelectProjection = selectProjection }. GetSqlStatement(); var expression = new SqlSubStatementExpression (sqlStatement); var result = expression.ConvertToSqlTable ("q0"); Assert.That (result.JoinSemantics, Is.EqualTo (JoinSemantics.Inner)); Assert.That (result.TableInfo.GetResolvedTableInfo().TableAlias, Is.EqualTo ("q0")); Assert.That (result.TableInfo, Is.TypeOf (typeof (ResolvedSubStatementTableInfo))); var newSubStatement = ((ResolvedSubStatementTableInfo) result.TableInfo).SqlStatement; var expectedSubStatement = new SqlStatementBuilder (sqlStatement) { DataInfo = new StreamedSequenceInfo (typeof (IEnumerable<Cook>), sqlStatement.SelectProjection) }.GetSqlStatement(); Assert.That (newSubStatement, Is.EqualTo (expectedSubStatement)); }