ALinq 入门学习(六)Join 连接查询

简单介绍一下连接查询：通过连接运算符可以实现多个表查询。连接是关系数据库模型的主要特点，也是它区别于其它类型数据库管理系统的一个标志。from join_table1 join_type join_table2 on Join_condition  这个是SQL 中最简单的连接查询功能语法。在ALinq , Linq ,Entity Framework 中都有涉及到连接查询，在某种程度上的确简便了很多查询。但是个人认为，Linq to SQL ，ALinq 使用Linq 语句来连接查询数据库不是那么的方便，总感觉有些地方不是Linq 语句所能处理的。本文章出略的讲解ALinq 中连接查询数据。

1. 一对多查询

在ORM映射框架中我们听得最多的也就是什么 1 to 1， 1 to many ，many to many 等等。这代表着一种数据结构之间的关系。一对多查询也就是查询主表的时候附带查询子表中的集合信息。在很多情况下不建议采用一对多查询，因为这样是比较消耗性能的。ALinq 一对多查询例子如下:

 1 /// <summary>
 2         /// 一对多链接查询
 3         /// </summary>
 4         public void FunctionOnToMany()
 5         {
 6             OA_DBDataContext context = new OA_DBDataContext(new SqlConnection(connectionString));
 7             context.Log = Console.Out;
 8 
 9             var query = from r in context.TabRole
10                         from u in r.TabUser
11                         where r.Id == 1
12                         select u;
13 
14             foreach (var item in query)
15             {
16                 Console.WriteLine("TabRole.Id >> " + item.TabRole.Id);
17                 Console.WriteLine("TabUser.Id >> " + item.Id);
18                 Console.WriteLine("\n");
19             }
20         }

TabUser 作为TabRole 的子表，这段语句会查询出TabRole 的id==1 的所有TabUser 数据集合。也就是说我们查询一个TabRle 的对象同时还可以附带查询出TabUser 的数据集合

2.多对多查询

多对多查询一般都会涉及到三张表，一种有一张中间表，适用于连接另外两张表之间的关系的，而这两张表式没有必然联系的。此三张表成

1:N:1 的关系，其中N为中间表，负责维护1和1之间的关系。多对多关系式数据关系表中比较复杂的关系。典型的例子就是我们涉及权限操作的时候。这里不过多讲解。 

 1 /// <summary>
 2         /// 多对多查询
 3         /// </summary>
 4         public void FunctionManyToMany()
 5         {
 6             OA_DBDataContext context = new OA_DBDataContext(new SqlConnection(connectionString));
 7             context.Log = Console.Out;
 8 
 9             var query = from u in context.TabUser
10                         from r in u.TabRule
11                         where u.Id == 1
12                         select new
13                         {
14                             u.Id,
15                             u.UserName,
16                             r.TabMenu
17                         };
18             foreach (var item in query)
19             {
20                 Console.WriteLine("TabUser.ID ==> " + item.Id);
21                 Console.WriteLine("TabUser.UserName ==> " + item.UserName);
22                 Console.WriteLine("TabMenu.ID ==> " + item.TabMenu.Id);
23                 Console.WriteLine("TabMenu.MenuName ==> " + item.TabMenu.MenuName);
24                 Console.WriteLine("");
25             }
26         }

3. 自连接查询

在连接查询中有一种特殊的连接查询，也就是自连接查询。此种查询，就是自己连接自己进行连接查询。在ALinq 中，自连接查询 使用到两个同类型的对象，来比较某列值之间的查询。下来的例子是查询菜单编号(MenuID) 相同的数据。

 1 /// <summary>
 2         /// 自连接查询
 3         /// </summary>
 4         public void FunctionJionSelf()
 5         {
 6             OA_DBDataContext context = new OA_DBDataContext(new SqlConnection(connectionString));
 7             context.Log = Console.Out;
 8             var query = from r1 in context.TabRule
 9                         from r2 in context.TabRule
10                         where r1.MenuID == r2.MenuID
11                         select new
12                         {
13                             RuleID = r1.Id,
14                             MenuID = r1.MenuID
15                         };
16             foreach (var item in query)
17             {
18                 Console.WriteLine("RuleID ==> " + item.RuleID);
19                 Console.WriteLine("MenuID ==> " + item.MenuID);
20                 Console.WriteLine();
21             }
22         }
23 

4.双向连接查询

说实话写到这个例子的时候才感觉这才像连接查询语句，所谓的双向链接，只是说在查看的角度不同。1 to many 查询关系，站在对方的角度也就是 many to 1, 双向连接也就是总体上查看他们之间的关系。也就是在查询的时候，主表加载子表的集合，子表加载主表的对象。

 1 /// <summary>
 2         /// 双向连接查询
 3         /// </summary>
 4         public void FunctionJionDouble()
 5         {
 6             OA_DBDataContext context = new OA_DBDataContext(new SqlConnection(connectionString));
 7             context.Log = Console.Out;
 8             var query = from r in context.TabRole
 9                         join u in context.TabUser
10                         on r.Id equals u.RoleId into userlist
11                         select new
12                         {
13                             r.RoleName,
14                             userlist
15                         };
16             foreach (var item in query)
17             {
18                 Console.WriteLine("RoleName ==> "+item.RoleName);
19                 foreach (var user in item.userlist)
20                 {
21                     Console.WriteLine("UserName ==> "+user.UserName);
22                 }
23                 Console.WriteLine();
24             }
25         }

补充介绍连接查询:

在SQL中连接查询分为三种情况:内连接、外连接和交叉连接

1.内连接

内连接又非为三种情况:等值连接、自然连接和不等连接

等值连接:在连接条件中使用等于号(=)运算符比较被连接列的列值，其查询结果中列出被连接表中的所有列，包括其中的重复列

不等连接:在连接条件中使用 除 等于号之外的运算符比较被连接列的列值，其查询结果中列出被连接表中的所有列

自然连接:在连接条件中使用等于(=)运算符比较被连接列的列值，但它使用选择列表指出查询结果集合中所包括的列，并删除连接表中的重复列。这个与等值连接的区别就是重复列的问题。

2.外连接

外连接又分为: 左外连接，右外连接，全连接

  左外连接，右外连接：返回到查询结果集合中的不仅包含符合连接条件的行，而且还包括左表(左外连接时)、右表(右外连接时)所有数行 。

全连接: 其实就是上面的组合情况，包含两张表中的所有数据。 

3.交叉连接 

交叉连接：不带WHERE 子句，它返回被连接的两个表所有数据行的笛卡尔积，返回到结果集合中的数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数 

上面的链接查询，都只是包含了很肤浅的介绍，文章主要目的还是介绍ALinq中Join关键字的一些简单用法。数据库的链接查询还必须查看具体的SQL官方资料。在使用Linq 语句的时候，我也不太喜欢这种方式的链接查询，感觉SQL语句的连接查询比Linq 语句的连接语句来的更为直接。