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