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