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 indb.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  wherep.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 ine.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 ine1.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.Orderson 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.Orderson c.CustomerID   equals o.CustomerID into ords   join e indb.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.Employeeinto 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 赋值(Projectedlet assignment)：

 

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

 

这个例子从联接投影 出最终“Let”表达式：

 

var q =   from c indb.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 indb.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 indb.Employees     on o.EmployeeID equals     (int?)e.EmployeeIDinto emps    from e in emps   select new 
  { 
     o.OrderID, 
    e.FirstName 
  };