LINQ体验(6)——LINQ to SQL语句之Join和Order By

LINQ体验(6)——LINQ to SQL语句之Join和Order By
Join操作

适用场景：在我们表关系中有一对一关系，一对多关系。多对多关系等。对各个表之间的关系，就用这些实现对多个表的操作。

说明：在Join操作中。分别为Join(Join查询), SelectMany(Select一对多选择)和GroupJoin(分组Join查询)。

该扩展方法对两个序列中键匹配的元素进行inner join操作

SelectMany

说明：我们在写查询语句时，假设被翻译成SelectMany须要满足2个条件。1：查询语句中没有join和into。2：必须出现EntitySet。在我们表关系中有一对一关系，一对多关系，多对多关系等。以下分别介绍一下。

1.一对多关系(1 to Many)：
```
var q =
    from c in db.Customers
    from o in c.Orders
    where c.City == "London"
    select o;
```
语句描写叙述：Customers与Orders是一对多关系。
即Orders在Customers类中以EntitySet形式出现。
所以第二个from是从c.Orders而不是db.Orders里进行筛选。这个样例在From子句中使用外键导航选择伦敦客户的全部订单。
```
var q =
    from p in db.Products
    where p.Supplier.Country == "USA" && p.UnitsInStock == 0
    select p;
```
语句描写叙述：这一句使用了p.Supplier.Country条件，间接关联了Supplier表。这个样例在Where子句中使用外键导航筛选其供应商在美国且缺货的产品。生成SQL语句为：
```
SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID],
[t0].[CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice], 
[t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0].[ReorderLevel],
[t0].[Discontinued] FROM [dbo].[Products] AS [t0]
LEFT OUTER JOIN [dbo].[Suppliers] AS [t1] ON 
[t1].[SupplierID] = [t0].[SupplierID]
WHERE ([t1].[Country] = @p0) AND ([t0].[UnitsInStock] = @p1)
-- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [USA]
-- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0]
```
2.多对多关系(Many to Many)：
```
var q =
    from e in db.Employees
    from et in e.EmployeeTerritories
    where e.City == "Seattle"
    select new
    {
        e.FirstName,
        e.LastName,
        et.Territory.TerritoryDescription
    };
```
说明：多对多关系通常会涉及三个表(假设有一个表是自关联的，那有可能仅仅有2个表)。这一句语句涉及Employees, EmployeeTerritories, Territories三个表。它们的关系是1：M：1。
Employees和Territories没有非常明白的关系。

语句描写叙述：这个样例在From子句中使用外键导航筛选在西雅图的雇员。同一时候列出其所在地区。
这条生成SQL语句为：
```
SELECT [t0].[FirstName], [t0].[LastName], [t2].[TerritoryDescription]
FROM [dbo].[Employees] AS [t0] CROSS JOIN [dbo].[EmployeeTerritories]
AS [t1] INNER JOIN [dbo].[Territories] AS [t2] ON 
[t2].[TerritoryID] = [t1].[TerritoryID]
WHERE ([t0].[City] = @p0) AND ([t1].[EmployeeID] = [t0].[EmployeeID])
-- @p0: Input NVarChar (Size = 7; Prec = 0; Scale = 0) [Seattle]
```
3.自联接关系：
```
var q =
    from e1 in db.Employees
    from e2 in e1.Employees
    where e1.City == e2.City
    select new {
        FirstName1 = e1.FirstName, LastName1 = e1.LastName,
        FirstName2 = e2.FirstName, LastName2 = e2.LastName,
        e1.City
    };
```
语句描写叙述：这个样例在select 子句中使用外键导航筛选成对的雇员，每对中一个雇员隶属于还有一个雇员。且两个雇员都来自同样城市。生成SQL语句为：
```
SELECT [t0].[FirstName] AS [FirstName1], [t0].[LastName] AS 
[LastName1],[t1].[FirstName] AS [FirstName2], [t1].[LastName] AS 
[LastName2],[t0].[City] FROM [dbo].[Employees] AS [t0],
[dbo].[Employees] AS [t1] WHERE ([t0].[City] = [t1].[City]) AND 
([t1].[ReportsTo] = [t0].[EmployeeID])
```
GroupJoin

像上面所说的，没有join和into，被翻译成SelectMany，同一时候有join和into时。那么就被翻译为GroupJoin。在这里into的概念是对其结果进行又一次命名。

1.双向联接(Two way join)：

