public ITableInfo VisitSubStatementTableInfo (ResolvedSubStatementTableInfo tableInfo) { ArgumentUtility.CheckNotNull ("tableInfo", tableInfo); var newStatement = _stage.ApplySelectionContext (tableInfo.SqlStatement, _expressionContext, _mappingResolutionContext); if (newStatement != tableInfo.SqlStatement) return new ResolvedSubStatementTableInfo (tableInfo.TableAlias, newStatement); return tableInfo; }
public void SetUp () { _sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook))) { SelectProjection = new NamedExpression ("test", Expression.Constant (5)), DataInfo = new StreamedSequenceInfo (typeof (int[]), Expression.Constant (0)) }.GetSqlStatement(); _tableInfo = new ResolvedSubStatementTableInfo ("c", _sqlStatement); }
protected SubStatementReferenceResolver (ResolvedSubStatementTableInfo tableInfo, SqlTableBase sqlTable, IMappingResolutionContext context) { ArgumentUtility.CheckNotNull ("tableInfo", tableInfo); ArgumentUtility.CheckNotNull ("sqlTable", sqlTable); ArgumentUtility.CheckNotNull ("context", context); _tableInfo = tableInfo; _sqlTable = sqlTable; _context = context; }
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 FromExpressionInfo CreateSqlTableForStatement (SqlStatement sqlStatement, Func<ITableInfo, SqlTable> tableCreator) { if (sqlStatement.Orderings.Count == 0) { var tableInfo = new ResolvedSubStatementTableInfo (_uniqueIdentifierGenerator.GetUniqueIdentifier ("q"), sqlStatement); var sqlTable = tableCreator (tableInfo); return new FromExpressionInfo (sqlTable, new Ordering[0], new SqlTableReferenceExpression (sqlTable), null); } var selectExpressionWithOrderings = GetNewSelectExpressionWithOrderings (sqlStatement); var tableWithSubStatement = CreateSqlCompatibleSubStatementTable (sqlStatement, selectExpressionWithOrderings, tableCreator); return GetFromExpressionInfoForSubStatement (sqlStatement, tableWithSubStatement); }
public void ResolveSubStatementReferenceExpression_CreatesColumnExpression_ForNamedExpression () { var referencedExpression = new NamedExpression ("test", Expression.Constant (0)); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement (referencedExpression); var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression ( referencedExpression, tableInfo, sqlTable, _context); var expectedResult = new SqlColumnDefinitionExpression (typeof (int), "q0", "test", false); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public void ApplyContext_ResolvedSubStatementTableInfo_SameTableInfo () { var subStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook)); var subStatementTableInfo = new ResolvedSubStatementTableInfo ("c", subStatement); _stageMock .Expect (mock => mock.ApplySelectionContext (subStatement, SqlExpressionContext.ValueRequired, _mappingresolutionContext)) .Return (subStatement); _stageMock.Replay (); var result = SqlContextTableInfoVisitor.ApplyContext (subStatementTableInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext); Assert.That (result, Is.SameAs (subStatementTableInfo)); _stageMock.VerifyAllExpectations (); }
public static Expression ResolveSubStatementReferenceExpression ( Expression referencedExpression, ResolvedSubStatementTableInfo containingSubStatementTableInfo, SqlTableBase containingSqlTable, IMappingResolutionContext context) { ArgumentUtility.CheckNotNull ("referencedExpression", referencedExpression); ArgumentUtility.CheckNotNull ("containingSubStatementTableInfo", containingSubStatementTableInfo); ArgumentUtility.CheckNotNull ("containingSqlTable", containingSqlTable); var visitor = new SubStatementReferenceResolver (containingSubStatementTableInfo, containingSqlTable, context); var result = visitor.VisitExpression (referencedExpression); return result; }
public SqlTable ConvertToSqlTable (string uniqueIdentifier) { ArgumentUtility.CheckNotNullOrEmpty ("uniqueIdentifier", uniqueIdentifier); ArgumentUtility.CheckNotNullOrEmpty ("uniqueIdentifier", uniqueIdentifier); var joinSemantic = CalculateJoinSemantic(); SqlStatement sequenceStatement; if (SqlStatement.DataInfo is StreamedSequenceInfo) sequenceStatement = SqlStatement; else sequenceStatement = ConvertValueStatementToSequenceStatement (); var resolvedSubStatementTableInfo = new ResolvedSubStatementTableInfo (uniqueIdentifier, sequenceStatement); return new SqlTable (resolvedSubStatementTableInfo, joinSemantic); }
public void ResolveSubStatementReferenceExpression_CreatesNewExpressionWithReferences_ForNewExpressions () { var newExpression = Expression.New ( TypeForNewExpression.GetConstructor (typeof(int)), new[] { new NamedExpression ("const", Expression.Constant (0)) }, (MemberInfo) typeof (TypeForNewExpression).GetProperty ("A")); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement (newExpression); var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (newExpression, tableInfo, sqlTable, _context); var expectedResult = Expression.New ( TypeForNewExpression.GetConstructor (typeof (int)), new Expression[] { new NamedExpression ("A", new SqlColumnDefinitionExpression (typeof (int), "q0", "const", false) ) }, newExpression.Members); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
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); }
public new void ToString () { var sqlStatement = new SqlStatementBuilder () { SelectProjection = Expression.Constant (new Cook ()), DataInfo = new StreamedSequenceInfo (typeof (IQueryable<int>), Expression.Constant (0)) }.GetSqlStatement (); var subStatementInfo = new ResolvedSubStatementTableInfo ("c", sqlStatement); var result = subStatementInfo.ToString (); Assert.That (result, Is.EqualTo ("(" + sqlStatement + ") [c]")); }
public ITableInfo VisitSubStatementTableInfo (ResolvedSubStatementTableInfo tableInfo) { ArgumentUtility.CheckNotNull ("tableInfo", tableInfo); _commandBuilder.Append ("("); _stage.GenerateTextForSqlStatement (_commandBuilder, tableInfo.SqlStatement); _commandBuilder.Append (")"); _commandBuilder.Append (" AS "); _commandBuilder.AppendIdentifier (tableInfo.TableAlias); return tableInfo; }
public ITableInfo VisitSubStatementTableInfo (ResolvedSubStatementTableInfo tableInfo) { ArgumentUtility.CheckNotNull ("tableInfo", tableInfo); var newSqlStatement = _stage.ResolveSqlStatement (tableInfo.SqlStatement, _context); if (newSqlStatement.Equals (tableInfo.SqlStatement)) return tableInfo; else return new ResolvedSubStatementTableInfo (tableInfo.TableAlias, newSqlStatement); }
public void ResolveTableInfo_SubStatementTableInfo_SubStatementUnmodified () { var sqlSubStatementTableInfo = new ResolvedSubStatementTableInfo ("c", _sqlStatement); _stageMock .Expect (mock => mock.ResolveSqlStatement (_sqlStatement, _mappingResolutionContext)) .Return (_sqlStatement); _resolverMock.Replay (); var result = (ResolvedSubStatementTableInfo) ResolvingTableInfoVisitor.ResolveTableInfo (sqlSubStatementTableInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext); _stageMock.VerifyAllExpectations (); Assert.That (result, Is.SameAs (sqlSubStatementTableInfo)); }
public void ResolveSubStatementReferenceExpression_RegistersEntityTable_WithinUnknownExpression () { var referencedExpression = Expression.Convert (SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook)), typeof (Chef)); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement (referencedExpression); var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression ( referencedExpression, tableInfo, sqlTable, _context); Assert.That (result.NodeType, Is.EqualTo (ExpressionType.Convert)); var entityReference = (SqlEntityExpression) ((UnaryExpression) result).Operand; Assert.That (_context.GetSqlTableForEntityExpression (entityReference), Is.SameAs (sqlTable)); }
public void ResolveSubStatementReferenceExpression_CopiesExpression_ForUnknownExpression () { var referencedExpression = Expression.Constant (0); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement (referencedExpression); var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression ( referencedExpression, tableInfo, sqlTable, _context); Assert.That (result, Is.SameAs (referencedExpression)); }
public void ResolveSubStatementReferenceExpression_CreatesSqlGroupingSelectExpressionWithNamedExpressions () { var expression = new SqlGroupingSelectExpression ( Expression.Constant ("key"), Expression.Constant ("element"), new[] { Expression.Constant ("aggregation") }); var tableInfo = new ResolvedSubStatementTableInfo ("q0", SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook))); var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)); var exprectedResult = new SqlGroupingSelectExpression ( new NamedExpression ("key", Expression.Constant ("key")), new NamedExpression ("element", Expression.Constant ("element")), new[] { new NamedExpression ("a0", Expression.Constant ("aggregation")) }); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (expression, tableInfo, sqlTable, _context); SqlExpressionTreeComparer.CheckAreEqualTrees (result, exprectedResult); Assert.That (_context.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable)); }
public void ApplyContext_JoinInfo () { var sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook))) { SelectProjection = Expression.Constant (true), DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook())) }.GetSqlStatement(); var tableInfo = new ResolvedSubStatementTableInfo ("c", sqlStatement); var joinInfo = new ResolvedJoinInfo (tableInfo, Expression.Equal (new SqlLiteralExpression (1), new SqlLiteralExpression (1))); var result = _stage.ApplyContext (joinInfo, SqlExpressionContext.ValueRequired, _mappingResolutionContext); Assert.That (result, Is.Not.SameAs (joinInfo)); Assert.That ( ((ResolvedSubStatementTableInfo) ((ResolvedJoinInfo) result).ForeignTableInfo).SqlStatement.SelectProjection, Is.TypeOf (typeof (SqlConvertedBooleanExpression))); Assert.That ( ((ConstantExpression) ((SqlConvertedBooleanExpression) ((ResolvedSubStatementTableInfo) ((ResolvedJoinInfo) result).ForeignTableInfo).SqlStatement.SelectProjection) .Expression).Value, Is.EqualTo (1)); }
public void ResolveSubStatementReferenceExpression_CreatesEntityReference_ForEntities () { var entityDefinitionExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook)); var sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook))) { SelectProjection = entityDefinitionExpression, DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook())) }.GetSqlStatement(); var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (entityDefinitionExpression, tableInfo, sqlTable, _context); Assert.That (result, Is.TypeOf (typeof (SqlEntityReferenceExpression))); Assert.That (_context.GetSqlTableForEntityExpression ((SqlEntityReferenceExpression) result), Is.SameAs (sqlTable)); var expectedResult = entityDefinitionExpression.CreateReference ("q0", tableInfo.SqlStatement.SelectProjection.Type); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResult, result); }
public void VisitSubStatementTableInfo () { var sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook[]))) { DataInfo = new StreamedSequenceInfo (typeof (IQueryable<Cook>), Expression.Constant (new Cook ())) }.GetSqlStatement (); var resolvedSubTableInfo = new ResolvedSubStatementTableInfo ("cook", sqlStatement); _stageMock .Expect (mock => mock.GenerateTextForSqlStatement (_commandBuilder, sqlStatement)) .WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("XXX")); _stageMock.Replay(); _generator.VisitSubStatementTableInfo (resolvedSubTableInfo); _stageMock.VerifyAllExpectations(); Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("(XXX) AS [cook]")); }
public void GenerateSql_InnerJoinSemantics_NonFirstTable_SubstatementTableInfo () { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook)); var tableInfo = new ResolvedSubStatementTableInfo("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); _stageMock .Expect (mock => mock.GenerateTextForSqlStatement (_commandBuilder, sqlStatement)) .WhenCalled(mi=> ((ISqlCommandBuilder) mi.Arguments[0]).Append("[Table] AS [t]")); _stageMock.Replay(); SqlTableAndJoinTextGenerator.GenerateSql (sqlTable, _commandBuilder, _stageMock, isFirstTable: false); _stageMock.VerifyAllExpectations(); Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo (" CROSS APPLY ([Table] AS [t]) AS [q0]")); }
public void ResolveTableInfo () { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook)); var fakeResolvedSubStatementTableInfo = new ResolvedSubStatementTableInfo ("c", sqlStatement); _resolverMock .Expect (mock => mock.ResolveTableInfo (_unresolvedTableInfo, _uniqueIdentifierGenerator)) .Return (fakeResolvedSubStatementTableInfo); _resolverMock.Replay(); var result = _stage.ResolveTableInfo (_sqlTable.TableInfo, _mappingResolutionContext); _resolverMock.VerifyAllExpectations(); Assert.That (result, Is.SameAs (fakeResolvedSubStatementTableInfo)); }
public void ResolveSubStatementReferenceExpression_CreatesSqlGroupingReferenceExpression_ForSqlGroupingSelectExpression () { var groupingSelectExpression = new SqlGroupingSelectExpression ( SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), "key"), new NamedExpression ("element", Expression.Constant (0)), new[] { new NamedExpression ("a0", Expression.Constant (1)) }); var sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook))) { SelectProjection = groupingSelectExpression, DataInfo = new StreamedSequenceInfo (typeof (IGrouping<int, int>[]), Expression.Constant (null, typeof (IGrouping<int, int>))) }.GetSqlStatement (); var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (groupingSelectExpression, tableInfo, sqlTable, _context); Assert.That (result, Is.TypeOf (typeof (SqlGroupingSelectExpression))); var referencedKeyExpression = ((SqlGroupingSelectExpression) result).KeyExpression; var expectedReferencedKeyExpression = new NamedExpression("key", new SqlEntityReferenceExpression ( typeof (Cook), "q0", null, (SqlEntityExpression) groupingSelectExpression.KeyExpression)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedKeyExpression, referencedKeyExpression); var referencedElementExpression = ((SqlGroupingSelectExpression) result).ElementExpression; var expectedReferencedElementExpression = new NamedExpression("element", new SqlColumnDefinitionExpression (typeof (int), "q0", "element", false)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedElementExpression, referencedElementExpression); Assert.That (((SqlGroupingSelectExpression) result).AggregationExpressions.Count, Is.EqualTo (1)); var referencedAggregationExpression = ((SqlGroupingSelectExpression) result).AggregationExpressions[0]; var expectedReferencedAggregationExpression = new NamedExpression("a0", new SqlColumnDefinitionExpression (typeof (int), "q0", "a0", false)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedAggregationExpression, referencedAggregationExpression); Assert.That (_context.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable)); }
public void ResolveTableInfo_SubStatementTableInfo_SubStatementModified () { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatementWithCook (); var sqlSubStatementTableInfo = new ResolvedSubStatementTableInfo ("c", sqlStatement); _stageMock .Expect (mock => mock.ResolveSqlStatement (sqlStatement, _mappingResolutionContext)) .Return (_sqlStatement); _resolverMock.Replay (); var result = (ResolvedSubStatementTableInfo) ResolvingTableInfoVisitor.ResolveTableInfo (sqlSubStatementTableInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext); _stageMock.VerifyAllExpectations (); Assert.That (result, Is.Not.SameAs (sqlSubStatementTableInfo)); Assert.That (result.SqlStatement, Is.SameAs (_sqlStatement)); Assert.That (result.TableAlias, Is.EqualTo (sqlSubStatementTableInfo.TableAlias)); }