C#3.0入门系列(十)-之Join操作

转载 2007年09月28日 17:33:00

 本节讲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] = @p0AND ([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] = @p0AND ([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是对自己个人知识的总结,也是对自己表达功底的考验。因本人水平有限,错误再所难免,还请大家指出并谅解。

相关文章推荐

C#3.0 之 自动属性 对象初始化器,集合初始器,扩展方法

批注:1)自动属性:可以减少自定义属性的代码量,但是不能在get/set容器中,进行内部的处理,使得属性对外部和对内部必须一致。如下无法使用自动属性:///使用 Pers...

C#3.0新特性(三)- 详说自动属性和匿名类型

一、自动实现的属性   全称应该叫自动实现的属性(Auto-implemented properties),在上一篇中,给了简单的例子,说的是当属性访问器中不需要其他逻辑时,自动实现的属性可使属性声明...

C#3.0自学入门手册

  • 2009-12-21 14:54
  • 2.26MB
  • 下载

C#3.0入门[只写3.0特点]

  • 2009-07-28 12:35
  • 1.99MB
  • 下载

LINQ&EF任我行(一)--C#3.0与LinQ

LinQ家族五大成员: LinQ to Objects - 默认功能,用来实现对内存中集合对象的查询 LinQ to SQL - 针对SQL Server的查询,它是一个带有可视化的操作界面的ORM工...

c#3.0新特性使用lambda表达式创建表达式树

c#3.0新特性使用lambda表达式创建表达式树2009年8月18日 云飞扬 发表评论 阅读评论 -c#3.0新特性使用lambda表达式创建表达式树题外话:这空间访问速度真慢,在我发布文章的时候,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)