此演示样例显式联接两个表并从这两个表投影出结果：
```
var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID
    equals o.CustomerID into orders
    select new
    {
        c.ContactName,
        OrderCount = orders.Count()
    };
```
说明：在一对多关系中，左边是1，它每条记录为c（from c in db.Customers），右边是Many，其每条记录叫做o ( join o in db.Orders )，每相应左边的一个c，就会有一组o，那这一组o，就叫做orders，也就是说，我们把一组o命名为orders。这就是into用途。这也就是为什么在select语句中。orders能够调用聚合函数Count。在T-SQL中，使用其内嵌的T-SQL返回值作为字段值。如图所看到的：

生成SQL语句为：
```
SELECT [t0].[ContactName], (
    SELECT COUNT(*)
    FROM [dbo].[Orders] AS [t1]
    WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [OrderCount]
FROM [dbo].[Customers] AS [t0]
```
2.三向联接(There way join)：

此演示样例显式联接三个表并分别从每一个表投影出结果：
```
var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID
    equals o.CustomerID into ords
    join e in db.Employees on c.City
    equals e.City into emps
    select new
    {
        c.ContactName,
        ords = ords.Count(),
        emps = emps.Count()
    };
```
生成SQL语句为：
```
SELECT [t0].[ContactName], (
    SELECT COUNT(*)
    FROM [dbo].[Orders] AS [t1]
    WHERE [t0].[CustomerID] = [t1].[CustomerID]
) AS [ords], (
SELECT COUNT(*)
    FROM [dbo].[Employees] AS [t2]
    WHERE [t0].[City] = [t2].[City]
) AS [emps]
FROM [dbo].[Customers] AS [t0]
```
3.左外部联接(Left Outer Join)：

此演示样例说明怎样通过使用此演示样例说明怎样通过使用DefaultIfEmpty() 获取左外部联接。
在雇员没有订单时，DefaultIfEmpty()方法返回null：
```
var q =
    from e in db.Employees
    join o in db.Orders on e equals o.Employee into ords
    from o in ords.DefaultIfEmpty()
    select new
    {
        e.FirstName,
        e.LastName,
        Order = o
    };
```
说明：以Employees左表，Orders右表。Orders 表中为空时。用null值填充。Join的结果重命名ords。使用DefaultIfEmpty()函数对其再次查询。其最后的结果中有个Order，由于from o in ords.DefaultIfEmpty() 是对ords组再一次遍历。所以，最后结果中的Order并非一个集合。可是，假设没有from o in ords.DefaultIfEmpty() 这句，最后的select语句写成select new { e.FirstName, e.LastName, Order = ords }的话，那么Order就是一个集合。

4.投影的Let赋值(Projected let assignment)：

说明：let语句是重命名。
let位于第一个from和select语句之间。

这个样例从联接投影出终于“Let”表达式：
```
var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID
    equals o.CustomerID into ords
    let z = c.City + c.Country
    from o in ords
    select new
    {
        c.ContactName,
        o.OrderID,
        z
    };
```
5.组合键(Composite Key)：

这个样例显示带有组合键的联接：
```
var q =
    from o in db.Orders
    from p in db.Products
    join d in db.OrderDetails
        on new
        {
            o.OrderID,
            p.ProductID
        } equals
            new
            {
                d.OrderID,
                d.ProductID
            }
        into details
    from d in details
    select new
    {
        o.OrderID,
        p.ProductID,
        d.UnitPrice
    };
```
说明：使用三个表，而且用匿名类来说明：使用三个表，而且用匿名类来表示它们之间的关系。它们之间的关系不能用一个键描写叙述清楚。所以用匿名类，来表示组合键。
另一种是两个表之间是用组合键表示关系的，不须要使用匿名类。

6.可为null/不可为null的键关系(Nullable/Nonnullable Key Relationship)：

这个实例显示怎样构造一側可为 null 而还有一側不可为 null 的联接：
```
var q =
    from o in db.Orders
    join e in db.Employees
        on o.EmployeeID equals
        (int?)e.EmployeeID into emps
    from e in emps
    select new
    {
        o.OrderID,
        e.FirstName
    };
```
Order By操作

适用场景：对查询出的语句进行排序，比方按时间排序等等。

说明：按指定表达式对集合排序；延迟。：按指定表达式对集合排序；延迟，默认是升序，加上descending表示降序。相应的扩展方法是OrderBy和OrderByDescending

1.简单形式

这个样例使用 orderby 按雇用日期对雇员进行排序：
```
var q =
    from e in db.Employees
    orderby e.HireDate
    select e;
```
说明：默觉得升序

