public void Equals_DifferentSetOperationCombinedStatements() { var dataInfo = new TestStreamedValueInfo(typeof(int)); var selectProjection = Expression.Constant(1); var setOperationCombinedStatement1 = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var setOperationCombinedStatement2 = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var sqlStatement1 = new SqlStatement( dataInfo, selectProjection, new SqlTable[0], null, null, new Ordering[0], null, false, null, null, new[] { setOperationCombinedStatement1 }); var sqlStatement2 = new SqlStatement( dataInfo, selectProjection, new SqlTable[0], null, null, new Ordering[0], null, false, null, null, new[] { setOperationCombinedStatement2 }); Assert.That(sqlStatement1.Equals(sqlStatement2), Is.False); }
public void ToString_AllProperties() { var dataInfo = new TestStreamedValueInfo(typeof(int)); var selectProjection = Expression.Constant(1); var sqlTable1 = new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Inner); var sqlTable2 = new SqlTable(new ResolvedSimpleTableInfo(typeof(Kitchen), "KitchenTable", "k"), JoinSemantics.Left); var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Asc); var whereCondition = Expression.Constant(true); var topExpression = Expression.Constant(10); var groupExpression = Expression.Constant("group"); var setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var sqlStatement = new SqlStatement( dataInfo, selectProjection, new[] { sqlTable1, sqlTable2 }, whereCondition, groupExpression, new[] { ordering }, topExpression, true, null, null, new[] { setOperationCombinedStatement }); var result = sqlStatement.ToString(); Assert.That( result, Is.EqualTo( "SELECT DISTINCT TOP (10) 1 FROM [CookTable] [c], [KitchenTable] [k] WHERE True GROUP BY \"group\" ORDER BY \"ordering\" ASC UNION (" + setOperationCombinedStatement.SqlStatement + ")")); }
public void GetStatementAndResetBuilder() { var statementBuilder = new SqlStatementBuilder { DataInfo = new TestStreamedValueInfo(typeof(Cook)), TopExpression = ExpressionHelper.CreateExpression(), IsDistinctQuery = true, SelectProjection = new AggregationExpression(typeof(int), Expression.Constant(1), AggregationModifier.Min), SqlTables = { new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Inner) }, WhereCondition = Expression.Constant(true), RowNumberSelector = Expression.Constant("selector"), CurrentRowNumberOffset = Expression.Constant(1), GroupByExpression = Expression.Constant("group"), Orderings = { new Ordering(Expression.Constant("order"), OrderingDirection.Desc) }, SetOperationCombinedStatements = { SqlStatementModelObjectMother.CreateSetOperationCombinedStatement() } }; var sqlStatement = statementBuilder.GetSqlStatement(); var result = statementBuilder.GetStatementAndResetBuilder(); Assert.That(result, Is.Not.SameAs(sqlStatement)); Assert.That(result, Is.EqualTo(sqlStatement)); 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); Assert.That(statementBuilder.SetOperationCombinedStatements, Is.Empty); }
public void DifferentType() { var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(); var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left); var newJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenRestaurant(); sqlJoinedTable.JoinInfo = newJoinInfo; }
public void Equals_ObjectIsNull() { var dataInfo = new TestStreamedValueInfo(typeof(int)); var selectProjection = Expression.Constant(1); var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); Assert.That(sqlStatement.Equals(null), Is.False); }
public new void ToString() { var joinedTable = new SqlJoinedTable(SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(), JoinSemantics.Left); var result = joinedTable.ToString(); Assert.That(result, Is.EqualTo("LEFT JOIN Kitchen.Cook")); }
public void To_String() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook)); var expression = new SqlSubStatementExpression(sqlStatement); var result = expression.ToString(); Assert.That(result, Is.EqualTo("(SELECT [t0] FROM [Table] [t])")); }
public void CreateExpression_WithSqlTables() { var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()); var sqlStatement = sqlStatementBuilder.GetSqlStatement(); var result = sqlStatement.CreateExpression(); Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression))); Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.SameAs(sqlStatement)); }
public void GetOrAddJoin_NewEntry() { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)); var unresolvedJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_CookSubstitution(); var joinedTable = sqlTable.GetOrAddLeftJoin(unresolvedJoinInfo, unresolvedJoinInfo.MemberInfo); Assert.That(joinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Left)); Assert.That(joinedTable.JoinInfo, Is.SameAs(unresolvedJoinInfo)); }
public void CreateExpression_WithNoSqlTablesAndNoDistinctQueryAndNoAggregationModifier() { var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()); sqlStatementBuilder.SqlTables.Clear(); var sqlStatement = sqlStatementBuilder.GetSqlStatement(); var result = sqlStatement.CreateExpression(); Assert.That(result, Is.SameAs(sqlStatement.SelectProjection)); }
public void ToString_WithJoins() { var joinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(); var memberInfo = typeof(Kitchen).GetProperty("Cook"); _sqlTable.GetOrAddLeftJoin(joinInfo, memberInfo); var result = _sqlTable.ToString(); Assert.That(result, Is.EqualTo("[table1] [t] LEFT JOIN Kitchen.Cook")); }
public void ToString_WithJoins() { var joinedTable = new SqlJoinedTable(SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(), JoinSemantics.Left); var joinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(); var memberInfo = typeof(Kitchen).GetProperty("Cook"); joinedTable.GetOrAddLeftJoin(joinInfo, memberInfo); var result = joinedTable.ToString(); Assert.That(result, Is.EqualTo("LEFT JOIN Kitchen.Cook LEFT JOIN Kitchen.Cook")); }
public void SameType() { var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(); var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left); var newJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_CookSubstitution(); sqlJoinedTable.JoinInfo = newJoinInfo; Assert.That(sqlJoinedTable.JoinInfo.ItemType, Is.EqualTo(newJoinInfo.ItemType)); Assert.That(sqlJoinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Left)); }
public void CreateExpression_IsDistinctQuery() { var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()); sqlStatementBuilder.SqlTables.Clear(); sqlStatementBuilder.IsDistinctQuery = true; var sqlStatement = sqlStatementBuilder.GetSqlStatement(); var result = sqlStatement.CreateExpression(); Assert.That(result, Is.TypeOf(typeof(SqlSubStatementExpression))); Assert.That(((SqlSubStatementExpression)result).SqlStatement, Is.SameAs(sqlStatement)); }
public void CreateExpression_HasAggregationModifier() { var sqlStatementBuilder = new SqlStatementBuilder(SqlStatementModelObjectMother.CreateSqlStatement()); sqlStatementBuilder.SqlTables.Clear(); var selectProjection = new AggregationExpression(typeof(double), sqlStatementBuilder.SelectProjection, AggregationModifier.Max); sqlStatementBuilder.SelectProjection = selectProjection; var sqlStatement = sqlStatementBuilder.GetSqlStatement(); var result = sqlStatement.CreateExpression(); Assert.That(result, Is.SameAs(selectProjection)); }
public void GetOrAddJoin_GetEntry_Twice() { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)); var memberInfo = typeof(Cook).GetProperty("FirstName"); var unresolvedJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_CookSubstitution(); var joinedTable1 = sqlTable.GetOrAddLeftJoin(unresolvedJoinInfo, memberInfo); var originalJoinInfo = joinedTable1.JoinInfo; var joinedTable2 = sqlTable.GetOrAddLeftJoin(originalJoinInfo, memberInfo); Assert.That(joinedTable2, Is.SameAs(joinedTable1)); Assert.That(joinedTable2.JoinInfo, Is.SameAs(originalJoinInfo)); }
public void Accept_VisitorSupportingExpressionType() { var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(); var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left); var visitorMock = MockRepository.GenerateMock <ISqlTableBaseVisitor> (); visitorMock.Expect(mock => mock.VisitSqlJoinedTable(sqlJoinedTable)); visitorMock.Replay(); sqlJoinedTable.Accept(visitorMock); visitorMock.VerifyAllExpectations(); Assert.That(sqlJoinedTable.JoinSemantics, Is.EqualTo(JoinSemantics.Left)); }
public void Accept_ITableInfoVisitor() { var oldJoinInfo = SqlStatementModelObjectMother.CreateUnresolvedJoinInfo_KitchenCook(); var sqlJoinedTable = new SqlJoinedTable(oldJoinInfo, JoinSemantics.Left); var fakeResult = new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"); var visitorMock = MockRepository.GenerateMock <ITableInfoVisitor>(); visitorMock .Expect(mock => mock.VisitSqlJoinedTable(sqlJoinedTable)) .Return(fakeResult); var result = ((ITableInfo)sqlJoinedTable).Accept(visitorMock); visitorMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(fakeResult)); }
public void GetSqlStatement() { var statementBuilder = new SqlStatementBuilder(); statementBuilder.DataInfo = new TestStreamedValueInfo(typeof(int)); var constantExpression = Expression.Constant("test"); statementBuilder.SelectProjection = constantExpression; var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(); statementBuilder.SqlTables.Add(sqlTable); var result = statementBuilder.GetSqlStatement(); Assert.That(result.SelectProjection, Is.SameAs(constantExpression)); Assert.That(result.SqlTables.Count, Is.EqualTo(1)); Assert.That(result.SqlTables[0], Is.SameAs(sqlTable)); }
public void GetSqlStatement_CheckProperties() { var dataInfo = new TestStreamedValueInfo(typeof(Cook)); var topExpression = ExpressionHelper.CreateExpression(); var isDistinctQuery = BooleanObjectMother.GetRandomBoolean(); var selectProjection = new AggregationExpression(typeof(int), Expression.Constant(1), AggregationModifier.Min); var whereCondition = Expression.Constant(true); 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 setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var statementBuilder = new SqlStatementBuilder { DataInfo = dataInfo, TopExpression = topExpression, IsDistinctQuery = isDistinctQuery, SelectProjection = selectProjection, SqlTables = { sqlTable }, WhereCondition = whereCondition, RowNumberSelector = rowNumberSelector, CurrentRowNumberOffset = currentRowNumberOffset, GroupByExpression = groupExpression, Orderings = { ordering }, SetOperationCombinedStatements = { setOperationCombinedStatement } }; var sqlStatement = statementBuilder.GetSqlStatement(); Assert.That(sqlStatement.DataInfo, Is.SameAs(dataInfo)); Assert.That(sqlStatement.TopExpression, Is.SameAs(topExpression)); Assert.That(sqlStatement.IsDistinctQuery, Is.EqualTo(isDistinctQuery)); Assert.That(sqlStatement.SelectProjection, Is.SameAs(selectProjection)); Assert.That(sqlStatement.SqlTables, Is.EqualTo(new[] { sqlTable })); Assert.That(sqlStatement.Orderings, Is.EqualTo(new[] { ordering })); Assert.That(sqlStatement.WhereCondition, Is.SameAs(whereCondition)); Assert.That(sqlStatement.RowNumberSelector, Is.SameAs(rowNumberSelector)); Assert.That(sqlStatement.CurrentRowNumberOffset, Is.SameAs(currentRowNumberOffset)); Assert.That(sqlStatement.GroupByExpression, Is.SameAs(groupExpression)); Assert.That(sqlStatement.SetOperationCombinedStatements, Is.EqualTo(new[] { setOperationCombinedStatement })); }
public void Equals_EqualStatementsWithAllMembers() { var dataInfo = new TestStreamedValueInfo(typeof(int)); var isDistinctQuery = BooleanObjectMother.GetRandomBoolean(); var selectProjection = Expression.Constant(1); var sqlTable = new SqlTable(new ResolvedSimpleTableInfo(typeof(Cook), "CookTable", "c"), JoinSemantics.Inner); var ordering = new Ordering(Expression.Constant("ordering"), OrderingDirection.Asc); var whereCondition = Expression.Constant(true); var topExpression = Expression.Constant("top"); var rowNumberSelector = Expression.Constant("selector"); var currentRowNumberOffset = Expression.Constant(1); var groupByExpression = Expression.Constant("group"); var setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var sqlStatement1 = new SqlStatement( dataInfo, selectProjection, new[] { sqlTable }, whereCondition, groupByExpression, new[] { ordering }, topExpression, isDistinctQuery, rowNumberSelector, currentRowNumberOffset, new[] { setOperationCombinedStatement }); var sqlStatement2 = new SqlStatement( dataInfo, selectProjection, new[] { sqlTable }, whereCondition, groupByExpression, new[] { ordering }, topExpression, isDistinctQuery, rowNumberSelector, currentRowNumberOffset, new[] { setOperationCombinedStatement }); Assert.That(sqlStatement1.Equals(sqlStatement2), Is.True); }
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 setOperationCombinedStatement = SqlStatementModelObjectMother.CreateSetOperationCombinedStatement(); var sqlStatement = new SqlStatement( new TestStreamedValueInfo(typeof(int)), selectProjection, new[] { sqlTable }, whereCondition, groupExpression, new[] { ordering }, topExpression, isDistinctQuery, rowNumberSelector, currentRowNumberOffset, new[] { setOperationCombinedStatement }); var testedBuilder = new SqlStatementBuilder(sqlStatement); Assert.That(testedBuilder.SelectProjection, Is.SameAs(selectProjection)); Assert.That(testedBuilder.TopExpression, Is.SameAs(topExpression)); Assert.That(testedBuilder.SqlTables, Is.EqualTo(new[] { sqlTable })); Assert.That(testedBuilder.Orderings, Is.EqualTo(new[] { 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)); Assert.That(testedBuilder.SetOperationCombinedStatements, Is.EqualTo(new[] { setOperationCombinedStatement })); }
public void SetUp() { _sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); _expression = new SqlSubStatementExpression(_sqlStatement); }
public void Equals_ObjectIsNotASqlStatement() { var sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement(); Assert.That(sqlStatement.Equals(new object()), Is.False); }