LINQ之路13:LINQ Operators之连接(Joining)

Joining

IEnumerable<TOuter>, IEnumerable<TInner>→IEnumerable<TResult>

Operator

说明

SQL语义

Join

应用一种查询策略来匹配两个集合中的元素,产生一个平展的结果集

INNER JOIN

GroupJoin

同上,但是产生一个层次结果集

INNER   JOIN,

LEFT   OUTER JOIN

Join & GroupJoin Arguments

参数

类型

外层/Outer sequence

IEnumerable<TOuter>

内层/Inner sequence

IEnumerable<TInner>

外键选择器/Outer key selector

TOuter => TKey

内键选择器/Inner key selector

TInner => TKey

结果选择器/Result selector

Join:      (TOuter,TInner) =>   TResult

GroupJoin    (TOuter,IEnumerable<TInner>) => TResult

查询表达式语法

                from outer-var in outer-enumerable
join inner-var in inner-enumerable on outer-key-expr equals inner-key-expr
[ into identifier ]

简介

Join和GroupJoin通过匹配两个输入sequence来产生单个输出sequence。Join产生平展结果集,而GroupJoin产生层次结果集。Join和GroupJoin提供了Select和SelectMany的替代策略。

Join和GroupJoin的优点是他们对于本地内存集合的执行更加有效,因为他们开始就把内层sequence装载到一个按键排序的查找器,这样就避免了重复的遍历每一个内层元素。他们的缺点则是他们只提供了inner和left out join的功能,而cross joins和不等连接non-equi joins还是只能通过Select/SelectMany来实现。

对于LINQ to SQL和Entity Framework查询来讲,Join和GroupJoin并没有提供相对于Select和SelectMany的任何真正优化,因为他们只是生成相应的SQL语句,而执行是在数据库引擎中完成的。

下表总结了 每种join策略的差异:

表:连接策略

策略

结果形状

本地查询效率

Inner   joins

Left   outer joins

Cross   joins

Nonequi   joins

Select + SelectMany

Flat

Bad

Yes

Yes

Yes

Yes

 

Select + Select

Nested

Bad

Yes

Yes

Yes

Yes

 

Join

Flat

Good

Yes

-

-

-

GroupJoin

Nested

Good

Yes

Yes

-

-

GroupJoin + SelectMany

Flat

Good

Yes

Yes

-

-

Join

Join运算符执行一个inner join,产生一个平展的输出sequence。示范Join的最简单方式是使用LINQ to SQL,下面的示例列出所有的Customers和他们的Purchases:

            IQueryable<string> query =
from c in dataContext.Customers
join p in dataContext.Purchases on c.ID equals p.CustomerID
select c.Name + " bought a " + p.Description;

//Result:
Tom bought a Bike
Tom bought a Holiday
Dick bought a Phone
Harry bought a Car

结果与我们使用SelectMany方式查询时是一致的。

要看到Join相对于SelectMany的优势,我们必须先把查询转为本地查询,如下所示:

 

            //把所有customers和purchases拷贝到数组,以实现本地查询
Customer[] customers = dataContext.Customers.ToArray();
Purchase[] purchases = dataContext.Purchases.ToArray();

var slowQuery = from c in customers
from p in purchases
where c.ID == p.CustomerID
select c.Name + " bought a " + p.Description;
var fastQuery = from c in customers
join p in purchases on c.ID equals p.CustomerID
select c.Name + " bought a " + p.Description;

尽管上面两个查询产生相同的结果,但是使用join的查询快得多,因为它的Enumerable实现把内层collection预先装载到一个按键排序的查找器。

join的查询语法如下:

        join inner-var in inner-sequence on outer-key-expr equals inner-key-expr

 LINQ中的Join运算符会区分对待outer sequence和inner sequence,语法上看:

  • Outer sequence是输入sequence (本例中是customers).
  • Inner sequence是我们引入的新集合 (本例中是purchases).

Join执行内连接(inner joins),意味着没有任何Purchases的Customers会被排除在结果之外。对于inner joins,我们可以交换查询的inner和outer sequences并得到相同的结果:

             var fastQuery = from p in purchases
join c in customers on p.CustomerID equals c.ID
select c.Name + " bought a " + p.Description;

我们可以在查询中继续添加join子句。比如,如果每个purchase有一个或多个purchase items,我们可以使用如下查询来join purchase items:

                from c in customers
