Linq to SQL 語法查詢(子查詢 & in操作 & join )

子查詢

描述：查詢訂單數超過5的顧客信息

查詢句法：

var 子查詢 = from c in ctx.Customers
                   where
                       (from o in ctx.Orders group o by o.CustomerID into o where o.Count() > 5 select o.Key).Contains(c.CustomerID)
                   select c;

　　

in 操作

描述：查詢指定城市中的客戶

查詢句法：

var in操作 = from c in ctx.Customers
                    wherenewstring[] { "Brandenburg", "Cowes", "Stavern" }.Contains(c.City)
                    select c;

 

Join

描述：內連接，沒有分類的產品查詢不到

查詢句法：

var innerjoin = from p in ctx.Products
                        join c in ctx.Categories
                        on p.CategoryID equals c.CategoryID
                        select p.ProductName;

　　

描述：外連接，沒有分類的產品也能查詢到

查詢句法：

var leftjoin = from p in ctx.Products
                       join c in ctx.Categories
                       on p.CategoryID equals c.CategoryID
                       into pro
                       from x in pro.DefaultIfEmpty()
                       select p.ProductName;

　　

1.簡單形式：
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select g;
語句描述：使用Group By按CategoryID划分產品。

說明：from p in db.Products 表示從表中將產品對象取出來。group p by p.CategoryID into g表示對p按CategoryID字段歸類。其結果命名為g，一旦重新命名，p的作用域就結束了，所以，最后select時，只能select g。當然，也不必重新命名可以這樣寫：

var q =
    from p in db.Products
    group p by p.CategoryID;
我們用示意圖表示：



如果想遍歷某類別中所有記錄，這樣：

foreach (var gp in q)
{
    if (gp.Key == 2)
    {
        foreach (var item in gp)
        {
            //do something
        }
    }
}
2.Select匿名類：
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new { CategoryID = g.Key, g }; 
說明：在這句LINQ語句中，有2個property：CategoryID和g。這個匿名類，其實質是對返回結果集重新進行了包裝。把g的property封裝成一個完整的分組。如下圖所示：



如果想遍歷某匿名類中所有記錄，要這么做：

foreach (var gp in q)
{
    if (gp.CategoryID == 2)
    {
        foreach (var item in gp.g)
        {
            //do something
        }
    }
}
3.最大值
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key,
        MaxPrice = g.Max(p => p.UnitPrice)
    };
語句描述：使用Group By和Max查找每個CategoryID的最高單價。

說明：先按CategoryID歸類，判斷各個分類產品中單價最大的Products。取出CategoryID值，並把UnitPrice值賦給MaxPrice。

4.最小值
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key,
        MinPrice = g.Min(p => p.UnitPrice)
    };
語句描述：使用Group By和Min查找每個CategoryID的最低單價。

說明：先按CategoryID歸類，判斷各個分類產品中單價最小的Products。取出CategoryID值，並把UnitPrice值賦給MinPrice。

5.平均值
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key,
        AveragePrice = g.Average(p => p.UnitPrice)
    };
語句描述：使用Group By和Average得到每個CategoryID的平均單價。

說明：先按CategoryID歸類，取出CategoryID值和各個分類產品中單價的平均值。

6.求和
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key,
        TotalPrice = g.Sum(p => p.UnitPrice)
    };
語句描述：使用Group By和Sum得到每個CategoryID 的單價總計。

說明：先按CategoryID歸類，取出CategoryID值和各個分類產品中單價的總和。

7.計數
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key,
        NumProducts = g.Count()
    };
語句描述：使用Group By和Count得到每個CategoryID中產品的數量。

說明：先按CategoryID歸類，取出CategoryID值和各個分類產品的數量。

8.帶條件計數
var q =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key,
        NumProducts = g.Count(p => p.Discontinued)
    };
語句描述：使用Group By和Count得到每個CategoryID中斷貨產品的數量。

說明：先按CategoryID歸類，取出CategoryID值和各個分類產品的斷貨數量。 Count函數里，使用了Lambda表達式，Lambda表達式中的p，代表這個組里的一個元素或對象，即某一個產品。