2.带条件形式

注意：Where和Order By的顺序并不重要。而在T-SQL中，Where和Order By有严格的位置限制。
```
var q =
    from o in db.Orders
    where o.ShipCity == "London"
    orderby o.Freight
    select o;
```
语句描写叙述：使用where和orderby按运费进行排序。

3.降序排序
```
var q = 
    from p in db.Products
    orderby p.UnitPrice descending
    select p;
```
4.ThenBy

语句描写叙述：使用复合的 orderby 对客户进行排序。进行排序：
```
var q =
    from c in db.Customers
    orderby c.City, c.ContactName
    select c;
```
说明：按多个表达式进行排序。比如先按City排序。当City同样时。按ContactName排序。
这一句用Lambda表达式像这样写：
```
var q = 
    db.Customers
    .OrderBy(c => c.City)
    .ThenBy(c => c.ContactName).ToList();
```
在T-SQL中没有ThenBy语句，其依旧翻译为OrderBy，所以也能够用以下语句来表达：
```
var q = 
    db.Customers
    .OrderBy(c => c.ContactName)
    .OrderBy(c => c.City).ToList();
```
所要注意的是，多个OrderBy操作时，级连方式是按逆序。
对于降序的。用对应的降序操作符替换就可以。
```
var q = 
    db.Customers
    .OrderByDescending(c => c.City)
    .ThenByDescending(c => c.ContactName).ToList();
```
须要说明的是。OrderBy操作，不支持按type排序，也不支持匿名类。比方
```
var q = 
    db.Customers
    .OrderBy(c => new
    {
        c.City,
        c.ContactName
    }).ToList();
```
会被抛出异常。
错误是前面的操作有匿名类，再跟OrderBy时，比較的是类别。比方
```
var q = 
    db.Customers
    .Select(c => new
    {
        c.City,
        c.Address
    })
    .OrderBy(c => c).ToList();
```
假设你想使用OrderBy(c => c)，其前提条件是，前面步骤中，所产生的对象的类别必须为C#语言的基本类型。
比方下句，这里City为string类型。
```
var q = 
    db.Customers
    .Select(c => c.City)
    .OrderBy(c => c).ToList();
```
5.ThenByDescending

这两个扩展方式都是用在OrderBy/OrderByDescending之后的，第一个ThenBy/ThenByDescending扩展方法作为第二位排序根据，第二个ThenBy/ThenByDescending则作为第三位排序根据，以此类推
```
var q =
    from o in db.Orders
    where o.EmployeeID == 1
    orderby o.ShipCountry, o.Freight descending
    select o;
```
语句描写叙述：使用orderby先按发往国家再按运费从高到低的顺序对 EmployeeID 1 的订单进行排序。

6.带GroupBy形式
```
var q = 
    from p in db.Products
    group p by p.CategoryID into g
    orderby g.Key
    select new {
        g.Key,
        MostExpensiveProducts =
            from p2 in g
            where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
            select p2
    };
```
语句描写叙述：使用orderby、Max 和 Group By 得出每种类别中单位价格最高的产品，并按 CategoryID 对这组产品进行排序。
相关阅读:
Python学习 Day 1-简介安装 Hello world
R Programming week2 Functions and Scoping Rules
R in action读书笔记（6）-第七章：基本统计分析（中）
R in action读书笔记（5）-第七章：基本统计分析
 Redis进阶应用：Redis+Lua脚本实现复合操作
 一个项目的SpringCloud微服务改造过程
 中间件增强框架之-CaptureFramework框架
 关系型数据库全表扫描分片详解
 AI中台——智能聊天机器人平台的架构与应用（分享实录）
如何设计实时数据平台（设计篇）
原文地址：https://www.cnblogs.com/cxchanpin/p/7283516.html

LINQ体验(6)——LINQ to SQL语句之Join和Order By

Join操作

SelectMany

1.一对多关系(1 to Many)：

2.多对多关系(Many to Many)：

3.自联接关系：

GroupJoin

1.双向联接(Two way join)：

2.三向联接(There way join)：

3.左外部联接(Left Outer Join)：

4.投影的Let赋值(Projected let assignment)：

5.组合键(Composite Key)：

6.可为null/不可为null的键关系(Nullable/Nonnullable Key Relationship)：

Order By操作

1.简单形式

2.带条件形式

3.降序排序

4.ThenBy

5.ThenByDescending

6.带GroupBy形式