join p in purchases on c.ID equals p.CustomerID // first join
join pi in purchaseItems on p.ID equals pi.PurchaseID // second join
...

purchases是第一个join的inner sequence和第二个join的outer sequence。我们可以通过嵌套的foreach来获得相同的结果(低性能):

            foreach (Customer c in customers)
foreach (Purchase p in purchases)
if (c.ID == p.CustomerID)
foreach (PurchaseItem pi in purchaseItems)
if (p.ID == pi.PurchaseID)
Console.WriteLine(c.Name + "," + p.Price + "," + pi.Detail);

在查询语法中,前一个join引入的变量会保持在作用域之内,就像SelectMany样式查询中的外部范围变量那样,我们还可以在join子句中间插入where和let子句。

对多个键值进行Join

我们可以使用匿名类型来对多个键值进行Join,如下所示:

                from x in sequenceX
join y in sequenceY on new { K1 = x.Prop1, K2 = x.Prop2 }
equals new { K1 = y.Prop3, K2 = y.Prop4 }
...

要使上面的查询正确执行,两个匿名类型的结构必须完全一致,这样编译器把他们对应到同一个实现类型,从而使连接键值彼此兼容。

Join的方法语法

下面的join查询语法

                from c in customers
join p in purchases on c.ID equals p.CustomerID
select new { c.Name, p.Description, p.Price };

对应的方法语法如下:

                customers.Join(         // outer collection
purchases, // inner collection
c => c.ID, // outer key selector
p => p.CustomerID, // inner key selector
(c, p) => new { c.Name, p.Description, p.Price } // result selector
);

结果选择器表达式为输出sequence创建每个element。如果我们需要在数据转换之前添加其他子句比如orderby:

                from c in customers
join p in purchases on c.ID equals p.CustomerID
orderby p.Price
select c.Name + " bought a " + p.Description;

那么在方法语法中,我们必须在结果选择器中手动构建一个临时的匿名类型,在该匿名类型中保存c和p:

                customers.Join(         // outer collection
purchases, // inner collection
c => c.ID, // outer key selector
p => p.CustomerID, // inner key selector
(c, p) => new { c, p }) // result selector
.OrderBy(x => x.p.Price)
.Select(x => x.c.Name + " bought a " + x.p.Description);

通常情况下,join的查询表达式语法更加简洁。

GroupJoin

GroupJoin和Join一样执行连接操作,但它不是返回一个平展的结果集,而是一个层次结构的结果集,使用每个外层element进行分组。除了inner joins,GroupJoin还允许outer joins。GroupJoin的查询语法也与Join相似,只是后面紧跟着into关键字。

            // Here’s the most basic example of GroupJoin:
IEnumerable<IEnumerable<Purchase>> query =
from c in customers
join p in purchases on c.ID equals p.CustomerID
into custPurchases
select custPurchases; // custPurchases is a sequence

直接出现在join子句之后的into关键字会被翻译为GroupJoin,而在select或group子句之后的into表示继续一个查询。虽然他们有一个共同的特征:都引入了一个新的查询变量,但是into关键字的这两种使用方式大不相同,必须引起注意。

其结果是一个包含了多个sequences的sequence,我们可以通过如下方式进行遍历:

            foreach (IEnumerable<Purchase> purchaseSequence in query)
foreach (Purchase p in purchaseSequence)
Console.WriteLine(p.Description);

但是这种方式不是非常有用,原因在于outer sequence并没有到outer customer的引用,所以purchaseSequence虽然是按customer进行分组的,但我们在结果中却失去了customer的相关信息。通常情况下,我们会在数据转换中添加对外部范围变量的引用:

                from c in customers
join p in purchases on c.ID equals p.CustomerID
into custPurchases
select new { CustName = c.Name, custPurchases };

这会得到和下面的Select子查询相同的结果(对于本地查询来说,Select效率不如join):

                from c in customers
select new
{
CustName = c.Name,
custPurchases = purchases.Where(p => c.ID == p.CustomerID)
};

默认情况下,GroupJoin相当于left outer join。要得到inner join(排除没有任何purchases的customers),可以对custPurchases添加过滤条件:

                from c in customers
join p in purchases on c.ID equals p.CustomerID
into custPurchases
where custPurchases.Any()
select ...

GroupJoin的into关键字之后的子句比如where针对subsequence,而不是单个的child elements。如果要对单独的purchases添加条件,必须在join之前调用Where:

                from c in customers