9.Where限制
var q =
    from p in db.Products
    group p by p.CategoryID into g
    where g.Count() >= 10
    select new {
        g.Key,
        ProductCount = g.Count()
    };
語句描述：根據產品的―ID分組，查詢產品數量大於10的ID和產品數量。這個示例在Group By子句后使用Where子句查找所有至少有10種產品的類別。

說明：在翻譯成SQL語句時，在最外層嵌套了Where條件。

10.多列(Multiple Columns)
var categories =
    from p in db.Products
    group p by new
    {
        p.CategoryID,
        p.SupplierID
    }
        into g
        select new
            {
                g.Key,
                g
            };
語句描述：使用Group By按CategoryID和SupplierID將產品分組。

說明：既按產品的分類，又按供應商分類。在by后面，new出來一個匿名類。這里，Key其實質是一個類的對象，Key包含兩個Property：CategoryID、SupplierID。用g.Key.CategoryID可以遍歷CategoryID的值。

11.表達式(Expression)
var categories =
    from p in db.Products
    group p by new { Criterion = p.UnitPrice > 10 } into g
    select g;
語句描述：使用Group By返回兩個產品序列。第一個序列包含單價大於10的產品。第二個序列包含單價小於或等於10的產品。

說明：按產品單價是否大於10分類。其結果分為兩類，大於的是一類，小於及等於為另一類。

Exists/In/Any/All/Contains操作符
適用場景：用於判斷集合中元素，進一步縮小范圍。

Any
說明：用於判斷集合中是否有元素滿足某一條件；不延遲。（若條件為空，則集合只要不為空就返回True，否則為False）。有2種形式，分別為簡單形式和帶條件形式。

1.簡單形式：
僅返回沒有訂單的客戶：

var q =
    from c in db.Customers
    where !c.Orders.Any()
    select c;
生成SQL語句為：

SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName],
[t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region],
[t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax]
FROM [dbo].[Customers] AS [t0]
WHERE NOT (EXISTS(
    SELECT NULL AS [EMPTY] FROM [dbo].[Orders] AS [t1]
    WHERE [t1].[CustomerID] = [t0].[CustomerID]
   ))
2.帶條件形式：
僅返回至少有一種產品斷貨的類別：

var q =
    from c in db.Categories
    where c.Products.Any(p => p.Discontinued)
    select c;
生成SQL語句為：

SELECT [t0].[CategoryID], [t0].[CategoryName], [t0].[Description],
[t0].[Picture] FROM [dbo].[Categories] AS [t0]
WHERE EXISTS(
    SELECT NULL AS [EMPTY] FROM [dbo].[Products] AS [t1]
    WHERE ([t1].[Discontinued] = 1) AND 
    ([t1].[CategoryID] = [t0].[CategoryID])
    )
All
說明：用於判斷集合中所有元素是否都滿足某一條件；不延遲

1.帶條件形式
var q =
    from c in db.Customers
    where c.Orders.All(o => o.ShipCity == c.City)
    select c;
語句描述：這個例子返回所有訂單都運往其所在城市的客戶或未下訂單的客戶。

Contains
說明：用於判斷集合中是否包含有某一元素；不延遲。它是對兩個序列進行連接操作的。

string[] customerID_Set =
    new string[] { "AROUT", "BOLID", "FISSA" };
var q = (
    from o in db.Orders
    where customerID_Set.Contains(o.CustomerID)
    select o).ToList();
語句描述：查找"AROUT", "BOLID" 和 "FISSA" 這三個客戶的訂單。先定義了一個數組，在LINQ to SQL中使用Contains，數組中包含了所有的CustomerID，即返回結果中，所有的CustomerID都在這個集合內。也就是in。 你也可以把數組的定義放在LINQ to SQL語句里。比如：

var q = (
    from o in db.Orders
    where (
    new string[] { "AROUT", "BOLID", "FISSA" })
    .Contains(o.CustomerID)
    select o).ToList();
Not Contains則取反：

var q = (
    from o in db.Orders
    where !(
    new string[] { "AROUT", "BOLID", "FISSA" })
    .Contains(o.CustomerID)
    select o).ToList();
