You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2210 lines
75 KiB
C#
2210 lines
75 KiB
C#
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.EntityFrameworkCore.Query;
|
|
using Microsoft.EntityFrameworkCore.TestUtilities;
|
|
using Xunit;
|
|
using Xunit.Abstractions;
|
|
|
|
namespace EntityFrameworkCore.Jet.FunctionalTests.Query
|
|
{
|
|
public class GroupByQueryJetTest : GroupByQueryTestBase<NorthwindQueryJetFixture<NoopModelCustomizer>>
|
|
{
|
|
// ReSharper disable once UnusedParameter.Local
|
|
public GroupByQueryJetTest(NorthwindQueryJetFixture<NoopModelCustomizer> fixture, ITestOutputHelper testOutputHelper)
|
|
: base(fixture)
|
|
{
|
|
Fixture.TestSqlLoggerFactory.Clear();
|
|
//Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper);
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Average(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Average(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID])))
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
|
|
// Validating that we don't generate warning when translating GroupBy. See Issue#11157
|
|
Assert.DoesNotContain(
|
|
"The LINQ expression 'GroupBy([o].CustomerID, [o])' could not be translated and will be evaluated locally.",
|
|
Fixture.TestSqlLoggerFactory.Log.Select(l => l.Message));
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Average_with_navigation_expansion(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Average_with_navigation_expansion(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Count(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_LongCount(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_LongCount(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT_BIG(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Max(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Max(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MAX([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Min(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Min(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MIN([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Sum_Min_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Sum_Min_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_Average(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_Average(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Average]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_Count(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_Count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_LongCount(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_LongCount(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT_BIG(*) AS [LongCount]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_Max(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_Max(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], MAX([o].[OrderID]) AS [Max]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_Min(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_Min(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], MIN([o].[OrderID]) AS [Min]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_Sum_Min_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_Sum_Min_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Sum_Min_Key_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Sum_Min_Key_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], [o].[CustomerID] AS [Key], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_key_multiple_times_and_aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_key_multiple_times_and_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key1], SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_Select_Key_with_constant(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_Select_Key_with_constant(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT 'CustomerID' AS [Name], [o].[CustomerID] AS [Value], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_aggregate_projecting_conditional_expression(bool isAsync)
|
|
{
|
|
await base.GroupBy_aggregate_projecting_conditional_expression(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderDate] AS [Key], CASE
|
|
WHEN COUNT(*) = 0 THEN 1
|
|
ELSE SUM(CASE
|
|
WHEN ([o].[OrderID] MOD 2) = 0 THEN 1
|
|
ELSE 0
|
|
END) / COUNT(*)
|
|
END AS [SomeValue]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[OrderDate]");
|
|
}
|
|
|
|
public override async Task GroupBy_aggregate_projecting_conditional_expression_based_on_group_key(bool isAsync)
|
|
{
|
|
await base.GroupBy_aggregate_projecting_conditional_expression_based_on_group_key(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT CASE
|
|
WHEN [o].[OrderDate] IS NULL THEN 'is null'
|
|
ELSE 'is not null'
|
|
END AS [Key], SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[OrderDate]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_Select_Average(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_Select_Average(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID])))
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_Select_Count(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_Select_Count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_Select_LongCount(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_Select_LongCount(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT_BIG(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_Select_Max(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_Select_Max(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MAX([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_Select_Min(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_Select_Min(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MIN([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_Select_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_Select_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_Select_Sum_Min_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_Select_Sum_Min_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_with_alias_Select_Key_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_with_alias_Select_Key_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Average(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Average(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID])))
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Count(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_LongCount(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_LongCount(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT_BIG(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Max(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Max(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MAX([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Min(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Min(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MIN([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Sum_Min_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Sum_Min_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Key_Average(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Key_Average(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[EmployeeID], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Average]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Key_Count(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Key_Count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[EmployeeID], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Key_LongCount(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Key_LongCount(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[EmployeeID], COUNT_BIG(*) AS [LongCount]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Key_Max(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Key_Max(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[EmployeeID], MAX([o].[OrderID]) AS [Max]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Key_Min(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Key_Min(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[EmployeeID], MIN([o].[OrderID]) AS [Min]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Key_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Key_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[EmployeeID], SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Key_Sum_Min_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Key_Sum_Min_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[EmployeeID], SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Sum_Min_Key_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Sum_Min_Key_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], [o].[CustomerID], [o].[EmployeeID], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Sum_Min_Key_flattened_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Sum_Min_Key_flattened_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], [o].[CustomerID], [o].[EmployeeID], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Dto_as_key_Select_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Dto_as_key_Select_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], [o].[CustomerID], [o].[EmployeeID]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Dto_as_element_selector_Select_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Dto_as_element_selector_Select_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM(CAST([o].[EmployeeID] AS bigint)) AS [Sum], [o].[CustomerID] AS [Key]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Dto_Sum_Min_Key_flattened_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Dto_Sum_Min_Key_flattened_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], [o].[CustomerID] AS [CustomerId], [o].[EmployeeID] AS [EmployeeId], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Composite_Select_Sum_Min_part_Key_flattened_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Composite_Select_Sum_Min_part_Key_flattened_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], [o].[CustomerID], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID], [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Constant_Select_Sum_Min_Key_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Constant_Select_Sum_Min_Key_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], 2 AS [Key], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_Constant_with_element_selector_Select_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Constant_with_element_selector_Select_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_Constant_with_element_selector_Select_Sum2(bool isAsync)
|
|
{
|
|
await base.GroupBy_Constant_with_element_selector_Select_Sum2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_Constant_with_element_selector_Select_Sum3(bool isAsync)
|
|
{
|
|
await base.GroupBy_Constant_with_element_selector_Select_Sum3(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_after_predicate_Constant_Select_Sum_Min_Key_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_after_predicate_Constant_Select_Sum_Min_Key_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], 2 AS [Random], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
WHERE [o].[OrderID] > 10500");
|
|
}
|
|
|
|
public override async Task GroupBy_Constant_with_element_selector_Select_Sum_Min_Key_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Constant_with_element_selector_Select_Sum_Min_Key_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], 2 AS [Key]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_param_Select_Sum_Min_Key_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_param_Select_Sum_Min_Key_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__a_0='2'
|
|
|
|
SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], @__a_0 AS [Key], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_param_with_element_selector_Select_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_param_with_element_selector_Select_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_param_with_element_selector_Select_Sum2(bool isAsync)
|
|
{
|
|
await base.GroupBy_param_with_element_selector_Select_Sum2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_param_with_element_selector_Select_Sum3(bool isAsync)
|
|
{
|
|
await base.GroupBy_param_with_element_selector_Select_Sum3(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_param_with_element_selector_Select_Sum_Min_Key_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_param_with_element_selector_Select_Sum_Min_Key_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__a_0='2'
|
|
|
|
SELECT SUM([o].[OrderID]) AS [Sum], @__a_0 AS [Key]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_key_type_mismatch_with_aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_key_type_mismatch_with_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT(*) AS [I0], DATEPART('yyyy', [o].[OrderDate]) AS [I1]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY DATEPART('yyyy', [o].[OrderDate])
|
|
ORDER BY DATEPART('yyyy', [o].[OrderDate])");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_scalar_element_selector_Average(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_scalar_element_selector_Average(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID])))
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_scalar_element_selector_Count(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_scalar_element_selector_Count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_scalar_element_selector_LongCount(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_scalar_element_selector_LongCount(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT_BIG(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_scalar_element_selector_Max(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_scalar_element_selector_Max(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MAX([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_scalar_element_selector_Min(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_scalar_element_selector_Min(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MIN([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_scalar_element_selector_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_scalar_element_selector_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_scalar_element_selector_Sum_Min_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_scalar_element_selector_Sum_Min_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_anonymous_element_selector_Average(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_anonymous_element_selector_Average(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID])))
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_anonymous_element_selector_Count(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_anonymous_element_selector_Count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_anonymous_element_selector_LongCount(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_anonymous_element_selector_LongCount(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT_BIG(*)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_anonymous_element_selector_Max(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_anonymous_element_selector_Max(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MAX([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_anonymous_element_selector_Min(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_anonymous_element_selector_Min(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MIN([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_anonymous_element_selector_Sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_anonymous_element_selector_Sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Property_anonymous_element_selector_Sum_Min_Max_Avg(bool isAsync)
|
|
{
|
|
await base.GroupBy_Property_anonymous_element_selector_Sum_Min_Max_Avg(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[EmployeeID]) AS [Min], MAX([o].[EmployeeID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_element_selector_complex_aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_element_selector_complex_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID] + 1)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_element_selector_complex_aggregate2(bool isAsync)
|
|
{
|
|
await base.GroupBy_element_selector_complex_aggregate2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID] + 1)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_element_selector_complex_aggregate3(bool isAsync)
|
|
{
|
|
await base.GroupBy_element_selector_complex_aggregate3(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID] + 1)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_element_selector_complex_aggregate4(bool isAsync)
|
|
{
|
|
await base.GroupBy_element_selector_complex_aggregate4(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID] + 1)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_empty_key_Aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_empty_key_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID])
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task GroupBy_empty_key_Aggregate_Key(bool isAsync)
|
|
{
|
|
await base.GroupBy_empty_key_Aggregate_Key(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]");
|
|
}
|
|
|
|
public override async Task OrderBy_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.OrderBy_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID])
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task OrderBy_Skip_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.OrderBy_Skip_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='80'
|
|
|
|
SELECT AVG(IIf([t].[OrderID] IS NULL, NULL, CDBL([t].[OrderID])))
|
|
FROM (
|
|
SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[OrderID]
|
|
SKIP @__p_0
|
|
) AS [t]
|
|
GROUP BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task OrderBy_Take_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.OrderBy_Take_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='500'
|
|
|
|
SELECT MIN([t].[OrderID])
|
|
FROM (
|
|
SELECT TOP @__p_0 [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[OrderID]
|
|
) AS [t]
|
|
GROUP BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task OrderBy_Skip_Take_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.OrderBy_Skip_Take_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='80'
|
|
@__p_1='500'
|
|
|
|
SELECT MAX([t].[OrderID])
|
|
FROM (
|
|
SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[OrderID]
|
|
SKIP @__p_0 FETCH NEXT @__p_1 ROWS ONLY
|
|
) AS [t]
|
|
GROUP BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Distinct_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.Distinct_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [t].[CustomerID] AS [Key], COUNT(*) AS [c]
|
|
FROM (
|
|
SELECT DISTINCT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
) AS [t]
|
|
GROUP BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Anonymous_projection_Distinct_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.Anonymous_projection_Distinct_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [t].[EmployeeID] AS [Key], COUNT(*) AS [c]
|
|
FROM (
|
|
SELECT DISTINCT [o].[OrderID], [o].[EmployeeID]
|
|
FROM [Orders] AS [o]
|
|
) AS [t]
|
|
GROUP BY [t].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task SelectMany_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.SelectMany_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[EmployeeID] AS [Key], COUNT(*) AS [c]
|
|
FROM [Customers] AS [c]
|
|
INNER JOIN [Orders] AS [o] ON [c].[CustomerID] = [o].[CustomerID]
|
|
GROUP BY [o].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task Join_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.Join_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID] AS [Key], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
INNER JOIN [Customers] AS [c] ON [o].[CustomerID] = [c].[CustomerID]
|
|
GROUP BY [c].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_required_navigation_member_Aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_required_navigation_member_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o0].[CustomerID] AS [CustomerId], COUNT(*) AS [Count]
|
|
FROM [Order Details] AS [o]
|
|
INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
|
|
GROUP BY [o0].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Join_complex_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.Join_complex_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='100'
|
|
@__p_1='10'
|
|
@__p_2='50'
|
|
|
|
SELECT [t0].[CustomerID] AS [Key], AVG(IIf([t].[OrderID] IS NULL, NULL, CDBL([t].[OrderID]))) AS [Count]
|
|
FROM (
|
|
SELECT TOP @__p_0 [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
WHERE [o].[OrderID] < 10400
|
|
ORDER BY [o].[OrderDate]
|
|
) AS [t]
|
|
INNER JOIN (
|
|
SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]
|
|
FROM [Customers] AS [c]
|
|
WHERE ([c].[CustomerID] <> 'DRACD') AND ([c].[CustomerID] <> 'FOLKO')
|
|
ORDER BY [c].[City]
|
|
SKIP @__p_1 FETCH NEXT @__p_2 ROWS ONLY
|
|
) AS [t0] ON [t].[CustomerID] = [t0].[CustomerID]
|
|
GROUP BY [t0].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupJoin_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.GroupJoin_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Average]
|
|
FROM [Customers] AS [c]
|
|
LEFT JOIN [Orders] AS [o] ON [c].[CustomerID] = [o].[CustomerID]
|
|
WHERE [o].[OrderID] IS NOT NULL
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupJoin_GroupBy_Aggregate_2(bool isAsync)
|
|
{
|
|
await base.GroupJoin_GroupBy_Aggregate_2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID] AS [Key], MAX([c].[City]) AS [Max]
|
|
FROM [Customers] AS [c]
|
|
LEFT JOIN [Orders] AS [o] ON [c].[CustomerID] = [o].[CustomerID]
|
|
GROUP BY [c].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupJoin_GroupBy_Aggregate_3(bool isAsync)
|
|
{
|
|
await base.GroupJoin_GroupBy_Aggregate_3(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Average]
|
|
FROM [Orders] AS [o]
|
|
LEFT JOIN [Customers] AS [c] ON [o].[CustomerID] = [c].[CustomerID]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupJoin_GroupBy_Aggregate_4(bool isAsync)
|
|
{
|
|
await base.GroupJoin_GroupBy_Aggregate_4(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID] AS [Value], MAX([c].[City]) AS [Max]
|
|
FROM [Customers] AS [c]
|
|
LEFT JOIN [Orders] AS [o] ON [c].[CustomerID] = [o].[CustomerID]
|
|
GROUP BY [c].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupJoin_GroupBy_Aggregate_5(bool isAsync)
|
|
{
|
|
await base.GroupJoin_GroupBy_Aggregate_5(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID] AS [Value], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Average]
|
|
FROM [Orders] AS [o]
|
|
LEFT JOIN [Customers] AS [c] ON [o].[CustomerID] = [c].[CustomerID]
|
|
GROUP BY [o].[OrderID]");
|
|
}
|
|
|
|
public override async Task GroupBy_optional_navigation_member_Aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_optional_navigation_member_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[Country], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
LEFT JOIN [Customers] AS [c] ON [o].[CustomerID] = [c].[CustomerID]
|
|
GROUP BY [c].[Country]");
|
|
}
|
|
|
|
public override async Task GroupJoin_complex_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.GroupJoin_complex_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='10'
|
|
@__p_1='50'
|
|
@__p_2='100'
|
|
|
|
SELECT [t0].[CustomerID] AS [Key], AVG(IIf([t0].[OrderID] IS NULL, NULL, CDBL([t0].[OrderID]))) AS [Count]
|
|
FROM (
|
|
SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]
|
|
FROM [Customers] AS [c]
|
|
WHERE ([c].[CustomerID] <> 'DRACD') AND ([c].[CustomerID] <> 'FOLKO')
|
|
ORDER BY [c].[City]
|
|
SKIP @__p_0 FETCH NEXT @__p_1 ROWS ONLY
|
|
) AS [t]
|
|
INNER JOIN (
|
|
SELECT TOP @__p_2 [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
WHERE [o].[OrderID] < 10400
|
|
ORDER BY [o].[OrderDate]
|
|
) AS [t0] ON [t].[CustomerID] = [t0].[CustomerID]
|
|
WHERE [t0].[OrderID] > 10300
|
|
GROUP BY [t0].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Self_join_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.Self_join_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], AVG(IIf([o0].[OrderID] IS NULL, NULL, CDBL([o0].[OrderID]))) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
|
|
WHERE [o].[OrderID] < 10400
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_multi_navigation_members_Aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_multi_navigation_members_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o0].[CustomerID], [p].[ProductName], COUNT(*) AS [Count]
|
|
FROM [Order Details] AS [o]
|
|
INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
|
|
INNER JOIN [Products] AS [p] ON [o].[ProductID] = [p].[ProductID]
|
|
GROUP BY [o0].[CustomerID], [p].[ProductName]");
|
|
}
|
|
|
|
public override async Task Union_simple_groupby(bool isAsync)
|
|
{
|
|
await base.Union_simple_groupby(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [t].[City] AS [Key], COUNT(*) AS [Total]
|
|
FROM (
|
|
SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]
|
|
FROM [Customers] AS [c]
|
|
WHERE [c].[ContactTitle] = 'Owner'
|
|
UNION
|
|
SELECT [c0].[CustomerID], [c0].[Address], [c0].[City], [c0].[CompanyName], [c0].[ContactName], [c0].[ContactTitle], [c0].[Country], [c0].[Fax], [c0].[Phone], [c0].[PostalCode], [c0].[Region]
|
|
FROM [Customers] AS [c0]
|
|
WHERE [c0].[City] = 'México D.F.'
|
|
) AS [t]
|
|
GROUP BY [t].[City]");
|
|
}
|
|
|
|
public override async Task Select_anonymous_GroupBy_Aggregate(bool isAsync)
|
|
{
|
|
await base.Select_anonymous_GroupBy_Aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MIN([o].[OrderDate]) AS [Min], MAX([o].[OrderDate]) AS [Max], SUM([o].[OrderID]) AS [Sum], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
WHERE [o].[OrderID] < 10300
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_principal_key_property_optimization(bool isAsync)
|
|
{
|
|
await base.GroupBy_principal_key_property_optimization(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID] AS [Key], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
LEFT JOIN [Customers] AS [c] ON [o].[CustomerID] = [c].[CustomerID]
|
|
GROUP BY [c].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_OrderBy_key(bool isAsync)
|
|
{
|
|
await base.GroupBy_OrderBy_key(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT(*) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_OrderBy_count(bool isAsync)
|
|
{
|
|
await base.GroupBy_OrderBy_count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
ORDER BY COUNT(*), [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_OrderBy_count_Select_sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_OrderBy_count_Select_sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
ORDER BY COUNT(*), [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_aggregate_Contains(bool isAsync)
|
|
{
|
|
await base.GroupBy_aggregate_Contains(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
WHERE [o].[CustomerID] IN (
|
|
SELECT [o0].[CustomerID]
|
|
FROM [Orders] AS [o0]
|
|
GROUP BY [o0].[CustomerID]
|
|
HAVING COUNT(*) > 30
|
|
)");
|
|
}
|
|
|
|
public override async Task GroupBy_aggregate_Pushdown(bool isAsync)
|
|
{
|
|
await base.GroupBy_aggregate_Pushdown(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='20'
|
|
@__p_1='4'
|
|
|
|
SELECT [t].[CustomerID]
|
|
FROM (
|
|
SELECT TOP @__p_0 [o].[CustomerID]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 10
|
|
ORDER BY [o].[CustomerID]
|
|
) AS [t]
|
|
ORDER BY [t].[CustomerID]
|
|
SKIP @__p_1");
|
|
}
|
|
|
|
public override async Task GroupBy_aggregate_Pushdown_followed_by_projecting_Length(bool isAsync)
|
|
{
|
|
await base.GroupBy_aggregate_Pushdown_followed_by_projecting_Length(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='20'
|
|
@__p_1='4'
|
|
|
|
SELECT CAST(LEN([t].[CustomerID]) AS int)
|
|
FROM (
|
|
SELECT TOP @__p_0 [o].[CustomerID]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 10
|
|
ORDER BY [o].[CustomerID]
|
|
) AS [t]
|
|
ORDER BY [t].[CustomerID]
|
|
SKIP @__p_1");
|
|
}
|
|
|
|
public override async Task GroupBy_aggregate_Pushdown_followed_by_projecting_constant(bool isAsync)
|
|
{
|
|
await base.GroupBy_aggregate_Pushdown_followed_by_projecting_constant(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='20'
|
|
@__p_1='4'
|
|
|
|
SELECT 5
|
|
FROM (
|
|
SELECT TOP @__p_0 [o].[CustomerID]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 10
|
|
ORDER BY [o].[CustomerID]
|
|
) AS [t]
|
|
ORDER BY [t].[CustomerID]
|
|
SKIP @__p_1");
|
|
}
|
|
|
|
public override async Task GroupBy_Select_sum_over_unmapped_property(bool isAsync)
|
|
{
|
|
await base.GroupBy_Select_sum_over_unmapped_property(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_filter_key(bool isAsync)
|
|
{
|
|
await base.GroupBy_filter_key(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT(*) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING [o].[CustomerID] = 'ALFKI'");
|
|
}
|
|
|
|
public override async Task GroupBy_filter_count(bool isAsync)
|
|
{
|
|
await base.GroupBy_filter_count(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 4");
|
|
}
|
|
|
|
public override async Task GroupBy_filter_count_OrderBy_count_Select_sum(bool isAsync)
|
|
{
|
|
await base.GroupBy_filter_count_OrderBy_count_Select_sum(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT(*) AS [Count], SUM([o].[OrderID]) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 4
|
|
ORDER BY COUNT(*), [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Aggregate_Join(bool isAsync)
|
|
{
|
|
await base.GroupBy_Aggregate_Join(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]
|
|
FROM (
|
|
SELECT [o].[CustomerID], MAX([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 5
|
|
) AS [t]
|
|
INNER JOIN [Customers] AS [c] ON [t].[CustomerID] = [c].[CustomerID]
|
|
INNER JOIN [Orders] AS [o0] ON [t].[c] = [o0].[OrderID]");
|
|
}
|
|
|
|
public override async Task Join_GroupBy_Aggregate_multijoins(bool isAsync)
|
|
{
|
|
await base.Join_GroupBy_Aggregate_multijoins(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]
|
|
FROM [Customers] AS [c]
|
|
INNER JOIN (
|
|
SELECT [o].[CustomerID], MAX([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 5
|
|
) AS [t] ON [c].[CustomerID] = [t].[CustomerID]
|
|
INNER JOIN [Orders] AS [o0] ON [t].[c] = [o0].[OrderID]");
|
|
}
|
|
|
|
public override async Task Join_GroupBy_Aggregate_single_join(bool isAsync)
|
|
{
|
|
await base.Join_GroupBy_Aggregate_single_join(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], [t].[c] AS [LastOrderID]
|
|
FROM [Customers] AS [c]
|
|
INNER JOIN (
|
|
SELECT [o].[CustomerID], MAX([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 5
|
|
) AS [t] ON [c].[CustomerID] = [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Join_GroupBy_Aggregate_with_another_join(bool isAsync)
|
|
{
|
|
await base.Join_GroupBy_Aggregate_with_another_join(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], [t].[c] AS [LastOrderID], [o0].[OrderID]
|
|
FROM [Customers] AS [c]
|
|
INNER JOIN (
|
|
SELECT [o].[CustomerID], MAX([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 5
|
|
) AS [t] ON [c].[CustomerID] = [t].[CustomerID]
|
|
INNER JOIN [Orders] AS [o0] ON [c].[CustomerID] = [o0].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Join_GroupBy_Aggregate_in_subquery(bool isAsync)
|
|
{
|
|
await base.Join_GroupBy_Aggregate_in_subquery(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate], [t0].[CustomerID], [t0].[Address], [t0].[City], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Country], [t0].[Fax], [t0].[Phone], [t0].[PostalCode], [t0].[Region]
|
|
FROM [Orders] AS [o]
|
|
INNER JOIN (
|
|
SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], [t].[CustomerID] AS [CustomerID0], [t].[c]
|
|
FROM [Customers] AS [c]
|
|
INNER JOIN (
|
|
SELECT [o0].[CustomerID], MAX([o0].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o0]
|
|
GROUP BY [o0].[CustomerID]
|
|
HAVING COUNT(*) > 5
|
|
) AS [t] ON [c].[CustomerID] = [t].[CustomerID]
|
|
) AS [t0] ON [o].[CustomerID] = [t0].[CustomerID]
|
|
WHERE [o].[OrderID] < 10400");
|
|
}
|
|
|
|
public override async Task Join_GroupBy_Aggregate_on_key(bool isAsync)
|
|
{
|
|
await base.Join_GroupBy_Aggregate_on_key(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], [t].[c] AS [LastOrderID]
|
|
FROM [Customers] AS [c]
|
|
INNER JOIN (
|
|
SELECT [o].[CustomerID], MAX([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING COUNT(*) > 5
|
|
) AS [t] ON [c].[CustomerID] = [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_result_selector(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_result_selector(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM([o].[OrderID]) AS [Sum], MIN([o].[OrderID]) AS [Min], MAX([o].[OrderID]) AS [Max], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Sum_constant(bool isAsync)
|
|
{
|
|
await base.GroupBy_Sum_constant(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM(1)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Sum_constant_cast(bool isAsync)
|
|
{
|
|
await base.GroupBy_Sum_constant_cast(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT SUM(1)
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Distinct_GroupBy_OrderBy_key(bool isAsync)
|
|
{
|
|
await base.Distinct_GroupBy_OrderBy_key(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [t].[CustomerID] AS [Key], COUNT(*) AS [c]
|
|
FROM (
|
|
SELECT DISTINCT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
) AS [t]
|
|
GROUP BY [t].[CustomerID]
|
|
ORDER BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Select_nested_collection_with_groupby(bool isAsync)
|
|
{
|
|
await base.Select_nested_collection_with_groupby(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT (
|
|
SELECT CASE
|
|
WHEN EXISTS (
|
|
SELECT 1
|
|
FROM [Orders] AS [o0]
|
|
WHERE [c].[CustomerID] = [o0].[CustomerID])
|
|
THEN True ELSE False
|
|
END
|
|
), [c].[CustomerID]
|
|
FROM [Customers] AS [c]
|
|
WHERE [c].[CustomerID] LIKE 'A' & '%'",
|
|
//
|
|
@"@_outer_CustomerID='ALFKI' (Size = 5)
|
|
|
|
SELECT [o1].[OrderID]
|
|
FROM [Orders] AS [o1]
|
|
WHERE @_outer_CustomerID = [o1].[CustomerID]
|
|
ORDER BY [o1].[OrderID]",
|
|
//
|
|
@"@_outer_CustomerID='ANATR' (Size = 5)
|
|
|
|
SELECT [o1].[OrderID]
|
|
FROM [Orders] AS [o1]
|
|
WHERE @_outer_CustomerID = [o1].[CustomerID]
|
|
ORDER BY [o1].[OrderID]",
|
|
//
|
|
@"@_outer_CustomerID='ANTON' (Size = 5)
|
|
|
|
SELECT [o1].[OrderID]
|
|
FROM [Orders] AS [o1]
|
|
WHERE @_outer_CustomerID = [o1].[CustomerID]
|
|
ORDER BY [o1].[OrderID]",
|
|
//
|
|
@"@_outer_CustomerID='AROUT' (Size = 5)
|
|
|
|
SELECT [o1].[OrderID]
|
|
FROM [Orders] AS [o1]
|
|
WHERE @_outer_CustomerID = [o1].[CustomerID]
|
|
ORDER BY [o1].[OrderID]");
|
|
}
|
|
|
|
public override async Task Select_GroupBy_All(bool isAsync)
|
|
{
|
|
await base.Select_GroupBy_All(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID] AS [Order], [o].[CustomerID] AS [Customer]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Where_in_aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_Where_in_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Key_as_part_of_element_selector(bool isAsync)
|
|
{
|
|
await base.GroupBy_Key_as_part_of_element_selector(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID] AS [Key], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg], MAX([o].[OrderDate]) AS [Max]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[OrderID]");
|
|
}
|
|
|
|
public override async Task GroupBy_composite_Key_as_part_of_element_selector(bool isAsync)
|
|
{
|
|
await base.GroupBy_composite_Key_as_part_of_element_selector(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], AVG(IIf([o].[OrderID] IS NULL, NULL, CDBL([o].[OrderID]))) AS [Avg], MAX([o].[OrderDate]) AS [Max]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[OrderID], [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[City], [c].[CustomerID]
|
|
FROM [Customers] AS [c]
|
|
ORDER BY [c].[City]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_with_where(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_with_where(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[City], [c].[CustomerID]
|
|
FROM [Customers] AS [c]
|
|
WHERE [c].[Country] IN ('Argentina', 'Austria', 'Brazil', 'France', 'Germany', 'USA')
|
|
ORDER BY [c].[City]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_subquery(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_subquery(isAsync);
|
|
|
|
AssertSql(" ");
|
|
}
|
|
|
|
public override async Task GroupBy_nested_order_by_enumerable(bool isAsync)
|
|
{
|
|
await base.GroupBy_nested_order_by_enumerable(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[Country], [c].[CustomerID]
|
|
FROM [Customers] AS [c]
|
|
ORDER BY [c].[Country]");
|
|
}
|
|
|
|
public override async Task GroupBy_join_default_if_empty_anonymous(bool isAsync)
|
|
{
|
|
await base.GroupBy_join_default_if_empty_anonymous(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [order0].[OrderID], [order0].[CustomerID], [order0].[EmployeeID], [order0].[OrderDate], [orderDetail0].[OrderID], [orderDetail0].[ProductID], [orderDetail0].[Discount], [orderDetail0].[Quantity], [orderDetail0].[UnitPrice]
|
|
FROM [Orders] AS [order0]
|
|
LEFT JOIN [Order Details] AS [orderDetail0] ON [order0].[OrderID] = [orderDetail0].[OrderID]
|
|
ORDER BY [order0].[OrderID]");
|
|
}
|
|
|
|
public override async Task GroupBy_SelectMany(bool isAsync)
|
|
{
|
|
await base.GroupBy_SelectMany(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]
|
|
FROM [Customers] AS [c]
|
|
ORDER BY [c].[City]");
|
|
}
|
|
|
|
public override async Task GroupBy_simple(bool isAsync)
|
|
{
|
|
await base.GroupBy_simple(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_simple2(bool isAsync)
|
|
{
|
|
await base.GroupBy_simple2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_first(bool isAsync)
|
|
{
|
|
await base.GroupBy_first(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
WHERE [o].[CustomerID] = 'ALFKI'
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_element_selector(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_element_selector(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID], [o].[OrderID]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_element_selector2(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_element_selector2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_element_selector3(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_element_selector3(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [e].[EmployeeID], [e].[City], [e].[Country], [e].[FirstName], [e].[ReportsTo], [e].[Title]
|
|
FROM [Employees] AS [e]
|
|
ORDER BY [e].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_DateTimeOffset_Property(bool isAsync)
|
|
{
|
|
await base.GroupBy_DateTimeOffset_Property(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
WHERE [o].[OrderDate] IS NOT NULL
|
|
ORDER BY DATEPART('m', [o].[OrderDate])");
|
|
}
|
|
|
|
public override async Task OrderBy_GroupBy_SelectMany(bool isAsync)
|
|
{
|
|
await base.OrderBy_GroupBy_SelectMany(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID], [o].[OrderID]");
|
|
}
|
|
|
|
public override async Task OrderBy_GroupBy_SelectMany_shadow(bool isAsync)
|
|
{
|
|
await base.OrderBy_GroupBy_SelectMany_shadow(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [e].[EmployeeID], [e].[City], [e].[Country], [e].[FirstName], [e].[ReportsTo], [e].[Title]
|
|
FROM [Employees] AS [e]
|
|
ORDER BY [e].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_orderby(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_orderby(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID], [o].[OrderID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_orderby_and_anonymous_projection(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_orderby_and_anonymous_projection(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_orderby_take_skip_distinct(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_orderby_take_skip_distinct(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_orderby_take_skip_distinct_followed_by_group_key_projection(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_orderby_take_skip_distinct_followed_by_group_key_projection(isAsync);
|
|
|
|
AssertSql(
|
|
"");
|
|
}
|
|
|
|
public override async Task GroupBy_with_orderby_take_skip_distinct_followed_by_order_by_group_key(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_orderby_take_skip_distinct_followed_by_order_by_group_key(isAsync);
|
|
|
|
AssertSql(
|
|
"");
|
|
}
|
|
|
|
public override async Task GroupBy_join_anonymous(bool isAsync)
|
|
{
|
|
await base.GroupBy_join_anonymous(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [order0].[OrderID], [order0].[CustomerID], [order0].[EmployeeID], [order0].[OrderDate], [orderDetail0].[OrderID], [orderDetail0].[ProductID], [orderDetail0].[Discount], [orderDetail0].[Quantity], [orderDetail0].[UnitPrice]
|
|
FROM [Orders] AS [order0]
|
|
LEFT JOIN [Order Details] AS [orderDetail0] ON [order0].[OrderID] = [orderDetail0].[OrderID]
|
|
ORDER BY [order0].[OrderID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Distinct(bool isAsync)
|
|
{
|
|
await base.GroupBy_Distinct(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]
|
|
FROM [Orders] AS [o0]
|
|
ORDER BY [o0].[CustomerID]");
|
|
}
|
|
|
|
public override async Task OrderBy_Skip_GroupBy(bool isAsync)
|
|
{
|
|
await base.OrderBy_Skip_GroupBy(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='800'
|
|
|
|
SELECT [t].[OrderID], [t].[CustomerID], [t].[EmployeeID], [t].[OrderDate]
|
|
FROM (
|
|
SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[OrderDate], [o].[OrderID]
|
|
SKIP @__p_0
|
|
) AS [t]
|
|
ORDER BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task OrderBy_Take_GroupBy(bool isAsync)
|
|
{
|
|
await base.OrderBy_Take_GroupBy(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='50'
|
|
|
|
SELECT [t].[OrderID], [t].[CustomerID], [t].[EmployeeID], [t].[OrderDate]
|
|
FROM (
|
|
SELECT TOP @__p_0 [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[OrderDate]
|
|
) AS [t]
|
|
ORDER BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task OrderBy_Skip_Take_GroupBy(bool isAsync)
|
|
{
|
|
await base.OrderBy_Skip_Take_GroupBy(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='450'
|
|
@__p_1='50'
|
|
|
|
SELECT [t].[OrderID], [t].[CustomerID], [t].[EmployeeID], [t].[OrderDate]
|
|
FROM (
|
|
SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
WHERE ([o].[CustomerID] <> 'SAVEA') OR [o].[CustomerID] IS NULL
|
|
ORDER BY [o].[OrderDate]
|
|
SKIP @__p_0 FETCH NEXT @__p_1 ROWS ONLY
|
|
) AS [t]
|
|
ORDER BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Select_Distinct_GroupBy(bool isAsync)
|
|
{
|
|
await base.Select_Distinct_GroupBy(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [t].[CustomerID], [t].[EmployeeID]
|
|
FROM (
|
|
SELECT DISTINCT [o].[CustomerID], [o].[EmployeeID]
|
|
FROM [Orders] AS [o]
|
|
) AS [t]
|
|
ORDER BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_aggregate_through_navigation_property(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_aggregate_through_navigation_property(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[OrderID], [c].[CustomerID], [c].[EmployeeID], [c].[OrderDate]
|
|
FROM [Orders] AS [c]
|
|
ORDER BY [c].[EmployeeID]",
|
|
//
|
|
@"SELECT [i.Customer0].[CustomerID], [i.Customer0].[Region]
|
|
FROM [Customers] AS [i.Customer0]",
|
|
//
|
|
@"SELECT [i.Customer0].[CustomerID], [i.Customer0].[Region]
|
|
FROM [Customers] AS [i.Customer0]");
|
|
}
|
|
|
|
public override async Task GroupBy_anonymous_key_without_aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_anonymous_key_without_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID], [o].[OrderDate]");
|
|
}
|
|
|
|
public override async Task GroupBy_Shadow(bool isAsync)
|
|
{
|
|
await base.GroupBy_Shadow(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [e].[EmployeeID], [e].[City], [e].[Country], [e].[FirstName], [e].[ReportsTo], [e].[Title]
|
|
FROM [Employees] AS [e]
|
|
WHERE ([e].[Title] = 'Sales Representative') AND ([e].[EmployeeID] = 1)
|
|
ORDER BY [e].[Title]");
|
|
}
|
|
|
|
public override async Task GroupBy_Shadow2(bool isAsync)
|
|
{
|
|
await base.GroupBy_Shadow2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [e].[EmployeeID], [e].[City], [e].[Country], [e].[FirstName], [e].[ReportsTo], [e].[Title]
|
|
FROM [Employees] AS [e]
|
|
WHERE ([e].[Title] = 'Sales Representative') AND ([e].[EmployeeID] = 1)
|
|
ORDER BY [e].[Title]");
|
|
}
|
|
|
|
public override async Task GroupBy_Shadow3(bool isAsync)
|
|
{
|
|
await base.GroupBy_Shadow3(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [e].[EmployeeID], [e].[City], [e].[Country], [e].[FirstName], [e].[ReportsTo], [e].[Title]
|
|
FROM [Employees] AS [e]
|
|
WHERE [e].[EmployeeID] = 1
|
|
ORDER BY [e].[EmployeeID]");
|
|
}
|
|
|
|
public override async Task GroupBy_Select_First_GroupBy(bool isAsync)
|
|
{
|
|
await base.GroupBy_Select_First_GroupBy(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]
|
|
FROM [Customers] AS [c]
|
|
ORDER BY [c].[City]");
|
|
}
|
|
|
|
public override async Task GroupBy_Select_First_GroupBy_followed_by_identity_projection(bool isAsync)
|
|
{
|
|
await base.GroupBy_Select_First_GroupBy_followed_by_identity_projection(isAsync);
|
|
|
|
AssertSql(
|
|
"");
|
|
}
|
|
|
|
public override async Task Select_GroupBy(bool isAsync)
|
|
{
|
|
await base.Select_GroupBy(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID] AS [Order], [o].[CustomerID] AS [Customer]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Select_GroupBy_SelectMany(bool isAsync)
|
|
{
|
|
await base.Select_GroupBy_SelectMany(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID] AS [Order], [o].[CustomerID] AS [Customer]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[OrderID]");
|
|
}
|
|
|
|
public override async Task Join_GroupBy_entity_ToList(bool isAsync)
|
|
{
|
|
await base.Join_GroupBy_entity_ToList(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='5'
|
|
@__p_1='50'
|
|
|
|
SELECT [t1].[CustomerID], [t1].[Address], [t1].[City], [t1].[CompanyName], [t1].[ContactName], [t1].[ContactTitle], [t1].[Country], [t1].[Fax], [t1].[Phone], [t1].[PostalCode], [t1].[Region], [t2].[OrderID], [t2].[CustomerID], [t2].[EmployeeID], [t2].[OrderDate]
|
|
FROM (
|
|
SELECT TOP @__p_0 [c0].[CustomerID], [c0].[Address], [c0].[City], [c0].[CompanyName], [c0].[ContactName], [c0].[ContactTitle], [c0].[Country], [c0].[Fax], [c0].[Phone], [c0].[PostalCode], [c0].[Region]
|
|
FROM [Customers] AS [c0]
|
|
ORDER BY [c0].[CustomerID]
|
|
) AS [t1]
|
|
INNER JOIN (
|
|
SELECT TOP @__p_1 [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]
|
|
FROM [Orders] AS [o0]
|
|
ORDER BY [o0].[OrderID]
|
|
) AS [t2] ON [t1].[CustomerID] = [t2].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Double_GroupBy_with_aggregate(bool isAsync)
|
|
{
|
|
await base.Double_GroupBy_with_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]
|
|
FROM [Orders] AS [o0]
|
|
ORDER BY [o0].[OrderID], [o0].[OrderDate]");
|
|
}
|
|
|
|
public override async Task Count_after_GroupBy_aggregate(bool isAsync)
|
|
{
|
|
await base.Count_after_GroupBy_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT COUNT(*)
|
|
FROM (
|
|
SELECT SUM([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
) AS [t]");
|
|
}
|
|
|
|
public override async Task LongCount_after_client_GroupBy(bool isAsync)
|
|
{
|
|
await base.LongCount_after_client_GroupBy(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task MinMax_after_GroupBy_aggregate(bool isAsync)
|
|
{
|
|
await base.MinMax_after_GroupBy_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT MIN([t].[c])
|
|
FROM (
|
|
SELECT SUM([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
) AS [t]",
|
|
//
|
|
@"SELECT MAX([t].[c])
|
|
FROM (
|
|
SELECT SUM([o].[OrderID]) AS [c]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
) AS [t]");
|
|
}
|
|
|
|
public override async Task All_after_GroupBy_aggregate(bool isAsync)
|
|
{
|
|
await base.All_after_GroupBy_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT CASE
|
|
WHEN NOT EXISTS (
|
|
SELECT 1
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING False = True) THEN True
|
|
ELSE False
|
|
END");
|
|
}
|
|
|
|
public override async Task All_after_GroupBy_aggregate2(bool isAsync)
|
|
{
|
|
await base.All_after_GroupBy_aggregate2(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT CASE
|
|
WHEN NOT EXISTS (
|
|
SELECT 1
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]
|
|
HAVING SUM([o].[OrderID]) < 0) THEN True
|
|
ELSE False
|
|
END");
|
|
}
|
|
|
|
public override async Task Any_after_GroupBy_aggregate(bool isAsync)
|
|
{
|
|
await base.Any_after_GroupBy_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT CASE
|
|
WHEN EXISTS (
|
|
SELECT 1
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]) THEN True
|
|
ELSE False
|
|
END");
|
|
}
|
|
|
|
public override async Task Count_after_GroupBy_without_aggregate(bool isAsync)
|
|
{
|
|
await base.Count_after_GroupBy_without_aggregate(isAsync);
|
|
|
|
AssertSql(" ");
|
|
}
|
|
|
|
public override async Task LongCount_after_GroupBy_without_aggregate(bool isAsync)
|
|
{
|
|
await base.LongCount_after_GroupBy_without_aggregate(isAsync);
|
|
|
|
AssertSql(" ");
|
|
}
|
|
|
|
public override async Task GroupBy_based_on_renamed_property_simple(bool isAsync)
|
|
{
|
|
await base.GroupBy_based_on_renamed_property_simple(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[City] AS [Renamed], COUNT(*) AS [Count]
|
|
FROM [Customers] AS [c]
|
|
GROUP BY [c].[City]");
|
|
}
|
|
|
|
public override async Task GroupBy_based_on_renamed_property_complex(bool isAsync)
|
|
{
|
|
await base.GroupBy_based_on_renamed_property_complex(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [t].[City] AS [Key], COUNT(*) AS [Count]
|
|
FROM (
|
|
SELECT DISTINCT [c].[City], [c].[CustomerID]
|
|
FROM [Customers] AS [c]
|
|
) AS [t]
|
|
GROUP BY [t].[City]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_group_key_access_thru_navigation(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_group_key_access_thru_navigation(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o0].[CustomerID] AS [Key], SUM([o].[OrderID]) AS [Aggregate]
|
|
FROM [Order Details] AS [o]
|
|
INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
|
|
GROUP BY [o0].[CustomerID]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_group_key_access_thru_nested_navigation(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_group_key_access_thru_nested_navigation(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [c].[Country] AS [Key], SUM([o].[OrderID]) AS [Aggregate]
|
|
FROM [Order Details] AS [o]
|
|
INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
|
|
LEFT JOIN [Customers] AS [c] ON [o0].[CustomerID] = [c].[CustomerID]
|
|
GROUP BY [c].[Country]");
|
|
}
|
|
|
|
public override async Task GroupBy_with_group_key_being_navigation(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_group_key_being_navigation(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task GroupBy_with_group_key_being_nested_navigation(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_group_key_being_nested_navigation(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task GroupBy_with_group_key_being_navigation_with_entity_key_projection(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_group_key_being_navigation_with_entity_key_projection(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task GroupBy_with_group_key_being_navigation_with_complex_projection(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_group_key_being_navigation_with_complex_projection(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task GroupBy_with_order_by_skip_and_another_order_by(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_order_by_skip_and_another_order_by(isAsync);
|
|
|
|
AssertSql(
|
|
@"@__p_0='80'
|
|
|
|
SELECT SUM([t].[OrderID])
|
|
FROM (
|
|
SELECT [o].[OrderID], [o].[CustomerID], [o].[EmployeeID], [o].[OrderDate]
|
|
FROM [Orders] AS [o]
|
|
ORDER BY [o].[CustomerID], [o].[OrderID]
|
|
SKIP @__p_0
|
|
) AS [t]
|
|
GROUP BY [t].[CustomerID]");
|
|
}
|
|
|
|
public override Task GroupBy_Property_Select_Count_with_predicate(bool isAsync)
|
|
{
|
|
return Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => base.GroupBy_Property_Select_Count_with_predicate(isAsync));
|
|
}
|
|
|
|
public override Task GroupBy_Property_Select_LongCount_with_predicate(bool isAsync)
|
|
{
|
|
return Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => base.GroupBy_Property_Select_LongCount_with_predicate(isAsync));
|
|
}
|
|
|
|
public override async Task GroupBy_with_grouping_key_using_Like(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_grouping_key_using_Like(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT IIF([o].[CustomerID] LIKE 'A' & '%', 1, 0) AS [Key], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY IIF([o].[CustomerID] LIKE 'A' & '%', 1, 0)");
|
|
}
|
|
|
|
public override async Task GroupBy_with_grouping_key_DateTime_Day(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_grouping_key_DateTime_Day(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT DATEPART('d', [o].[OrderDate]) AS [Key], COUNT(*) AS [Count]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY DATEPART('d', [o].[OrderDate])");
|
|
}
|
|
|
|
public override async Task GroupBy_with_cast_inside_grouping_aggregate(bool isAsync)
|
|
{
|
|
await base.GroupBy_with_cast_inside_grouping_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], COUNT(*) AS [Count], SUM(CAST([o].[OrderID] AS bigint)) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
public override async Task Complex_query_with_groupBy_in_subquery1(bool isAsync)
|
|
{
|
|
await base.Complex_query_with_groupBy_in_subquery1(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task Complex_query_with_groupBy_in_subquery2(bool isAsync)
|
|
{
|
|
await base.Complex_query_with_groupBy_in_subquery2(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task Complex_query_with_groupBy_in_subquery3(bool isAsync)
|
|
{
|
|
await base.Complex_query_with_groupBy_in_subquery3(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task Complex_query_with_groupBy_in_subquery4(bool isAsync)
|
|
{
|
|
await base.Complex_query_with_groupBy_in_subquery4(isAsync);
|
|
|
|
AssertSql(
|
|
@"");
|
|
}
|
|
|
|
public override async Task Group_by_with_arithmetic_operation_inside_aggregate(bool isAsync)
|
|
{
|
|
await base.Group_by_with_arithmetic_operation_inside_aggregate(isAsync);
|
|
|
|
AssertSql(
|
|
@"SELECT [o].[CustomerID] AS [Key], SUM([o].[OrderID] + CAST(LEN([o].[CustomerID]) AS int)) AS [Sum]
|
|
FROM [Orders] AS [o]
|
|
GROUP BY [o].[CustomerID]");
|
|
}
|
|
|
|
private void AssertSql(params string[] expected)
|
|
=> Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
|
|
|
|
protected override void ClearLog()
|
|
=> Fixture.TestSqlLoggerFactory.Clear();
|
|
}
|
|
}
|