LINQ to SQL语句(4)之Join

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

　　};