1.包含一個對象：
var order = (from o in db.Orders
             where o.OrderID == 10248
             select o).First();
var q = db.Customers.Where(p => p.Orders.Contains(order)).ToList();
foreach (var cust in q)
{
    foreach (var ord in cust.Orders)
    {
        //do something
    }
}
語句描述：這個例子使用Contain查找哪個客戶包含OrderID為10248的訂單。

2.包含多個值：
string[] cities = 
    new string[] { "Seattle", "London", "Vancouver", "Paris" };
var q = db.Customers.Where(p=>cities.Contains(p.City)).ToList();
語句描述：這個例子使用Contains查找其所在城市為西雅圖、倫敦、巴黎或溫哥華的客戶。

總結一下這篇我們說明了以下語句：

Group By/Having    分組數據；延遲
Any    用於判斷集合中是否有元素滿足某一條件；不延遲
All    用於判斷集合中所有元素是否都滿足某一條件；不延遲
Contains    用於判斷集合中是否包含有某一元素；不延遲






適用場景：統計數據吧，比如統計一些數據的個數，求和，最小值，最大值，平均數。

Count
說明：返回集合中的元素個數，返回INT類型；不延遲。生成SQL語句為：SELECT COUNT(*) FROM

1.簡單形式：
得到數據庫中客戶的數量：

var q = db.Customers.Count();
2.帶條件形式：
得到數據庫中未斷貨產品的數量：

var q = db.Products.Count(p => !p.Discontinued);
LongCount
說明：返回集合中的元素個數，返回LONG類型；不延遲。對於元素個數較多的集合可視情況可以選用LongCount來統計元素個數，它返回long類型，比較精確。生成SQL語句為：SELECT COUNT_BIG(*) FROM

var q = db.Customers.LongCount();
Sum
說明：返回集合中數值類型元素之和，集合應為INT類型集合；不延遲。生成SQL語句為：SELECT SUM(…) FROM

1.簡單形式：
得到所有訂單的總運費：

var q = db.Orders.Select(o => o.Freight).Sum();
2.映射形式：
得到所有產品的訂貨總數：

var q = db.Products.Sum(p => p.UnitsOnOrder);
Min
說明：返回集合中元素的最小值；不延遲。生成SQL語句為：SELECT MIN(…) FROM

1.簡單形式：
查找任意產品的最低單價：

var q = db.Products.Select(p => p.UnitPrice).Min();
2.映射形式：
查找任意訂單的最低運費：

var q = db.Orders.Min(o => o.Freight);
3.元素：
查找每個類別中單價最低的產品：

var categories =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        CategoryID = g.Key,
        CheapestProducts =
            from p2 in g
            where p2.UnitPrice == g.Min(p3 => p3.UnitPrice)
            select p2
    };
Max
說明：返回集合中元素的最大值；不延遲。生成SQL語句為：SELECT MAX(…) FROM

1.簡單形式：
查找任意雇員的最近雇用日期：

var q = db.Employees.Select(e => e.HireDate).Max();
2.映射形式：
查找任意產品的最大庫存量：

var q = db.Products.Max(p => p.UnitsInStock);
3.元素：
查找每個類別中單價最高的產品：

var categories =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key,
        MostExpensiveProducts =
            from p2 in g
            where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
            select p2
    };
Average
說明：返回集合中的數值類型元素的平均值。集合應為數字類型集合，其返回值類型為double；不延遲。生成SQL語句為：SELECT AVG(…) FROM

1.簡單形式：
得到所有訂單的平均運費：

var q = db.Orders.Select(o => o.Freight).Average();
2.映射形式：
得到所有產品的平均單價：

var q = db.Products.Average(p => p.UnitPrice);
3.元素：
查找每個類別中單價高於該類別平均單價的產品：

var categories =
    from p in db.Products
    group p by p.CategoryID into g
    select new {
        g.Key, 
        ExpensiveProducts =
            from p2 in g
            where p2.UnitPrice > g.Average(p3 => p3.UnitPrice)
            select p2
    };