join p in purchases.Where(p2 => p2.Price > 1000)
on c.ID equals p.CustomerID
into custPurchases ...

平展的外连接/Flat outer joins

事情在我们希望得到一个outer join和平展的结果集时会陷入两难的境地。GroupJoin让我们获得outer join;Join给了我们平展的结果集。所以解决方案就是先调用GroupJoin,然后对每个child sequence使用DefaultIfEmpty,最后调用SelectMany来获取平展结果集:

                from c in customers
join p in purchases on c.ID equals p.CustomerID into custPurchases
from cp in custPurchases.DefaultIfEmpty()
select new
{
CustName = c.Name,
Price = cp == null ? (decimal?)null : cp.Price
};

如果custPurchases为空,DefaultIfEmpty将产生一个null值。第二个from子句会被翻译成SelectMany。所以,它会平展输出所有的purchase subsequence,将他们合并到单一的输出sequence。

使用lookups

在Enumerable的实现中,Join和GroupJoin的工作分为两个步骤。首先,他们会把内层sequence装载到一个查找器,然后通过该查找器来查询外层sequence。一个查找器(lookup)是一个分组的sequence并可以通过key来直接访问。或者我们可以把它想象成一个dictionary,其中每个元素是一个sequence和对应的key。

查找器是只读的并通过如下接口定义:

        public interface ILookup<TKey, TElement> :
IEnumerable<IGrouping<TKey, TElement>>, IEnumerable
{
int Count { get; }
bool Contains(TKey key);
IEnumerable<TElement> this[TKey key] { get; }
}

在处理本地集合时,我们甚至可以手动创建和查询lookups来作为join运算符的替代策略。这么做有如下优点:

  • 我们可以在多个查询之间重用同一个查找器(lookup)
  • 对lookup进行查询可以让我们更好的理解Join和GroupJoin的工作方式

ToLookup扩展方法创建一个lookup,下面的代码把所有的purchases装载到一个lookup(用CustomerID作为Key):

            ILookup<int?, Purchase> purchLookup =
purchases.ToLookup(p => p.CustomerID, p => p);

第一个参数选择键值,第二个参数选择作为value值被装载到lookup中的对象。读取一个lookup就像读取一个dictionary,不同之处在于索引器返回的是一个包含多个匹配元素的sequence。下面的代码遍历所有CustomerID为1的purchases:

            foreach (Purchase p in purchLookup[1])
Console.WriteLine(p.Description);

通过使用lookup,我们可以让SelectMany/Select查询运行得像Join/GroupJoin查询一样高效。Join相当于在lookup上使用SelectMany:

                from c in customers
from p in purchLookup[c.ID]
select new { c.Name, p.Description, p.Price };

通过添加DefaultIfEmpty可以让上面的查询变成一个outer join:

                from c in customers
from p in purchLookup[c.ID].DefaultIfEmpty()
select new
{
c.Name,
Descript = p == null ? null : p.Description,
Price = p == null ? (decimal?)null : p.Price
};

GroupJoin等价于在数据转换时读取lookup:

                from c in customers
select new
{
CustName = c.Name,
CustPurchases = purchLookup[c.ID]
};

Enumerable实现

通过前面的介绍,现在我们可以来看看Join和GroupJoin在LINQ中的实现了。

下面是Enumerable.Join实现的简化版本(没有null checking):

        public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(
this IEnumerable<TOuter> outer,
IEnumerable<TInner> inner,
Func<TOuter, TKey> outerKeySelector,
Func<TInner, TKey> innerKeySelector,
Func<TOuter, TInner, TResult> resultSelector)
{
ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector);
return from outerItem in outer
from innerItem in lookup[outerKeySelector(outerItem)]
select resultSelector(outerItem, innerItem);
}

GroupJoin的实现与Join类似:

        public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(
this IEnumerable<TOuter> outer,
IEnumerable<TInner> inner,
Func<TOuter, TKey> outerKeySelector,
Func<TInner, TKey> innerKeySelector,
Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
{
ILookup<TKey, TInner> lookup = inner.ToLookup(innerKeySelector);
return from outerItem in outer
select resultSelector(outerItem, lookup[outerKeySelector(outerItem)]);
}

 

posted @ 2011-11-22 14:58  Life a Poem  阅读(7399)  评论(9编辑  收藏  举报