C#3.0入门系列（十）-之Join操作

 本节讲join操作。我们知道，T-sql中，有三种最基本的join，inner join, left join, 和right join。 而dlinq并不支持right join。道理很简单，right join以right表为基础，left表中没有对应记录的，将以null值填充。而dlinq以left表做为主表创建对象。如果一个对象为null,你如何获取它的其他的属性呢？

在C# 3.0入门系列（四）-之Select操作一文中，我们提到了query expression首先会被翻译成标准的API, 而dlinq在join操作中，一共为我们提供了三个API.它们是Join, SelectMany和GroupJoin

Join
在101 的sample中，并没有join的例子。当一个query expression 有join字句时，而没有into字句，它将会被翻译成join方法。如，以Customers为主表,Orders为子表，用CustomerID 做关联进行join操作。

            var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID equals o.CustomerID

    select new { c.CustomerID, o.EmployeeID };

它将会被翻译成

var q = db.Customers.Join(db.Orders, c => c.CustomerID, o => o.CustomerID, (c, o) => new { c.CustomerID, o.EmployeeID });

join方法的第一个参数，为子表，第二个参数，表示主表中的选择键，第三个参数为子表中的对应键，第四个为最终筛选结果。大家需要注意的时，因为参数的顺序是确定的，所以在写dlinq语句时，c.CustomerID equals o.CustomerID 的顺序是不能变的。
该语句所产生的T-sql语句为

SELECT [t0].[CustomerID], [t1].[EmployeeID]
FROM [Customers] AS [t0]
INNER JOIN [Orders] AS [t1] ON [t0].[CustomerID] = [t1].[CustomerID]

SelectMany
在101sample中，给了4个SelectMany的例子。会被翻译成SelectMany需要满足2个条件。1，query语句中没有join和into，2，必须出现EntitySet。 关于EntitySet,请参考C#3.0进阶系列（一）-从映射讲起
先看第一个例子

    var q =
        from c in db.Customers
        from o in c.Orders
        where c.City == "London"
        select o;

Customers与Orders是1:M的关系。即Orders在Customers类中，以EntitySet出现。所以第二个from是从c.Orders而不是db.Orders里进行筛选。定义了他们关系的Mapping Code用Attribute保存了他们的关系。如
[Association(Name="Order_OrderDetail", Storage="_OrderDetails", OtherKey="OrderID")]
[Association(Name="Order_OrderDetail", Storage="_Order", ThisKey="OrderID", IsForeignKey=true)]
所以，你就不用担心，dlinq是否知道该按那个键进行关联。有兴趣的朋友，可以自己修改这里的OtherKey和ThisKey的值，看看翻译的T-sql语句是否变了。
第二个例子

    var q =
        from p in db.Products
        where p.Supplier.Country == "USA" && p.UnitsInStock == 0
        select p;

这个例子，直接就使用了p.Supplier.Country 做条件，这样，也间接关联了Supplier表。该语句生成的T-sql语句更是值得揣摩，这大概是Left Out Join 的最简单的Dlinq语句。

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 String (Size = 3; Prec = 0; Scale = 0) [USA]
-- @p1: Input Int32 (Size = 0; Prec = 0; Scale = 0) [0]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

第三个例子是M : M的关系

    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};

M:M的关系，一般会涉及三个表。（如果，有一个表是自关联的，那有可能只有2个表。）在这里，涉及Employees, EmployeeTerritories, Territories共三个表。它们的关系是1 : M : 1. Employees和Territories没有很明确的关系。这个例子和上一个不同的是，它是在Select字句中，牵扯到Territories表。其生成的T-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 String (Size = 7; Prec = 0; Scale = 0) [Seattle]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

最后一个例子是自关联的，并且夹带了条件

    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
        };

其T-sql为

SELECT [t0].[FirstName], [t0].[LastName], [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])
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

从上面的例子我们可以看出，Dlinq以非常灵活的方式，处理其内部各表的关系。它不须显式的声明需要关联到那个表，也可以放在Where和Select等子句中，隐式关联。

GroupJoin
当dlinq语句中，有join而且还有into时，它会被翻译为GroupJoin.我们先来看第一个例子。

    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()};

本系列曾在C#3.0入门系列（八）-之GroupBy操作 一文中，第一次谈到到into。into的概念是对其结果进行重新命名。为什么需要重新命名呢？我们以本例为例。One To Many的关系中，左边是one，它每条记录叫做c（from c in db.Customers），右边是many，其每条记录叫做o ( join o in db.Orders )，每对应左边的一个c，都会有一组o，那这一组o，就叫做orders，也就是说，我们把一组o命名为orders，这就是into用途。（和groupby中类似）。这也就是为什么在select语句中，orders可以调用聚合函数Count。

在这个例子中，翻译的t-sql为

SELECT [t0].[ContactName], (
    SELECT COUNT(*)
    FROM [dbo].[Orders] AS [t1]
    WHERE [t0].[CustomerID] = [t1].[CustomerID]
    ) AS [value]
FROM [dbo].[Customers] AS [t0]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

dlinq很聪明，直接用其内欠的t-sql返回值作为字段值。
第二个例子

    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()};

