public virtual void GenerateTextForFromTable (ISqlCommandBuilder commandBuilder, SqlTable table, bool isFirstTable)
{
ArgumentUtility.CheckNotNull ("commandBuilder", commandBuilder);
ArgumentUtility.CheckNotNull ("table", table);
SqlTableAndJoinTextGenerator.GenerateSql (table, commandBuilder, this, isFirstTable);
}
public void SetUp ()
{
_context = new MappingResolutionContext();
_entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), null, "c");
_groupingSelectExpression = new SqlGroupingSelectExpression (Expression.Constant ("key"), Expression.Constant ("element"));
_sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
}
public void ToString_SqlTableWithUnresolvedTableInfo ()
{
var sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Left);
var expression = new SqlTableReferenceExpression (sqlTable);
var result = expression.ToString();
Assert.That (result, Is.EqualTo ("TABLE-REF(UnresolvedTableInfo(Cook))"));
}
public void JoinSemantic ()
{
var sqlTableWithInnerJoinSemantic = new SqlTable (_oldTableInfo, JoinSemantics.Inner);
var sqlTableWithLeftJoinSemantic = new SqlTable (_oldTableInfo, JoinSemantics.Left);
Assert.That (sqlTableWithInnerJoinSemantic.JoinSemantics, Is.EqualTo (JoinSemantics.Inner));
Assert.That (sqlTableWithLeftJoinSemantic.JoinSemantics, Is.EqualTo (JoinSemantics.Left));
}
public static void GenerateSql (SqlTable sqlTable, ISqlCommandBuilder commandBuilder, ISqlGenerationStage stage, bool isFirstTable)
{
ArgumentUtility.CheckNotNull ("sqlTable", sqlTable);
ArgumentUtility.CheckNotNull ("commandBuilder", commandBuilder);
ArgumentUtility.CheckNotNull ("stage", stage);
GenerateTextForSqlTable (new SqlTableAndJoinTextGenerator (commandBuilder, stage), sqlTable, commandBuilder, isFirstTable);
GenerateSqlForJoins (sqlTable, commandBuilder, new SqlTableAndJoinTextGenerator (commandBuilder, stage));
}
public FromExpressionInfo (SqlTable sqlTable, Ordering[] extractedOrderings, Expression itemSelector, Expression whereCondition)
{
ArgumentUtility.CheckNotNull ("sqlTable", sqlTable);
ArgumentUtility.CheckNotNull ("extractedOrderings", extractedOrderings);
ArgumentUtility.CheckNotNull ("itemSelector", itemSelector);
SqlTable = sqlTable;
ExtractedOrderings = Array.AsReadOnly(extractedOrderings);
ItemSelector = itemSelector;
WhereCondition = whereCondition;
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage>();
_mappingResolutionContext = new MappingResolutionContext();
_visitor = new TestableSqlStatementResolver (_stageMock, _mappingResolutionContext);
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook));
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable (_unresolvedTableInfo);
_fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook));
}
public void SetUp ()
{
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_source = ExpressionHelper.CreateMainFromClause<Cook>();
var source = new UnresolvedTableInfo (typeof (int));
_sqlTable = new SqlTable (source, JoinSemantics.Inner);
_parentContext = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
_parentSource = ExpressionHelper.CreateMainFromClause<Cook>();
_parentSqlTable = new SqlTable (new UnresolvedTableInfo (typeof (int)), JoinSemantics.Inner);
_sqlStatementBuilder = new SqlStatementBuilder();
_contextWithParent = new SqlPreparationContext (_parentContext, _sqlStatementBuilder);
}
public void SetUp ()
{
_resolverMock = MockRepository.GenerateMock<IMappingResolver>();
_uniqueIdentifierGenerator = new UniqueIdentifierGenerator();
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo (typeof (Cook));
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable (_unresolvedTableInfo);
_fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo (typeof (Cook));
_stage = new DefaultMappingResolutionStage (_resolverMock, _uniqueIdentifierGenerator);
_mappingResolutionContext = new MappingResolutionContext();
}
public void SetUp ()
{
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
var querySource = ExpressionHelper.CreateMainFromClause<Cook>();
_sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner);
_context.AddExpressionMapping (new QuerySourceReferenceExpression(querySource), new SqlTableReferenceExpression(_sqlTable));
_querySourceReferenceExpression = new QuerySourceReferenceExpression (querySource);
_stage = new DefaultSqlPreparationStage (
CompoundMethodCallTransformerProvider.CreateDefault(), ResultOperatorHandlerRegistry.CreateDefault(), new UniqueIdentifierGenerator());
}
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 SetUp ()
{
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage>();
_resolverMock = MockRepository.GenerateStrictMock<IMappingResolver>();
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo (typeof (Cook));
_mappingResolutionContext = new MappingResolutionContext();
_generator = new UniqueIdentifierGenerator();
_entityIdentityResolverMock = MockRepository.GenerateStrictMock<IEntityIdentityResolver> ();
_compoundComparisonSplitterMock = MockRepository.GenerateStrictMock<ICompoundExpressionComparisonSplitter> ();
_namedExpressionCombinerMock = MockRepository.GenerateStrictMock<INamedExpressionCombiner>();
_groupAggregateSimplifierMock = MockRepository.GenerateStrictMock<IGroupAggregateSimplifier>();
_visitor = CreateVisitor (true);
}
public void ResolveReference ()
{
var sqlTable = new SqlTable (_tableInfo, JoinSemantics.Inner);
var generator = new UniqueIdentifierGenerator ();
var resolverMock = MockRepository.GenerateStrictMock<IMappingResolver> ();
var mappingResolutionContext = new MappingResolutionContext ();
resolverMock.Replay ();
var result = _tableInfo.ResolveReference (sqlTable, resolverMock, mappingResolutionContext, generator);
Assert.That (result, Is.TypeOf (typeof (SqlColumnDefinitionExpression)));
Assert.That (((SqlColumnDefinitionExpression) result).ColumnName, Is.EqualTo ("test"));
Assert.That (((SqlColumnDefinitionExpression) result).OwningTableAlias, Is.EqualTo (_tableInfo.TableAlias));
Assert.That (result.Type, Is.EqualTo (typeof (int)));
}
public void SetUp ()
{
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo();
_entityExpression = new SqlEntityDefinitionExpression (
typeof(string),
"t", null,
e => e.GetColumn (typeof (int), "ID", true),
new SqlColumnExpression[]
{
new SqlColumnDefinitionExpression (typeof (int), "t", "ID", true),
new SqlColumnDefinitionExpression (typeof (int), "t", "Name", false),
new SqlColumnDefinitionExpression (typeof (int), "t", "City", false)
});
_stageMock = MockRepository.GenerateStrictMock<ISqlGenerationStage>();
_generator = new TestableSqlStatementTextGenerator (_stageMock);
_commandBuilder = new SqlCommandBuilder();
}
public void GenerateSql_ForJoinedTable ()
{
var originalTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Kitchen), "KitchenTable", "t1"), JoinSemantics.Inner);
var kitchenCookMember = typeof (Kitchen).GetProperty ("Cook");
var joinedTable = originalTable.GetOrAddLeftJoin (CreateResolvedJoinInfo (typeof (Cook), "t1", "ID", "CookTable", "t2", "FK"), kitchenCookMember);
joinedTable.JoinInfo = CreateResolvedJoinInfo (typeof (Cook), "t1", "ID", "CookTable", "t2", "FK");
_stageMock
.Expect (mock => mock.GenerateTextForJoinCondition (_commandBuilder, ((ResolvedJoinInfo) joinedTable.JoinInfo).JoinCondition))
.WhenCalled (mi => ((SqlCommandBuilder) mi.Arguments[0]).Append ("([t1].[ID] = [t2].[FK])"));
_stageMock.Replay();
SqlTableAndJoinTextGenerator.GenerateSql (originalTable, _commandBuilder, _stageMock, true);
_stageMock.VerifyAllExpectations();
Assert.That (
_commandBuilder.GetCommandText(), Is.EqualTo ("[KitchenTable] AS [t1] LEFT OUTER JOIN [CookTable] AS [t2] ON ([t1].[ID] = [t2].[FK])"));
}
public void SetUp ()
{
_dataInfo = new StreamedScalarValueInfo (typeof (int));
_resolvedElementExpressionReference = new SqlColumnDefinitionExpression (typeof (string), "q0", "element", false);
_resolvedSelectProjection = new NamedExpression (
null,
new AggregationExpression (typeof (int), _resolvedElementExpressionReference, AggregationModifier.Min));
_associatedGroupingSelectExpression = new SqlGroupingSelectExpression (
new NamedExpression ("key", Expression.Constant ("k")),
new NamedExpression ("element", Expression.Constant ("e")));
_resolvedJoinedGroupingSubStatement = SqlStatementModelObjectMother.CreateSqlStatement (_associatedGroupingSelectExpression);
_resolvedJoinedGroupingTable = new SqlTable (
new ResolvedJoinedGroupingTableInfo (
"q1",
_resolvedJoinedGroupingSubStatement,
_associatedGroupingSelectExpression,
"q0"), JoinSemantics.Inner);
_simplifiableResolvedSqlStatement = new SqlStatement (
_dataInfo,
_resolvedSelectProjection,
new[] { _resolvedJoinedGroupingTable },
null,
null,
new Ordering[0],
null,
false,
Expression.Constant (0),
Expression.Constant (0));
_simplifiableUnresolvedProjection = new AggregationExpression (
typeof (int),
new SqlTableReferenceExpression (_resolvedJoinedGroupingTable),
AggregationModifier.Count);
_stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage> ();
_context = new MappingResolutionContext();
_groupAggregateSimplifier = new GroupAggregateSimplifier (_stageMock, _context);
}
public void ResolveReference ()
{
var sqlTable = new SqlTable (_tableInfo, JoinSemantics.Inner);
var fakeResult = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook));
var generator = new UniqueIdentifierGenerator();
var resolverMock = MockRepository.GenerateStrictMock<IMappingResolver>();
var mappingResolutionContext = new MappingResolutionContext();
resolverMock
.Expect (mock => mock.ResolveSimpleTableInfo (_tableInfo, generator))
.Return (fakeResult);
resolverMock.Replay ();
var result = _tableInfo.ResolveReference (sqlTable, resolverMock, mappingResolutionContext, generator);
resolverMock.VerifyAllExpectations ();
Assert.That (result, Is.SameAs (fakeResult));
Assert.That (mappingResolutionContext.GetSqlTableForEntityExpression ((SqlEntityExpression) result), Is.SameAs (sqlTable));
}
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);
}
public void SetUp ()
{
_stageMock = MockRepository.GenerateMock<ISqlPreparationStage> ();
_generator = new UniqueIdentifierGenerator ();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext ();
_handler = new SkipResultOperatorHandler ();
_sqlTable = new SqlTable (new UnresolvedTableInfo (typeof (Cook)), JoinSemantics.Inner);
_selectProjection = new SqlTableReferenceExpression (_sqlTable);
_ordering = new Ordering (Expression.Constant (7), OrderingDirection.Asc);
_sqlStatementBuilder = new SqlStatementBuilder
{
SelectProjection = _selectProjection,
DataInfo = new StreamedSequenceInfo (typeof (Cook[]), Expression.Constant (new Cook ())),
SqlTables = { _sqlTable },
};
_tupleCtor = _tupleCtor = typeof (KeyValuePair<Cook, int>).GetConstructor (new[] { typeof (Cook), typeof (int) });
}
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 sqlStatement1 = new SqlStatement (
dataInfo,
selectProjection,
new[] { sqlTable },
whereCondition,
groupByExpression,
new[] { ordering },
topExpression,
isDistinctQuery,
rowNumberSelector,
currentRowNumberOffset);
var sqlStatement2 = new SqlStatement (
dataInfo,
selectProjection,
new[] { sqlTable },
whereCondition,
groupByExpression,
new[] { ordering },
topExpression,
isDistinctQuery,
rowNumberSelector,
currentRowNumberOffset);
Assert.That (sqlStatement1.Equals (sqlStatement2), Is.True);
}
private static void GenerateTextForSqlTable (ITableInfoVisitor visitor, SqlTable sqlTable, ISqlCommandBuilder commandBuilder, bool isFirstTable)
{
if (sqlTable.JoinSemantics == JoinSemantics.Left)
{
if (isFirstTable)
commandBuilder.Append ("(SELECT NULL AS [Empty]) AS [Empty]");
commandBuilder.Append (" OUTER APPLY ");
}
else
{
if (!isFirstTable)
{
commandBuilder.Append (" CROSS ");
if (sqlTable.TableInfo is ResolvedSimpleTableInfo)
commandBuilder.Append ("JOIN ");
else
commandBuilder.Append ("APPLY ");
}
}
sqlTable.TableInfo.Accept (visitor);
}
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 sqlStatement = new SqlStatement (
new TestStreamedValueInfo (typeof (int)),
selectProjection,
new[] { sqlTable },
whereCondition,
groupExpression,
new[] { ordering },
topExpression,
isDistinctQuery,
rowNumberSelector,
currentRowNumberOffset);
var testedBuilder = new SqlStatementBuilder (sqlStatement);
Assert.That (testedBuilder.SelectProjection, Is.SameAs (selectProjection));
Assert.That (testedBuilder.TopExpression, Is.SameAs (topExpression));
Assert.That (testedBuilder.SqlTables[0], Is.SameAs (sqlTable));
Assert.That (testedBuilder.Orderings[0], Is.SameAs (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));
}
public void VisitSqlTableReferenceExpression_Grouping ()
{
var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (IGrouping<string, int>), "test", "t0"), JoinSemantics.Inner);
var expression = new SqlTableReferenceExpression (sqlTable);
var result = SqlPreparationFromExpressionVisitor.AnalyzeFromExpression (
expression, _stageMock, _generator, _methodCallTransformerProvider, _context, null);
Assert.That (result.SqlTable, Is.Not.SameAs (sqlTable));
Assert.That (result.WhereCondition, Is.Null);
Assert.That (result.ExtractedOrderings, Is.Empty);
var expectedItemSelector = new SqlTableReferenceExpression (result.SqlTable);
SqlExpressionTreeComparer.CheckAreEqualTrees (expectedItemSelector, result.ItemSelector);
var tableInfo = ((SqlTable) result.SqlTable).TableInfo;
Assert.That (tableInfo, Is.TypeOf (typeof (UnresolvedGroupReferenceTableInfo)));
var castTableInfo = (UnresolvedGroupReferenceTableInfo) tableInfo;
Assert.That (castTableInfo.ItemType, Is.SameAs (typeof (int)));
Assert.That (castTableInfo.ReferencedGroupSource, Is.SameAs (sqlTable));
Assert.That (result.SqlTable.JoinSemantics, Is.EqualTo (JoinSemantics.Inner));
}
private FromExpressionInfo GetFromExpressionInfoForSubStatement (SqlStatement originalSqlStatement, SqlTable tableWithSubStatement)
{
var expressionsFromSubStatement =
TupleExpressionBuilder.GetExpressionsFromTuple (new SqlTableReferenceExpression (tableWithSubStatement)).ToArray();
var projectionFromSubStatement = expressionsFromSubStatement.First (); // this was the original projection
var orderingsFromSubStatement = expressionsFromSubStatement
.Skip (1) // ignore original projection
.Select ((expr, i) => new Ordering (expr, originalSqlStatement.Orderings[i].OrderingDirection));
return new FromExpressionInfo (tableWithSubStatement, orderingsFromSubStatement.ToArray (), projectionFromSubStatement, null);
}
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 builder = new SqlStatementBuilder
{
DataInfo = dataInfo,
SelectProjection = selectProjection,
SqlTables = { sqlTable1, sqlTable2 },
Orderings = { ordering },
WhereCondition = whereCondition,
TopExpression = topExpression,
IsDistinctQuery = true,
GroupByExpression = groupExpression
};
var result = builder.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"));
}
public static SqlTable CreateSqlTable_WithResolvedTableInfo (Type type, string tableName, string tableAlias)
{
var resolvedTableInfo = new ResolvedSimpleTableInfo (type, tableName, tableAlias);
var sqlTable = new SqlTable (resolvedTableInfo, JoinSemantics.Inner);
return sqlTable;
}
public static SqlTable CreateSqlTable_WithUnresolvedTableInfo (Type type)
{
var unresolvedTableInfo = new UnresolvedTableInfo (type);
var sqlTable = new SqlTable (unresolvedTableInfo, JoinSemantics.Inner);
return sqlTable;
}
public static SqlTable CreateSqlTable (ITableInfo tableInfo)
{
var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner);
return sqlTable;
}
public Expression VisitSqlTableReferenceExpression (SqlTableReferenceExpression expression)
{
ArgumentUtility.CheckNotNull ("expression", expression);
var tableInfo = new UnresolvedGroupReferenceTableInfo (expression.SqlTable);
var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner);
FromExpressionInfo = new FromExpressionInfo (sqlTable, new Ordering[0], new SqlTableReferenceExpression (sqlTable), null);
return expression;
}
public void ToString_SingleTable ()
{
var dataInfo = new TestStreamedValueInfo (typeof (int));
var selectProjection = Expression.Constant (1);
var sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner);
var builder = new SqlStatementBuilder
{
DataInfo = dataInfo,
SelectProjection = selectProjection,
SqlTables = { sqlTable },
};
var result = builder.ToString ();
Assert.That (result, Is.EqualTo ("SELECT 1 FROM [CookTable] [c]"));
}
