public FromExpressionInfo CreateSqlTableForStatement( SqlStatement sqlStatement, Func <ITableInfo, SqlTable> tableCreator, OrderingExtractionPolicy orderingExtractionPolicy) { ArgumentUtility.CheckNotNull("sqlStatement", sqlStatement); ArgumentUtility.CheckNotNull("tableCreator", 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)); } // If we have orderings, we need to: // - Build a nested projection that includes the original orderings if OrderingExtractionPolicy.ExtractOrderingsIntoProjection is specified. // - Create a substatement clearing orderings, unless a TOP expression is present. // - Put it into a SqlTable. // - Put a reference to everything in the select projection (i.e., the original projection and the extracted orderings) into a // FromExpressionInfo and return that. var newSelectProjection = sqlStatement.SelectProjection; if (orderingExtractionPolicy == OrderingExtractionPolicy.ExtractOrderingsIntoProjection) { newSelectProjection = GetNewSelectExpressionWithOrderings(sqlStatement); } var tableWithSubStatement = CreateSqlCompatibleSubStatementTable(sqlStatement, newSelectProjection, tableCreator); return(GetFromExpressionInfoForSubStatement(sqlStatement, tableWithSubStatement)); }
private SubStatementWithRowNumber CreateSubStatementWithRowNumber( SqlStatementBuilder sqlStatementBuilder, UniqueIdentifierGenerator generator, ISqlPreparationStage stage, ISqlPreparationContext context) { var originalSelectProjection = sqlStatementBuilder.SelectProjection; IncludeRowNumberInSelectProjection(sqlStatementBuilder, stage, context); // Orderings are not allowed in SQL substatements unless a TOP expression is present if (sqlStatementBuilder.TopExpression == null) { sqlStatementBuilder.Orderings.Clear(); } sqlStatementBuilder.RecalculateDataInfo(originalSelectProjection); // No NamedExpression required here because the row number tuple's items already have named members var newSqlStatement = sqlStatementBuilder.GetStatementAndResetBuilder(); var tableInfo = new ResolvedSubStatementTableInfo(generator.GetUniqueIdentifier("q"), newSqlStatement); var sqlTable = new SqlTable(tableInfo, JoinSemantics.Inner); var originalProjectionSelector = Expression.MakeMemberAccess( new SqlTableReferenceExpression(sqlTable), newSqlStatement.SelectProjection.Type.GetProperty("Key")); var rowNumberSelector = Expression.MakeMemberAccess( new SqlTableReferenceExpression(sqlTable), newSqlStatement.SelectProjection.Type.GetProperty("Value")); return(new SubStatementWithRowNumber(sqlTable, originalProjectionSelector, rowNumberSelector)); }
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 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 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 newStatement = _stage.ApplySelectionContext(tableInfo.SqlStatement, _expressionContext, _mappingResolutionContext); if (newStatement != tableInfo.SqlStatement) { return(new ResolvedSubStatementTableInfo(tableInfo.TableAlias, newStatement)); } return(tableInfo); }
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 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 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 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 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 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 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 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 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 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 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 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)); }
public void ApplyContext_TableInfo() { 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 result = _stage.ApplyContext(tableInfo, SqlExpressionContext.ValueRequired, _mappingResolutionContext); Assert.That(result, Is.Not.SameAs(tableInfo)); Assert.That(((ResolvedSubStatementTableInfo)result).SqlStatement.SelectProjection, Is.TypeOf(typeof(SqlConvertedBooleanExpression))); Assert.That( ((ConstantExpression)((SqlConvertedBooleanExpression)((ResolvedSubStatementTableInfo)result).SqlStatement.SelectProjection).Expression). Value, Is.EqualTo(1)); }
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 ResolveSubStatementReferenceExpression_CreatesNewExpressionWithReferences_ForNewExpressions_WithoutMembers() { var newExpression = Expression.New( TypeForNewExpression.GetConstructor(typeof(int)), new[] { new NamedExpression("const", Expression.Constant(0)) }); 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("m0", new SqlColumnDefinitionExpression(typeof(int), "q0", "const", false)) }); SqlExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
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 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 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)); }