三个表联合查询。在其join语句后，紧跟着又是一个join.只是表多了些，并没有太多新鲜的东西。
第三个例子

    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};

Left Out Join的标准写法。以Employees为左表，Orders 为右，Orders 表中为空时，填冲null值。在将join的结果重命名后，再使用DefaultEmpty()函数，对其再次查询。大家需要注意的时，其最后的结果中有个Order，因为from o in ords.DefaultIfEmpty() 是对ords组再一次遍历，所以，最后结果中的Order并不是一个集合。但是，如果没有from o in ords.DefaultIfEmpty() 这句，最后的select语句写成select new { e.FirstName, e.LastName, Order = ords }的话，那Order就是一个集合
上例翻译的T-sql 为

SELECT [t0].[FirstName], [t0].[LastName], [t2].[test], [t2].[OrderID], [t2].[CustomerID], [t2].[EmployeeID], [t2].[OrderDate], [t2].[RequiredDate], [t2].[ShippedDate], [t2].[ShipVia], [t2].[Freight], [t2].[ShipName], [t2].[ShipAddress], [t2].[ShipCity], [t2].[ShipRegion], [t2].[ShipPostalCode], [t2].[ShipCountry]
FROM [dbo].[Employees] AS [t0]
LEFT OUTER JOIN (
    SELECT 1 AS [test], [t1].[OrderID], [t1].[CustomerID], [t1].[EmployeeID], [t1].[OrderDate], [t1].[RequiredDate], [t1].[ShippedDate], [t1].[ShipVia], [t1].[Freight], [t1].[ShipName], [t1].[ShipAddress], [t1].[ShipCity], [t1].[ShipRegion], [t1].[ShipPostalCode], [t1].[ShipCountry]
    FROM [dbo].[Orders] AS [t1]
    ) AS [t2] ON [t0].[EmployeeID] = [t2].[EmployeeID]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

第四个例子，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};

let语句有点类似into，也是个重命名的概念。需要提醒大家的是，let只要是放在第一个from后，select语句前就是符合语法的。上面的语句和下面这条是等价的。

            var q =
                from c in db.Customers
                let z = c.City + c.Country                
                join o in db.Orders on c.CustomerID equals o.CustomerID into ords               
                from o in ords
                select new { c.ContactName, o.OrderID, z };

其产生的T-sql均为：

SELECT [t1].[ContactName], [t2].[OrderID], [t1].[value]
FROM (
    SELECT [t0].[City] + [t0].[Country] AS [value], [t0].[CustomerID], [t0].[ContactName]
    FROM [dbo].[Customers] AS [t0]
    ) AS [t1]
CROSS JOIN [dbo].[Orders] AS [t2]
WHERE [t1].[CustomerID] = [t2].[CustomerID]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

它也应该和下面的语句等价，但其翻译的T-sql语句稍微有所不同。

            var q =
                from c in db.Customers                        
                join o in db.Orders on c.CustomerID equals o.CustomerID into ords               
                from o in ords
                let z = c.City + c.Country        
                select new { c.ContactName, o.OrderID, z };

有兴趣的朋友可以研究下，其产生的T-sql 为

SELECT [t2].[ContactName], [t2].[OrderID], [t2].[value]
FROM (
    SELECT [t0].[City] + [t0].[Country] AS [value], [t0].[CustomerID], [t0].[ContactName], [t1].[OrderID], [t1].[CustomerID] AS [CustomerID2]
    FROM [Customers] AS [t0], [Orders] AS [t1]
    ) AS [t2]
WHERE [t2].[CustomerID] = [t2].[CustomerID2]
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

第五个例子为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};

这里，它使用三个表，并且用匿名类来表示它们之间的关系。因为，其之间的关系已经不是一个键可以描述清楚的，所以只有用匿名类，表示组合键。这个例子有点像SelectMany中的ManyToMany的那个。
还有一种composite key的，就是两个表之间是用composite key表示关系的。这种情况很简单，不需像该例中使用匿名类。该例翻译的T-sql为

SELECT [t0].[OrderID], [t1].[ProductID], [t2].[UnitPrice]
FROM [dbo].[Orders] AS [t0], [dbo].[Products] AS [t1], [dbo].[Order Details] AS [t2]
WHERE ([t0].[OrderID] = [t2].[OrderID]) AND ([t1].[ProductID] = [t2].[ProductID])
-- Context: SqlProvider(Sql2005) Model: AttributedMetaModel Build: 2.0.20612.0

最后一个例子，没有看出什么好玩的来，不讲了。

写到这里，c#3.0的入门系列已经接近尾声了。我们一起学习了Dlinq的最基本操作。还剩下Union, In, Like还有一些聚合函数等操作。将会在下面几章中介绍。不知道大家对什么还感兴趣的，或者我能够提供帮助的，尽管问。
关于Linq To Sql 中的，Create, update, Delete 操作，以及Store procedure 及UDF等，更像是运用函数，而不是语言。所以，不在C#语言中讲。在考虑是不是开个什么Linq To Sql的深入应用。
写blog是对自己个人知识的总结，也是对自己表达功底的考验。因本人水平有限，错误再所难免，还请大家指出并谅解。