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