LINQ to SQL Count/Sum/Min/Max/Avg Join

Posted dotNet疯狂之路

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LINQ to SQL Count/Sum/Min/Max/Avg Join相关的知识,希望对你有一定的参考价值。

 

public class Linq
{
MXSICEDataContext Db = new MXSICEDataContext();

// LINQ to SQL
// Count/Sum/Min/Max/Avg


// Count

public void Count()
{
// 说明:返回集合中的元素个数,返回 INT 类型;不延迟。生成 SQL 语句为: SELECT COUNT(*) FROM

//简单形式 性能差

var count = Db.MXSMemeber.Count();

//带条件形式

var count1 = Db.MXSMemeber.Count(a => bool.Parse(a.UID));

// LongCount
//说明 :返回集合中的元素个数,返回 LONG 类型;不延迟。对于元素个数较多的集合可 视
//情况可以选用 LongCount 来统计元素个数,它返回 long 类型,比较精确。生成 SQL 语句为:
//SELECT COUNT_BIG(*) FROM

var longcount = Db.MXSMemeber.LongCount();

 


}

//SUM
public void SUM()
{
///同样来个简单形式
///
var sum = Db.MXSMemeber.Select(a => a.Sex).Sum();

///映射形式
///
var sum1 = Db.MXSMemeber.Sum(a => decimal.Parse(a.UID));


}


///Min
public void Min()
{
// 说明:返回集合中元素的最小值;不延迟。 生成 SQL 语句为: SELECT MIN(?) FROM
//简单形式
var min = Db.MXSMemeber.Select(a => a.UID).Min();

//映射形式


var min1 = Db.MXSMemeber.Min(a => a.UID);

}

///Max
public void Max()
{
// 说明:返回集合中元素的最大值;不延迟。生成 SQL 语句为: SELECT MAX(?) FROM
//简单形式
var max = Db.MXSMemeber.Select(a => a.UID).Max();

//映射形式:

var max1 = Db.MXSMemeber.Max(a => a.UID);
}

//Average

public void Average()
{

// 说明:返回集合中的数值类型元素的平均值。集合应为数字类型集合,其返回 值类型为
//double;不延迟。生成 SQL 语句为: SELECT AVG(?) FROM
//简单形式
var Average = Db.MXSMemeber.Select(a => decimal.Parse(a.UID)).Average();

//映射形式
var Average1 = Db.MXSMemeber.Average(a => decimal.Parse( a.UID));

}


//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

}; 

}



























































以上是关于LINQ to SQL Count/Sum/Min/Max/Avg Join的主要内容,如果未能解决你的问题,请参考以下文章

Linq-to-SQL 数据检索速度比较

Linq-to-SQL 和 DateTime 的怪异

如何改进 Linq-To-Sql 代码

Linq-to-SQL 数据库文件为空

Linq学习随笔三------LINQ to SQL

Linq to SQL 还是 Linq to DataSet?