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 HandleResultOperator () { var keySelector = new SqlColumnDefinitionExpression(typeof(string), "c", "Name", false); var elementSelector = Expression.Constant ("elementSelector"); var resultOperator = new GroupResultOperator ("itemName", keySelector, elementSelector); _stageMock .Expect (mock => mock.PrepareResultOperatorItemExpression (keySelector, _context)) .Return (keySelector); _stageMock .Expect (mock => mock.PrepareResultOperatorItemExpression (elementSelector, _context)) .Return (elementSelector); _stageMock.Replay(); _handler.HandleResultOperator (resultOperator, _sqlStatementBuilder, _generator, _stageMock, _context); _stageMock.VerifyAllExpectations(); Assert.That (_sqlStatementBuilder.GroupByExpression, Is.SameAs (keySelector)); var expectedSelectProjection = new SqlGroupingSelectExpression ( new NamedExpression ("key", keySelector), new NamedExpression ("element", elementSelector)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedSelectProjection, _sqlStatementBuilder.SelectProjection); Assert.That ( _sqlStatementBuilder.DataInfo.DataType, Is.EqualTo (typeof (IQueryable<>).MakeGenericType (typeof (IGrouping<,>).MakeGenericType (typeof (string), typeof (string))))); }
public void AddGroupReferenceMapping (SqlGroupingSelectExpression groupingSelectExpression, SqlTableBase sqlTable) { ArgumentUtility.CheckNotNull ("groupingSelectExpression", groupingSelectExpression); ArgumentUtility.CheckNotNull ("sqlTable", sqlTable); _groupReferenceMapping[groupingSelectExpression] = sqlTable; }
public virtual Expression VisitSqlGroupingSelectExpression (SqlGroupingSelectExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var groupExpressions = new[] { expression.KeyExpression }.Concat (expression.AggregationExpressions); CommandBuilder.AppendSeparated (", ", groupExpressions, (cb, exp) => VisitExpression (exp)); return expression; }
public SqlTableBase GetReferencedGroupSource (SqlGroupingSelectExpression groupingSelectExpression) { ArgumentUtility.CheckNotNull ("groupingSelectExpression", groupingSelectExpression); SqlTableBase result; if (_groupReferenceMapping.TryGetValue (groupingSelectExpression, out result)) return result; var message = string.Format ( "No associated table found for grouping select expression '{0}'.", FormattingExpressionTreeVisitor.Format (groupingSelectExpression)); throw new InvalidOperationException (message); }
public void SetUp () { _keyExpression = Expression.Constant ("key"); _elementExpression = Expression.Constant ("element"); _aggregateExpression1 = Expression.Constant ("agg1"); _aggregateExpression2 = Expression.Constant ("agg2"); _sqlGroupingSelectExpression = new SqlGroupingSelectExpression ( _keyExpression, _elementExpression, new [] { _aggregateExpression1 }); }
protected override Expression VisitChildren(ExpressionTreeVisitor visitor) { ArgumentUtility.CheckNotNull("visitor", visitor); var newKeyExpression = visitor.VisitExpression(KeyExpression); var newElementExpression = visitor.VisitExpression(ElementExpression); var originalAggregationExpressions = AggregationExpressions; var newAggregationExpressions = visitor.VisitAndConvert(originalAggregationExpressions, "VisitChildren"); if (newKeyExpression != KeyExpression || newElementExpression != ElementExpression || newAggregationExpressions != originalAggregationExpressions) { var newSqlGroupingSelectExpression = new SqlGroupingSelectExpression(newKeyExpression, newElementExpression, newAggregationExpressions); return(newSqlGroupingSelectExpression); } return(this); }
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 Expression VisitSqlGroupingSelectExpression (SqlGroupingSelectExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var referenceToKeyExpression = ResolveChildExpression (expression.KeyExpression); var referenceToElementExpression = ResolveChildExpression (expression.ElementExpression); var referenceToAggregationExpressions = expression.AggregationExpressions.Select (expr => ResolveChildExpression (expr)); var newGroupingExpression = SqlGroupingSelectExpression.CreateWithNames (referenceToKeyExpression, referenceToElementExpression); foreach (var aggregationExpression in referenceToAggregationExpressions) newGroupingExpression.AddAggregationExpressionWithName (aggregationExpression); _context.AddGroupReferenceMapping (newGroupingExpression, _sqlTable); return newGroupingExpression; }
protected override Expression VisitChildren (ExpressionTreeVisitor visitor) { ArgumentUtility.CheckNotNull ("visitor", visitor); var newKeyExpression = visitor.VisitExpression (KeyExpression); var newElementExpression = visitor.VisitExpression (ElementExpression); var originalAggregationExpressions = AggregationExpressions; var newAggregationExpressions = visitor.VisitAndConvert (originalAggregationExpressions, "VisitChildren"); if (newKeyExpression != KeyExpression || newElementExpression != ElementExpression || newAggregationExpressions != originalAggregationExpressions) { var newSqlGroupingSelectExpression = new SqlGroupingSelectExpression (newKeyExpression, newElementExpression, newAggregationExpressions); return newSqlGroupingSelectExpression; } return this; }
public override Expression VisitSqlGroupingSelectExpression (SqlGroupingSelectExpression expression) { throw new NotSupportedException ( "This SQL generator does not support queries returning groupings that result from a GroupBy operator because SQL is not suited to " + "efficiently return " + "LINQ groupings. Use 'group into' and either return the items of the groupings by feeding them into an additional from clause, or perform " + "an aggregation on the groupings. " + Environment.NewLine + Environment.NewLine + "Eg., instead of: " + Environment.NewLine + "'from c in Cooks group c.ID by c.Name', " + Environment.NewLine + "write: " + Environment.NewLine + "'from c in Cooks group c.ID by c.Name into groupedCooks " + Environment.NewLine + " from c in groupedCooks select new { Key = groupedCooks.Key, Item = c }', " + Environment.NewLine + "or: " + Environment.NewLine + "'from c in Cooks group c.ID by c.Name into groupedCooks " + Environment.NewLine + " select new { Key = groupedCooks.Key, Count = groupedCooks.Count() }'."); }
public Expression VisitSqlGroupingSelectExpression (SqlGroupingSelectExpression expression) { var newKeyExpression = ApplyValueContext (expression.KeyExpression); var newElementExpression = ApplyValueContext (expression.ElementExpression); var newAggregationExpressions = expression.AggregationExpressions .Select (ApplyValueContext) .ToArray(); if (newKeyExpression != expression.KeyExpression || newElementExpression != expression.ElementExpression || !newAggregationExpressions.SequenceEqual (expression.AggregationExpressions)) return _context.UpdateGroupingSelectAndAddMapping (expression, newKeyExpression, newElementExpression, newAggregationExpressions); return expression; }
public void ResolveSubStatementReferenceExpression_CreatesSqlGroupingSelectExpressionWithNamedExpressions () { var expression = new SqlGroupingSelectExpression ( Expression.Constant ("key"), Expression.Constant ("element"), new[] { Expression.Constant ("aggregation") }); var tableInfo = new ResolvedSubStatementTableInfo ("q0", SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook))); var sqlTable = SqlStatementModelObjectMother.CreateSqlTable(typeof(Cook)); var exprectedResult = new SqlGroupingSelectExpression ( new NamedExpression ("key", Expression.Constant ("key")), new NamedExpression ("element", Expression.Constant ("element")), new[] { new NamedExpression ("a0", Expression.Constant ("aggregation")) }); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (expression, tableInfo, sqlTable, _context); SqlExpressionTreeComparer.CheckAreEqualTrees (result, exprectedResult); Assert.That (_context.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable)); }
public void ResolveSubStatementReferenceExpression_CreatesSqlGroupingReferenceExpression_ForSqlGroupingSelectExpression () { var groupingSelectExpression = new SqlGroupingSelectExpression ( SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), "key"), new NamedExpression ("element", Expression.Constant (0)), new[] { new NamedExpression ("a0", Expression.Constant (1)) }); var sqlStatement = new SqlStatementBuilder (SqlStatementModelObjectMother.CreateSqlStatement_Resolved (typeof (Cook))) { SelectProjection = groupingSelectExpression, DataInfo = new StreamedSequenceInfo (typeof (IGrouping<int, int>[]), Expression.Constant (null, typeof (IGrouping<int, int>))) }.GetSqlStatement (); var tableInfo = new ResolvedSubStatementTableInfo ("q0", sqlStatement); var sqlTable = new SqlTable (tableInfo, JoinSemantics.Inner); var result = SubStatementReferenceResolver.ResolveSubStatementReferenceExpression (groupingSelectExpression, tableInfo, sqlTable, _context); Assert.That (result, Is.TypeOf (typeof (SqlGroupingSelectExpression))); var referencedKeyExpression = ((SqlGroupingSelectExpression) result).KeyExpression; var expectedReferencedKeyExpression = new NamedExpression("key", new SqlEntityReferenceExpression ( typeof (Cook), "q0", null, (SqlEntityExpression) groupingSelectExpression.KeyExpression)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedKeyExpression, referencedKeyExpression); var referencedElementExpression = ((SqlGroupingSelectExpression) result).ElementExpression; var expectedReferencedElementExpression = new NamedExpression("element", new SqlColumnDefinitionExpression (typeof (int), "q0", "element", false)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedElementExpression, referencedElementExpression); Assert.That (((SqlGroupingSelectExpression) result).AggregationExpressions.Count, Is.EqualTo (1)); var referencedAggregationExpression = ((SqlGroupingSelectExpression) result).AggregationExpressions[0]; var expectedReferencedAggregationExpression = new NamedExpression("a0", new SqlColumnDefinitionExpression (typeof (int), "q0", "a0", false)); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedReferencedAggregationExpression, referencedAggregationExpression); Assert.That (_context.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable)); }
public void VisitSqlGroupingSelectExpression_WithoutAggregationExpressions () { var groupingExpression = new SqlGroupingSelectExpression (Expression.Constant ("keyExpression"), Expression.Constant ("elementExpression")); SqlGeneratingSelectExpressionVisitor.GenerateSql (groupingExpression, _commandBuilder, _stageMock); Assert.That (_commandBuilder.GetCommandText (), Is.EqualTo ("@1")); Assert.That (_commandBuilder.GetCommandParameters ()[0].Value, Is.EqualTo ("keyExpression")); }
public void ResolveTableInfo_GroupReferenceTableInfo () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook)); var groupingSelect = new SqlGroupingSelectExpression ( Expression.MakeMemberAccess (new SqlTableReferenceExpression (sqlTable), typeof (Cook).GetProperty ("Name")), Expression.MakeMemberAccess (new SqlTableReferenceExpression (sqlTable), typeof (Cook).GetProperty ("ID"))); var dataInfo = new StreamedSequenceInfo ( typeof (IEnumerable<>).MakeGenericType (groupingSelect.Type), Expression.Constant (null, groupingSelect.Type)); var whereCondition = Expression.Constant (false); var groupByExpression = groupingSelect.KeyExpression; var groupingSubStatement = new SqlStatementBuilder { DataInfo = dataInfo, SelectProjection = groupingSelect, SqlTables = { sqlTable }, WhereCondition = whereCondition, GroupByExpression = groupByExpression }.GetSqlStatement(); var groupSource = SqlStatementModelObjectMother.CreateSqlTable (new ResolvedSubStatementTableInfo ("q0", groupingSubStatement)); var tableInfo = new UnresolvedGroupReferenceTableInfo (groupSource); var expectedKeyViaElement = Expression.MakeMemberAccess (new SqlTableReferenceExpression (sqlTable), typeof (Cook).GetProperty ("Name")); var expectedKeyViaGroupSource = Expression.MakeMemberAccess (new SqlTableReferenceExpression (groupSource), groupSource.ItemType.GetProperty ("Key")); var expectedResultWhereCondition = Expression.OrElse ( Expression.AndAlso (new SqlIsNullExpression (expectedKeyViaElement), new SqlIsNullExpression (expectedKeyViaGroupSource)), Expression.AndAlso ( Expression.AndAlso (new SqlIsNotNullExpression (expectedKeyViaElement), new SqlIsNotNullExpression (expectedKeyViaGroupSource)), Expression.Equal (expectedKeyViaElement, expectedKeyViaGroupSource))); var fakeWhereCondition = Expression.Constant (false); _stageMock .Expect (mock => mock.ResolveWhereExpression (Arg<Expression>.Is.Anything, Arg.Is (_mappingResolutionContext))) .WhenCalled (mi => SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResultWhereCondition, (Expression) mi.Arguments[0])) .Return (fakeWhereCondition); _stageMock.Replay(); var result = ResolvingTableInfoVisitor.ResolveTableInfo (tableInfo, _resolverMock, _generator, _stageMock, _mappingResolutionContext); _stageMock.VerifyAllExpectations(); Assert.That (result, Is.TypeOf (typeof (ResolvedJoinedGroupingTableInfo))); var castResult = ((ResolvedJoinedGroupingTableInfo) result); var resultGroupingSelector = castResult.AssociatedGroupingSelectExpression; Assert.That (resultGroupingSelector, Is.SameAs (groupingSelect)); Assert.That (castResult.GroupSourceTableAlias, Is.EqualTo ("q0")); var resultSqlStatement = castResult.SqlStatement; Assert.That (resultSqlStatement.SqlTables, Is.EqualTo (groupingSubStatement.SqlTables)); Assert.That (resultSqlStatement.Orderings, Is.Empty); Assert.That (resultSqlStatement.GroupByExpression, Is.Null); SqlExpressionTreeComparer.CheckAreEqualTrees ( Expression.AndAlso (groupingSubStatement.WhereCondition, fakeWhereCondition), resultSqlStatement.WhereCondition); var expectedResultSelectProjection = Expression.MakeMemberAccess (new SqlTableReferenceExpression (resultSqlStatement.SqlTables[0]), typeof (Cook).GetProperty ("ID")); SqlExpressionTreeComparer.CheckAreEqualTrees (expectedResultSelectProjection, resultSqlStatement.SelectProjection); Assert.That (resultSqlStatement.DataInfo, Is.TypeOf (typeof (StreamedSequenceInfo))); Assert.That (resultSqlStatement.DataInfo.DataType, Is.SameAs (typeof (IQueryable<int>))); var expectedItemExpression = resultSqlStatement.SelectProjection; SqlExpressionTreeComparer.CheckAreEqualTrees (expectedItemExpression, ((StreamedSequenceInfo) resultSqlStatement.DataInfo).ItemExpression); }
public void ProcessNames_SqlGroupingSelectExpression () { var keyExpression = new NamedExpression ("key", Expression.Constant ("key")); var elementExpression = new NamedExpression ("element", Expression.Constant ("element")); var aggregationExpression = new NamedExpression ("a0", Expression.Constant ("aggregation")); var groupingSelectExpression = new SqlGroupingSelectExpression (keyExpression, elementExpression, new[]{aggregationExpression}); var expression = new NamedExpression ("outer", groupingSelectExpression); var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook)); _context.AddGroupReferenceMapping (groupingSelectExpression, sqlTable); var expectedResult = new SqlGroupingSelectExpression ( new NamedExpression ("outer_key", Expression.Constant ("key")), new NamedExpression ("outer_element", Expression.Constant ("element")), new[]{new NamedExpression("outer_a0", Expression.Constant("aggregation"))}); var result = _namedExpressionCombiner.ProcessNames (expression); SqlExpressionTreeComparer.CheckAreEqualTrees (result, expectedResult); Assert.That (_context.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable)); }
public SqlGroupingSelectExpression UpdateGroupingSelectAndAddMapping ( SqlGroupingSelectExpression expression, Expression newKey, Expression newElement, IEnumerable<Expression> aggregations) { ArgumentUtility.CheckNotNull ("expression", expression); ArgumentUtility.CheckNotNull ("newKey", newKey); ArgumentUtility.CheckNotNull ("newElement", newElement); ArgumentUtility.CheckNotNull ("aggregations", aggregations); var newSqlGroupingSelectExpression = expression.Update (newKey, newElement, aggregations); SqlTableBase tableForGroupingSelectExpression; if(_groupReferenceMapping.TryGetValue(expression, out tableForGroupingSelectExpression)) AddGroupReferenceMapping (newSqlGroupingSelectExpression, tableForGroupingSelectExpression); return newSqlGroupingSelectExpression; }
public void ResolveMemberAccess_OnGroupingSelectExpression_StripsNames () { var expression = new SqlGroupingSelectExpression ( new NamedExpression ("k", Expression.Constant ("key")), new NamedExpression ("e", Expression.Constant ("element"))); var memberInfo = typeof (IGrouping<string, string>).GetProperty ("Key"); var result = MemberAccessResolver.ResolveMemberAccess (expression, memberInfo, _resolverMock, _stageMock, _mappingResolutionContext); Assert.That (result, Is.SameAs (((NamedExpression) expression.KeyExpression).Expression)); }
public void VisitSqlGroupingSelectExpression_KeepsValueSemantics () { var keyExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook)); var elementExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook)); var aggregateExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook)); var expression = new SqlGroupingSelectExpression (keyExpression, elementExpression, new[] { aggregateExpression }); var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook)); _mappingResolutionContext.AddGroupReferenceMapping (expression, sqlTable); var result = _singleValueRequiredVisitor.VisitSqlGroupingSelectExpression (expression); Assert.That (result, Is.SameAs (expression)); Assert.That (_mappingResolutionContext.GetReferencedGroupSource (((SqlGroupingSelectExpression) result)), Is.SameAs (sqlTable)); }
public void VisitSqlGroupingSelectExpression_VisitsChildren () { var keyExpression = Expression.Constant (false); var elementExpression = Expression.Constant (false); var aggregateExpression = Expression.Constant (true); var expression = new SqlGroupingSelectExpression (keyExpression, elementExpression, new[] { aggregateExpression }); var sqlTable = SqlStatementModelObjectMother.CreateSqlTable (typeof (Cook)); _mappingResolutionContext.AddGroupReferenceMapping (expression, sqlTable); var result = (SqlGroupingSelectExpression) _singleValueRequiredVisitor.VisitSqlGroupingSelectExpression (expression); Assert.That (result, Is.Not.SameAs (expression)); SqlExpressionTreeComparer.CheckAreEqualTrees (new SqlConvertedBooleanExpression (Expression.Constant (0)), result.KeyExpression); SqlExpressionTreeComparer.CheckAreEqualTrees (new SqlConvertedBooleanExpression (Expression.Constant (0)), result.ElementExpression); SqlExpressionTreeComparer.CheckAreEqualTrees (new SqlConvertedBooleanExpression (Expression.Constant (1)), result.AggregationExpressions[0]); Assert.That (_mappingResolutionContext.GetReferencedGroupSource (result), Is.SameAs (sqlTable)); }