精华内容
下载资源
问答
  • 多表联查(多表连接)(join

    万次阅读 多人点赞 2018-03-12 17:43:47
    多表联查(多表连接)(join)1、 分类内连接、自然连接、外链接(左外连接、右外连接、全外连接(mysql不支持))2、 内连接 inner join(等值连接,制定对应的等值条件)SELECT * FROM emp,dept;/*得到的数据是...

    多表联查(多表连接)(join

    1、 分类

    内连接、自然连接、外链接(左外连接、右外连接、全外连接(mysql不支持))

    2、 内连接 inner join(等值连接,制定对应的等值条件)

    SELECT * FROM emp,dept;/*得到的数据是不对的*/

    得到的数据叫做笛卡尔积:结果是两个表数据的乘积

    使用内连接去查

    SELECT * FROM emp INNER JOIN dept;

    结果依然是笛卡尔积,是因为我们没有制定对应的等值条件

    SELECT * FROM emp e INNER JOIN dept d WHERE e.deptno = d.deptno;

    /*emp.deptnodept.deptno这样的写法叫做:完全限定名

    两个表中有相同的字段,类似于A村有个老张家,孩子叫张三

    B村也有一个老张家,孩子也叫张三,

    如果没有用到多表联查,就没有必要使用完全限定名,类似于

    A村老张家的爸爸说,张三,吃饭了,指的是自己的孩子

    用到了夺标联查,两家在一起,A村的老张家的爸爸说:张三,吃饭了

    这个张三指的是谁?(不一定)

    */

    提示:一般来讲,我们不使用内连接,因为效率低。用外链接

    标准写法:select * from 1 别名1 inner join 2 别名2 where 别名1.xxx = 别名2.xxx;

    SELECT * FROM emp e INNER JOIN dept d WHERE e.deptno = d.deptno;

     

    方言写法:select * from 1 别名1,表2别名2 where别名1.xxx = 别名2.xxx;

    SELECT * FROM emp e,dept d WHERE e.deptno = d.deptno;

     

    3、 自然连接 natural(不需要指定等值条件)

    select * from 1 别名1 natural join 2 别名2

    4、 外链接(难点)

    左外:select * from 1 别名1 left [ outer ] join 2 别名2 on 等值条件;

    SELECT * FROM emp e LEFT OUTER JOIN dept d ON e.deptno = d.deptno;

    左外的意思是:左表的记录无论是否满足条件,都会被查出来,而右表的记录只有满足条件的,才会被查出来。(左表中数据在右表中如果不存在,则右表的字段值为null

    理解左外右外:

    先看两个表数据:

     

     

    /*左外*/

    SELECT * FROM table1 t1 LEFT JOIN table2 t2 ON t1.id = t2.id;

     

    左外连接是以左边的表为基准。通俗的讲,先把左表的数据全都显示出来,然后右边的表id与左边表的id的值是一样的,就拼接上去,比如说上面的id=1的数据,就拼接了。

    如果没有匹配的,比如说id=2的数据,右边没有,用null拼接。

     

    /*右外 */

    SELECT * FROM table1 t1 RIGHT JOIN table2 t2 ON t1.id = t2.id;

     

    右外跟左外的机制刚好相反。

    如何去判断主副表?(左外连接:左边的是主表,右外连接:右边的是主表)

    跟讲过的内连接做个简单的比较

    SELECT * FROM table1 t1,table2 t2 WHERE t1.id = t2.id;

     

    区别:内连接显示的是满足等值条件的记录,而外链接主表的记录都显示出来。

    注意:使用多表联查,不一定要有外键。

    例题:/*查询所有工作为文员的员工姓名及部门名称*/

    SELECT e.ename,e.job,d.dname

    FROM emp e LEFT JOIN dept d ON e.deptno = d.deptno

    WHERE e.job = '文员';

     

    例题:/*查询至少有一个员工的部门信息*/


    结果很显然不对,因为40部门没人。

    分析:因为我把dept作为主表,而主表的数据都显示,所以不合适,更改如下:

     

    如下写法也可以

     

    其实可以不用外链接,也可以查询

     

     

     

    子查询

    子查询:查询中还有查询(数select的个数)

    1、 出现的位置

    A from前:作为字段存在的

     

    B where后:作为条件存在的

    /*查询出工资高于在30部门工作的所有员工的工资的员工信息*/

     

    C from后:表(极为罕见)

    展开全文
  • Join多表连接

    千次阅读 2019-04-21 22:01:38
    Join多表连接 文献种类:专题技术文献; 开发工具与关键技术:VS 作者:卢媛媛; 撰写时间:2019/04/21 先用文字来捋一下思路,数据库操作中无非就是「 增删查改 」,其中「 查」用得最多且最复杂,变化多端。查询的...

    Join多表连接

    文献种类:专题技术文献;
    开发工具与关键技术:VS
    作者:卢媛媛;
    撰写时间:2019/04/21
    

    先用文字来捋一下思路,数据库操作中无非就是「 增删查改 」,其中「 查」用得最多且最复杂,变化多端。查询的时候,我们可以只是单表查询,也可以是多表连接查询,单表查询中的学问也很大,但限于篇幅,本次主要分享多表连接查询,也就是各种各样的连接(JOIN)。

    SqL join用于根据两个或多个表中的列之间的关系,从而得到想要的数据

    看到join 我们第一想到就为联表查询,但是join 也分很多种,每一个join 都有着不同的书写方法和执行效果,那么在满足条件下可根据实际情况做出不同的选择;
    2. Join 分为几种连接呢?
    ① Inner join(内连接) 指连接结果仅包含符合连接条件的行,参与连接的两个表都应该符合连接条件。
    Inner join 的用法:inner join为等值连接,只返回两个及多个表中的联结字段相等的值。
    Select *
    from ((表1 inner join 表2 on 表1.字段号=表2.字段号)
    Inner join 表3 on 表1.字段号=表3.字段号 )
    以此类推即可
    在这里插入图片描述
    如图所示举简单的例子表A(“1 2 3 4 5 6”)与表B(“0 2 3 5 7 8”)连接使用 inner join 查询出来的数据为”2 3 5”; 在数学当中为A∩B=(2 3 5)
    Left join (左连接) 左边的表数据行全部保留,右边的表保留符合连接条件的行。
    Slect * 注释:*为通配符
    Left join( select 表1.表1ID from 表1
    Join 表2 on 表1.ID = 表2. 表1ID
    Join 表3 on 表2.ID = 表3. 表2ID)
    以此类推即可
    在这里插入图片描述
    表A(“1 2 3 4 5 6”)与表B(“0 2 3 5 7 8”) 连接使用left join 查询出来的数据为”1 4 6 ”;
     Right join (右连接)右边的表数据行全部保留,左边的表保留符合连接条件的行。与左连接相反;
     Slect * 注释:*为通配符
     right join( select 表1.表1ID from 表1
     Join 表2 on 表1.ID = 表2. 表1ID
     Join 表3 on 表2.ID = 表3. 表2ID)
     主要与左连接相反;right join 查询出来的数据为”0 7 8 ”;
     Outer join (外连接) 连接结果不仅包含了符合连接条件的行同时也包含了不符合连接条件的行,包括左外连接,右外连接,和全外连接 外连接一般情况下使用少;但也可以使用,只是用法不同结果不同使用方法:如果对C#当中的写法比较生疏那么我们可以打开SQL数据库 在编辑器中设计查询。只简单的使用两张表(一张文件表和权限表)
     在这里插入图片描述
     从图中我们可以看到这两张表毫无关联,当中的字段也并没有可以连接的但是我们可以使用外连接
     在这里插入图片描述
     右键选择下方出现已经编辑后的代码
     SELECT *FROM PW_File OUTER JOIN
      PW_Jurisdiction ON PW_File.FileTypeID = PW_Jurisdiction.UserTypeID
    在这里插入图片描述
    在文件表和权限表的字段都具备了 在数学当中为A∪B=(0 1 2 3 4 5 6 7 8);
    在这里插入图片描述
    join连接各有各的优点,根据需求使用即可;

    展开全文
  • MySQL多表连接查询Left Join,Right Join

    千次阅读 2011-08-02 14:16:52
    MySQL多表连接查询Left Join,Right Join MySQL中的连接查询 通过连接运算符可以实现查询。连接是关系数据库模型的主要特点,也是它区别于其它类型 数据库管理系统的一个标志。 在关系数据库管理系统中,...
      
    

    MySQL多表连接查询Left Join,Right Join

    MySQL中的连接查询

    通过连接运算符可以实现多个表查询。连接是关系数据库模型的主要特点,也是它区别于其它类型

    数据库管理系统的一个标志。

    在关系数据库管理系统中,表建立时各数据之间的关系不必确定,常把一个实体的所有信息存放在

    一个表中。当检索数据时,通过连接操作查询出存放在多个表中的不同实体的信息。连接操作给用户带

    来很大的灵活性,他们可以在任何时候增加新的数据类型。为不同实体创建新的表,尔后通过连接进行

    查询。

    连接可以在SELECT 语句的FROM子句或WHERE子句中建立,似是而非在FROM子句中指出连接时有助于

    将连接操作与WHERE子句中的搜索条件区分开来。所以,在Transact-SQL中推荐使用这种方法。

    SQL-92标准所定义的FROM子句的连接语法格式为:

    FROM join_table join_type join_table

    [ON (join_condition)]

    其中join_table指出参与连接操作的表名,连接可以对同一个表操作,也可以对多表操作,对同一

    个表操作的连接又称做自连接。

    join_type 指出连接类型,可分为三种:内连接、外连接和交叉连接。内连接(INNER JOIN)使用比

    较运算符进行表间某(些)列数据的比较操作,并列出这些表中与连接条件相匹配的数据行。根据所使用

    的比较方式不同,内连接又分为等值连接、自然连接和不等连接三种。

    外连接分为左外连接(LEFT OUTER JOIN或LEFT JOIN)、右外连接(RIGHT OUTER JOIN或RIGHT JOIN)

    和全外连接(FULL OUTER JOIN或FULL JOIN)三种。与内连接不同的是,外连接不只列出与连接条件相匹

    配的行,而是列出左表(左外连接时)、右表(右外连接时)或两个表(全外连接时)中所有符合搜索条件的

    数据行。

    交叉连接(CROSS JOIN)没有WHERE 子句,它返回连接表中所有数据行的笛卡尔积,其结果集合中的

    数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

    连接操作中的ON (join_condition) 子句指出连接条件,它由被连接表中的列和比较运算符、逻辑

    运算符等构成。

    无论哪种连接都不能对text、ntext和image数据类型列进行直接连接,但可以对这三种列进行间接

    连接。例如:

    SELECT p1.pub_id,p2.pub_id,p1.pr_info

    FROM pub_info AS p1 INNER JOIN pub_info AS p2

    ON DATALENGTH(p1.pr_info)=DATALENGTH(p2.pr_info)

    ­

    (一)内连接

    内连接查询操作列出与连接条件匹配的数据行,它使用比较运算符比较被连接列的列值。内连接分

    三种:

    1、等值连接:在连接条件中使用等于号(=)运算符比较被连接列的列值,其查询结果中列出被连接

    表中的所有列,包括其中的重复列。

    2、不等连接: 在连接条件使用除等于运算符以外的其它比较运算符比较被连接的列的列值。这些

    运算符包括>、>=、<=、<、!>、!<和<>。

    3、自然连接:在连接条件中使用等于(=)运算符比较被连接列的列值,但它使用选择列表指出查询

    结果集合中所包括的列,并删除连接表中的重复列。

    例,下面使用等值连接列出authors和publishers表中位于同一城市的作者和出版社:

    SELECT *

    FROM authors AS a INNER JOIN publishers AS p

    ON a.city=p.city

    ­

    又如使用自然连接,在选择列表中删除authors 和publishers 表中重复列(city和state):

    SELECT a.*,p.pub_id,p.pub_name,p.country

    FROM authors AS a INNER JOIN publishers AS p

    ON a.city=p.city

    ­

    (二)外连接

    内连接时,返回查询结果集合中的仅是符合查询条件( WHERE 搜索条件或 HAVING 条件)和连接条件

    的行。而采用外连接时,它返回到查询结果集合中的不仅包含符合连接条件的行,而且还包括左表(左外

    连接时)、右表(右外连接时)或两个边接表(全外连接)中的所有数据行。

    如下面使用左外连接将论坛内容和作者信息连接起来:

    SELECT a.*,b.* FROM luntan LEFT JOIN usertable as b

    ON a.username=b.username

    ­

    下面使用全外连接将city表中的所有作者以及user表中的所有作者,以及他们所在的城市:

    SELECT a.*,b.*

    FROM city as a FULL OUTER JOIN user as b

    ON a.username=b.username

    ­

    (三)交叉连接

    交叉连接不带WHERE 子句,它返回被连接的两个表所有数据行的笛卡尔积,返回到结果集合中的数

    据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

    例,titles表中有6类图书,而publishers表中有8家出版社,则下列交叉连接检索到的记录数将等

    于6*8=48行。

    SELECT type,pub_name

    FROM titles CROSS JOIN publishers

    ORDER BY type

             在讲MySQL的Join语法前还是先回顾一下联结的语法,呵呵,其实连我自己都忘得差不多了,那就大家一起温习吧(如果内容有错误或有疑问,国内关于 MySQL联结查询的资料十分少,相信大家在看了本文后会对MySQL联结语法有相当清晰的了解,也不会被Oracle的外联结的(“+”号)弄得糊涂了。

             在SQL标准中规划的(Join)联结大致分为下面四种:

    1. 内联结:将两个表中存在联结关系的字段符合联结关系的那些记录形成记录集的联结。

    2. 外联结:分为外左联结和外右联结。

            左联结A、B表的意思就是将表A中的全部记录和表B中联结的字段与表A的联结字段符合联结条件的那些记录形成的记录集的联结,这里注意的是最后出来的记录集会包括表A的全部记录。

    右联结A、B表的结果和左联结B、A的结果是一样的,也就是说:

    Select A.name B.name From A Left Join B On A.id=B.id

    和Select A.name B.name From B Right Join A on B.id=A.id执行后的结果是一样的。

              3.全联结:将两个表中存在联结关系的字段的所有记录取出形成记录集的联结(这个不需要记忆,只要是查询中提到了的表的字段都会取出,无论是否符合联结条件,因此意义不大)。

             4.无联结:不用解释了吧,就是没有使用联结功能呗,也有自联结的说法。

    这里我有个比较简便的记忆方法,内外联结的区别是内联结将去除所有不符合条件的记录,而外联结则保留其中部分。外左联结与外右联结的区别在于如果用 A左联结B则A中所有记录都会保留在结果中,此时B中只有符合联结条件的记录,而右联结相反,这样也就不会混淆了。其实大家回忆高等教育出版社出版的《数据库系统概论》书中讲到关系代数那章(就是将笛卡儿积和投影那章)的内容,相信不难理解这些联结功能的内涵。

        MySQL支持Select和某些Update和Delete情况下的Join语法,具体语法上的细节有:

        table_references:

        table_reference [, table_reference] …

        table_reference:

        table_factor

        | join_table

        table_factor:

        tbl_name [[AS] alias]

        [{USE|IGNORE|FORCE} INDEX (key_list)]

        | ( table_references )

        | { OJ table_reference LEFT OUTER JOIN table_reference

        ON conditional_expr }

        join_table:

        table_reference [INNER | CROSS] JOIN table_factor [join_condition]

        | table_reference STRAIGHT_JOIN table_factor

        | table_reference STRAIGHT_JOIN table_factor ON condition

        | table_reference LEFT [OUTER] JOIN table_reference join_condition

        | table_reference NATURAL [LEFT [OUTER]] JOIN table_factor

        | table_reference RIGHT [OUTER] JOIN table_reference join_condition

        | table_reference NATURAL [RIGHT [OUTER]] JOIN table_factor

        join_condition:

        ON conditional_expr | USING (column_list)

    上面的用法摘自权威资料,不过大家看了是否有点晕呢?呵呵,应该问题主要还在于table_reference是什么,table_factor又是什么?这里的table_reference其实就是表的引用的意思,因为在MySQL看来,联结就是一种对表的引用,因此把需要联结的表定义为 table_reference,同时在SQL Standard中也是如此看待的。而table_factor则是MySQL对这个引用的功能上的增强和扩充,使得引用的表可以是括号内的一系列表,如下面例子中的JOIN后面括号:

        Select * FROM t1 LEFT JOIN (t2, t3, t4) ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c) php开源嘛

        这个语句的执行结果和下面语句其实是一样的:

        Select * FROM t1 LEFT JOIN (t2 CROSS JOIN t3 CROSS JOIN t4)

        ON (t2.a=t1.a AND t3.b=t1.b AND t4.c=t1.c)

    这两个例子不仅让我们了解了MySQL中table_factor和table_reference含义,同时能理解一点CROSS JOIN的用法,我要补充的是在MySQL现有版本中CROSS JOIN的作用和INNER JOIN是一样的(虽然在SQL Standard中是不一样的,然而在MySQL中他们的区别仅仅是INNER JOIN需要附加ON参数的语句,而CROSS JOIN不需要)。

    既然说到了ON语句,那就解释一下吧,ON语句其实和Where语句功能大致相当,只是这里的ON语句是专门针对联结表的,ON语句后面的条件的要求和书写方式和Where语句的要求是一样的,大家基本上可以把ON当作Where用。

    大家也许也看到了OJ table_reference LEFT OUTER JOIN table_reference这个句子,这不是MySQL的标准写法,只是为了和ODBC的SQL语法兼容而设定的,我很少用,Java的人更是不会用,所以也不多解释了。


    展开全文
  • Linq 多表连接查询join

    万次阅读 2018-06-06 18:07:52
    Linq 多表连接查询join在查询语言中,通常需要使用联接操作。在 LINQ 中,可以通过 join 子句实现联接操作。join 子句可以将来自不同源序列,并且在对象模型中没有直接关系(数据库之间没有关系)的元素相关联,唯一...

    Linq 多表连接查询join


    在查询语言中,通常需要使用联接操作。在 LINQ 中,可以通过 join 子句实现联接操作。join 子句可以将来自不同源序列,并且在对象模型中没有直接关系(数据库表之间没有关系)的元素相关联,唯一的要求是每个源中的元素需要共享某个可以进行比较,以判断是否相等的值。

    在 LINQ 中,join 句可以实现 种类型的分别是内部联接、接和部联接。

     

    1、内部连接(相对于sql:join | inner join)

    格式:join element in dataSource on exp1 equals exp2 

    复制代码
    int[] intAry1 = {5, 15, 25, 30, 33, 40};//创建整数数组 intAry1 作为数据源
    int[] intAry2 = {10, 20, 30, 50, 60, 70, 80};//创建整数数组 intAry2 作为数据源
    //查询 query1 使用 join 子句从两个数据源获取数据
    //演示内部联接的使用
    var query1 =
    from val1 in intAry1
    join val2 in intAry2 on val1%5 equals val2%15
    select new {VAL1=val1, VAL2=val2};
    复制代码

    2、分组连接

    格式: join element in dataSource on exp1 equals exp2 into grpName 

    其中,into 字表示将这些数据组并保存到 grpName 中,grpName 是保存一组数据的集合。(感觉和sql不同,sql查询的结果是平面矩形的,而linq则是平面树形的,意思是像对象的元素也是个对象)  

    复制代码
    int[] intAry1 = { 5, 15, 25, 30, 33, 40 };//创建整数数组 intAry1 作为数据源
    int[] intAry2 = { 10, 20, 30, 50, 60, 70, 80 };//创建整数数组 intAry2 作为数据源
    //查询 query1 使用 join 子句从两个数据源获取数据
    //演示分组联接的使用
    var query1 =
    from val1 in intAry1
    join val2 in intAry2 on val1 % 5 equals val2 % 15 into val2Grp
    select new { VAL1 = val1, VAL2GRP = val2Grp};
    复制代码

    3、左外部联接 (相对于sql:left join | left outer join)

    第三种联接是左外部联接,它返回第一个集合中的所有元素,无论它是否在第二个集合中有相关元素。在 LINQ 中,通过对分组联接的结果调用 DefaultIfEmpty()方法来执行左外部联接。DefaultIfEmpty()方法从列表中获取指定元素。如果列表为空,则返回默认值。

    复制代码
    int[] intAry1 = { 5, 15, 23, 30, 33, 40 };//创建整数数组 intAry1 作为数据源
    int[] intAry2 = { 10, 20, 30, 50, 60, 70, 80 };//创建整数数组 intAry2 作为数据源
    //查询 query1 使用 join 子句从两个数据源获取数据
    //演示左联接的使用
    var query1 =
    from val1 in intAry1
    join val2 in intAry2 on val1 % 5 equals val2 % 15 into val2Grp
    from grp in val2Grp.DefaultIfEmpty()
    select new { VAL1 = val1, VAL2GRP = grp };
    复制代码

    查询方法Lambda示例(GroupJoin):

    原形:https://msdn.microsoft.com/zh-cn/library/bb534297(v=vs.105).aspx

    复制代码
    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
    )
    复制代码

    重载

    复制代码
    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,
        IEqualityComparer<TKey> comparer
    )
    复制代码

     

    复制代码
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace LinqDemo2
    {
        /// <summary>
        /// 学生实体
        /// </summary>
        public class Student
        {
            public int StudentId { get; set; }
            public string StudentName { get; set; }
            public int StandardId { get; set; }//水平
        }
    
        /// <summary>
        /// 水平/等级
        /// </summary>
        public class Standard
        {
            public int StandardId { get; set; }
            public string StandardName { get; set; }//
        }
        class Program
        {
            static void Main(string[] args)
            {
                #region 数据源
                IList<Student> studentList = new List<Student>()
                {
                    new Student() {StudentId = 1, StudentName = "John", StandardId = 1},
                    new Student() {StudentId = 2, StudentName = "Moin", StandardId = 1},
                    new Student() {StudentId = 3, StudentName = "Bill", StandardId = 2},
                    new Student() {StudentId = 4, StudentName = "Ram", StandardId = 2},
                    new Student() {StudentId = 5, StudentName = "Ron"}
                };
                IList<Standard> standardList = new List<Standard>()
                {
                    new Standard() {StandardId = 1, StandardName = "优秀"},
                    new Standard() {StandardId = 2, StandardName = "中等"},
                    new Standard() {StandardId = 3, StandardName = "差生"}
                };
                #endregion
    
                //查询公式
                var groupJoin = standardList.GroupJoin(studentList,
                    standard => standard.StandardId,
                    student => student.StandardId,
                    (standard, studentGroup) => new
                    {
                        StandarFullName = standard.StandardName,
                        Students = studentGroup
                    });//感觉和字典类型一样,一个key,对应一个velue, velue = IEnumerable<Student>
    
                //执行查询
                foreach (var item in groupJoin)
                {
                    Console.WriteLine(item.StandarFullName);
    
                    foreach (var student in item.Students)
                    {
                        Console.WriteLine(student.StudentName);
                    }
                }
    
                /* 输出:
                 * 
                优秀
                John
                Moin
                中等
                Bill
                Ram
                差生
                */
    
    
            }
        }
    }
    复制代码

    示例:分页查询

    复制代码
    var page = 1;
                var pageSize = 10;
                var query = (from user in db.Set<User>()
                             join userRole in db.Set<UserRole>() on user.Id equals userRole.UserId
                             join rolePrivilege in db.Set<RolePrivilege>() on userRole.RoleId equals rolePrivilege.RoleId
                             join priviege in db.Set<Privilege>() on rolePrivilege.PrivilegeId equals priviege.Id
                             join role in db.Set<Role>() on userRole.RoleId equals role.Id
                             where user.Id == 1 && userRole.RoleId == 1
                             orderby user.Id descending
                             select new
                             {
                                 user.Id,
                                 userRole.RoleId,
                                 user.Username,
                                 PrivilegeName = priviege.Name,
                                 RoleName = role.Name
                             }).Skip((page - 1) * pageSize).Take(pageSize);
    复制代码

    LINQ,EF联合查询join


    [csharp]  view plain  copy
    1. public object GetListAdmin()  
    2.         {  
    3.             //return db_C56.Admins  
    4.             //   .Where(a => a.Status != "D").ToList();  
    5.   
    6.             var query1 = db_C56.Admins.Join(db_C56.Area, a => a.AreaID, ar => ar.ID, (a, ar) => new  
    7.             {  
    8.                 userName = a.UserName,  
    9.                 pwd = a.Password,  
    10.                 dName = a.DisplayName,  
    11.                 areaId = a.AreaID,  
    12.                 hasNode = a.HasNode,  
    13.                 roleName = a.RoleName,  
    14.                 status = a.Status,  
    15.                 areaName = ar.Name  
    16.             });  
    17.   
    18.             var query = from a in db_C56.Admins  
    19.                         join ar in db_C56.Area  
    20.                         on a.AreaID equals ar.ID  
    21.                         where a.Status != "D"  
    22.                         select new  
    23.                         {  
    24.                             userName = a.UserName,  
    25.                             pwd = a.Password,  
    26.                             dName = a.DisplayName,  
    27.                             areaId = a.AreaID,  
    28.                             hasNode = a.HasNode,  
    29.                             roleName = a.RoleName,  
    30.                             status = a.Status,  
    31.                             areaName = ar.Name  
    32.                         };  
    33.             return query.ToList().Select(C => new Admin  
    34.             {  
    35.                 UserName = C.userName,  
    36.                 Password = C.pwd,  
    37.                 DisplayName = C.dName,  
    38.                 AreaID = C.areaId,  
    39.                 AreaPath = C.areaName,  
    40.                 HasNode = C.hasNode,  
    41.                 RoleName = C.roleName,  
    42.                 Status = C.status,  
    43.             });  
    44.         }  


    [html]  view plain  copy
    1. from v in Pdt_Versions  
    2. join t in Tb_TypeDics   
    3. on v.TypeName equals t.TypeName into ignored  
    4. from i in ignored.DefaultIfEmpty()  
    5. where v.Status != "D"  
    6. select new   
    7. {  
    8. ID = v.ID,  
    9. VersionName = v.VersionName,  
    10. VersionCode = v.VersionCode,  
    11. DownloadName = v.DownloadName,  
    12. DownloadURL = v.DownloadURL,  
    13. VType = v.VType,  
    14. TypeName = v.TypeName,  
    15. DisplyTypeName = i.DisplyTypeName,  
    16. }  


    Linq 多层嵌套查询


    [csharp]  view plain  copy
    1. var query1 = from p in dbContent.PostService  
    2.              where p.post_type == "product" &&  
    3.                  (from ot1 in dbContent.OrderItemmetaService  
    4.                   where  
    5.                       (from ot2 in dbContent.OrderItemsService  
    6.                        where ot2.order_item_type == "line_item" &&  
    7.                            (from p1 in dbContent.PostService  
    8.                             where p1.post_type == "shop_order" && p1.post_author == userid && p1.post_status == "wc-completed"  
    9.                             select p1.ID).Contains(ot2.order_id)  
    10.                        select ot2.order_item_id).Contains(ot1.meta_id)  
    11.                   select ot1.meta_value).Contains(p.ID)  
    12.              select new  
    13.              {  
    14.                  id = p.ID,  
    15.                  name = p.post_title  
    16.              };  
    17.   
    18. var query2 = dbContent.PostService.Where(p =>  
    19.     p.post_type == "product" &&  
    20.     (dbContent.OrderItemmetaService.Where(ot1 =>  
    21.         (dbContent.OrderItemsService.Where(ot2 =>  
    22.             ot2.order_item_type == "line_item" && (dbContent.PostService.Where(p1 =>  
    23.                 p1.post_type == "shop_order" && p1.post_author == userid && p1.post_status == "wc-completed").Select(p1 => p1.ID).Contains(ot2.order_item_id))  
    24.                 ).Select(ot2 => ot2.order_item_id).Contains(ot1.meta_id))  
    25.                 ).Select(ot1 => ot1.meta_value).Contains(p.ID))  
    26.                 ).Select(p => new  
    27.                 {  
    28.                     id = p.ID,  
    29.                     name = p.post_title  
    30.                 }).ToList();  


    Left Join 查询


    from d in Doctors
    join c in (
    (from t in Commentaries where t.State != 'D' group t by new { t.DoctorID } into g 
    select new {
    DoctorID = (Int64?)g.Key.DoctorID,
    Total = (Int32?)g.Sum(p => p.Rating),
    Evaluate = (System.Double?)g.Average(p => p.Rating)
    })) on new { UserID = d.UserID } equals new { UserID = (Int64)c.DoctorID }into a_join
    from p in a_join.DefaultIfEmpty()

    select new {
      d.ID,
      UserID = (Int64?)d.UserID,
      d.Name,
      Evaluate = ((int?)p.Evaluate ?? (int?)0)
    }


    Lambda表达式


    Doctors
       .GroupJoin (
          Commentaries
             .Where (t => ((Int32)(t.State) != 68))
             .GroupBy (
                t => 
                   new  
                   {
                      DoctorID = t.DoctorID
                   }
             )
             .Select (
                g => 
                   new  
                   {
                      DoctorID = (Int64?)(g.Key.DoctorID), 
                      Total = (Int32?)(g.Sum (p => p.Rating)), 
                      Evaluate = (Double?)(g.Average (p => p.Rating))
                   }
             ), 
          d => 
             new  
             {
                UserID = d.UserID
             }, 
          c => 
             new  
             {
                UserID = (Int64)(c.DoctorID)
             }, 
          (d, a_join) => 
             new  
             {
                d = d, 
                a_join = a_join
             }
       )
       .SelectMany (
          temp0 => temp0.a_join.DefaultIfEmpty (), 
          (temp0, p) => 
             new  
             {
                ID = temp0.d.ID, 
                UserID = (Int64?)(temp0.d.UserID), 
                Name = temp0.d.Name, 
                Evaluate = ((Int32?)(p.Evaluate) ?? (Int32?)0)
             }
       )

    ======================================================================

    多个left join


    from d in Doctors
    join f in Functions on new { FunctionID = d.FunctionID } equals new { FunctionID = f.ID } into b_join
    from f in b_join.DefaultIfEmpty()
    join c in (
    (from t in Commentaries where t.State != 'D' group t by new {t.DoctorID } into g
    select new {
     DoctorID = (Int64?)g.Key.DoctorID,
     Total = (Int32?)g.Sum(p => p.Rating),
     Evaluate = (System.Double?)g.Average(p => p.Rating)
    })) on new { UserID = d.UserID } equals new { UserID = (Int64)c.DoctorID } into a_join
    from c in a_join.DefaultIfEmpty()
    select new {
      d.ID,
      UserID = (Int64?)d.UserID,
      d.AvatarPic,
      d.Name,
      f.Title,
      f.ContentDescribe,
      Evaluate = ((int?)c.Evaluate ?? (int?)0)
    }


    Lambda表达式


    Doctors
       .GroupJoin (
          Functions, 
          d => 
             new  
             {
                FunctionID = d.FunctionID
             }, 
          f => 
             new  
             {
                FunctionID = f.ID
             }, 
          (d, b_join) => 
             new  
             {
                d = d, 
                b_join = b_join
             }
       )
       .SelectMany (
          temp0 => temp0.b_join.DefaultIfEmpty (), 
          (temp0, f) => 
             new  
             {
                temp0 = temp0, 
                f = f
             }
       )
       .GroupJoin (
          Commentaries
             .Where (t => ((Int32)(t.State) != 68))
             .GroupBy (
                t => 
                   new  
                   {
                      DoctorID = t.DoctorID
                   }
             )
             .Select (
                g => 
                   new  
                   {
                      DoctorID = (Int64?)(g.Key.DoctorID), 
                      Total = (Int32?)(g.Sum (p => p.Rating)), 
                      Evaluate = (Double?)(g.Average (p => p.Rating))
                   }
             ), 
          temp1 => 
             new  
             {
                UserID = temp1.temp0.d.UserID
             }, 
          c => 
             new  
             {
                UserID = (Int64)(c.DoctorID)
             }, 
          (temp1, a_join) => 
             new  
             {
                temp1 = temp1, 
                a_join = a_join
             }
       )
       .SelectMany (
          temp2 => temp2.a_join.DefaultIfEmpty (), 
          (temp2, c) => 
             new  
             {
                ID = temp2.temp1.temp0.d.ID, 
                UserID = (Int64?)(temp2.temp1.temp0.d.UserID), 
                AvatarPic = temp2.temp1.temp0.d.AvatarPic, 
                Name = temp2.temp1.temp0.d.Name, 
                Title = temp2.temp1.f.Title, 
                ContentDescribe = temp2.temp1.f.ContentDescribe, 
                Evaluate = ((Int32?)(c.Evaluate) ?? (Int32?)0)
             }
       )


    展开全文
  • sql多表连接查询inner join, left join , right join ,full join ,cross join inner join,full outer join,left join,right jion内部连接 inner join都满足的组合full outer 全连 两相同的组合在一起,A有...
  • sql多表连接查询inner join, left join , right join ,full join ,cross joininner join内部连接都满足的组合full outer 全连 两相同的组合在一起,A有但B没有的数据(显示null), 同样B有,A没有的...
  • MySQL JOIN 多表连接

    万次阅读 2016-09-06 20:27:57
    ySQL JOIN 多表连接 除了常用的两个表连接之外,SQL(MySQL) JOIN 语法还支持多表连接多表连接基本语法如下: ... FROM table1 INNER|LEFT|RIGHT JOIN table2 ON condition INNER|LEFT|RIGHT JOIN table3 ON ...
  • 连接(inner join)与外连接(outer join)小结

    万次阅读 多人点赞 2017-10-14 15:42:05
    1. 内连接首先说明内连接的一个重要性质:内连接查询结果与的顺序无关 (当然顺序可能会发生变化,但是对应关系绝对不会错乱!!!)1.1 交叉连接(cross join)当然,他还有其他的名字,比如:笛卡尔积,交叉积...
  • 连接LEFT JOIN

    万次阅读 2018-12-14 11:35:49
    连接(LEFT JOIN) ,在此记录一下。 SELECT ts.shift_id, ts.line_id, ts.tour_guide_id, ts.hotel_id, shift_name, tourist_standard, quote, car_type, start_date, return_date, tl.line_name, tg....
  • PHP完成MySQL多表连接查询-- JOIN

    千次阅读 2019-06-08 10:09:42
    可以在 SELECT, UPDATE 和 DELETE 语句中使用 Mysql 的 JOIN 来联合多表查询。 JOIN 按照功能大致分为如下三类: 1、INNER JOIN(内连接,或等值连接):获取两个中字段匹配关系的记录。 2、LEFT JOIN(左连接):...
  • MySQL多表连接查询Left Join,Right Join MySQL中的连接查询 通过连接运算符可以实现查询。连接是关系数据库模型的主要特点,也是它区别于其它类型 数据库管理系统的一个标志。 在关系数据库管理系统中,...
  • 使用Queryable.Join实现多表连接查询

    千次阅读 2016-01-08 19:11:31
    今天处理一个问题时,遇到EF Model中多表连接查询的情况,于是学习了一下Queryable.Join()的用法。由于本人是Linq新手,很地方都看不懂,只能依葫芦画瓢。 业务说明 1) 一个EF Model名为Daks,对应的DbContext名...
  • 多表连接(inner join on用法)

    千次阅读 2009-12-03 17:28:00
    连接两个数据的用法: FROM Member INNER JOIN MemberSort ON Member.MemberSort=MemberSort.MemberSort 语法格式可以概括为: FROM 1 INNER JOIN 2 ON 1.字段号=2.字段号 连接三个数据的用法: FROM ...
  • (四)sql多表连接查询join on的用法

    万次阅读 2019-08-04 18:45:53
    (四)sql多表连接查询join on的用法
  • LEFT JOINJOIN 多表连接

    万次阅读 2016-06-22 15:37:41
    四张表contract 、customer、customer3、customer4: 这是比较熟悉的3张表的连接 SELECT * FROM test.contract a JOIN test.customer b ON a.Num = b.Num2 ...连接不一定join后面都是和第一张表的连接
  • Linq多表左外连接left join查询

    千次阅读 2020-12-14 16:38:22
    今天的一个项目中,需要将classlist与其他3张表进行连接查询,且classlist中某列为空的数据也需要查询出来,这就需要进行LEFT JOIN(左外连接查询),且项目使用的是Entity Framework框架,因此,可以使用Linq...
  • 使用inner join实现多表连接查询

    千次阅读 2010-03-15 12:02:00
    查询四张表aspnet_Membership,aspnet_Users,Users,UserRoles...1.不是用inner join表连接查询declare @username nvarchar(100)declare @userpwd nvarchar(100)set @username=adminset @userpwd=passwordSELECT *
  • 表连接JOIN,USING子句的使用

    万次阅读 2014-05-13 13:43:38
    表连接分为:CROSS JOIN、INNERT JOIN、OUTER JOIN、SELF JOIN。一、CROSS JOIN 交叉连接 CROSS JOIN连接用于生成两张的笛卡尔集。 1、返回的记录数为两个的记录数乘积。比如,A有n条记录,B有m条记录,...
  • sqlite 多表查询,连接 join

    万次阅读 2017-08-14 17:33:59
    多表查询方法: 网上有篇文章介绍了这么一种方法: //不建议 select table1.abc from table1,table2 where table1.xxx=table2.xxx;1212 实测了一下,这种方法的复杂度是join关键字的几何级倍数,用join的关键...
  • INNER JOIN多表连接

    千次阅读 2017-08-22 13:46:14
    inner join(等值连接) 只返回两个中联结字段相等的行  left join(左联接) 返回包括左中的所有记录和右中联结字段相等的记录  right join(右联接) 返回包括右中的所有记录和左中联结字段相等的记录 ...
  • MySQL JOIN 多表连接(四)

    千次阅读 2012-07-26 15:28:02
    MySQL JOIN 多表连接 除了常用的两个表连接之外,SQL(MySQL) JOIN 语法还支持多表连接多表连接基本语法如下: ... FROM table1 INNER|LEFT|RIGHT JOIN table2 ON condition INNER|LEFT|RIGHT JOIN table3 ON ...
  • SQL表连接查询(inner join、full join、left join、right join) SQL表连接查询(inner join、full join、left join、right join)   前提条件:假设有两个,一个是学生,一个是学生成绩。  ...
  • 使用left join实现多表联查

    万次阅读 2019-03-20 09:30:18
    返回包括左中的所有的记录和右表连接字段相等的记录 select * from A left join B on A.id = B.id 因为left join是以左为主,所以只要左有数据,不管右有没有数据 (如果右没有数据则为null),查询...
  • ABAP INNER JOIN 连接多表查询

    千次阅读 2018-10-25 17:15:32
    两个连接查询操作就不介绍了,当需要连接三个或三个以上时应该如何连接呢?如下所示,以此类推。 SELECT * FROM (1 INNER JOIN 2 ON 1~字段号=2~字段号) INNER JOIN 3 ON 1~字段号=3~字段号 ...
  • 多表连接实操练习: 数据准备: 1,创建emp和dept,并向其中导入如下的数据: create database db_select; use db_select; create table if not exists dept( deptno int, dname string, loc int ) row ...
  • MapReduce表连接之半连接SemiJoin

    千次阅读 2015-01-22 11:55:23
    一般称为半连接,其原理是在Map端过滤掉一些不需要join的数据,从而大大减少了reduce和Shuffle的时间,因为我们知道,如果仅仅使用Reduce端连接,那么如果一份数据,存在大量的无效数据,而这些数据在join中并不需要...
  • EF表连接查询 include join 方法介绍

    千次阅读 2015-04-27 16:30:33
    在EF中表连接常用的有Join()和Include(),两者都可以实现两张连接,但又有所不同。 例如有个唱片Album(AlbumId,Name,CreateDate,GenreId),中含外键GenreId连接流派Genre(GenreId,Name)。每个唱片归属...
  • 目录 背景 使用的景场 代码及演示 ...在数据库里面,因为某些存在外键的关联,比如一个人住了某个房子,这个房子里面还有很信息,这个时候。 如果要查询,某个这个人的信息,以及他所居...
  • 数据库SQL语句~四表连接(left join

    千次阅读 2019-06-01 15:20:47
    LEFT JOIN 关键字会从左 (table_name1) 那里返回所有的行,即使在右 (table_name2) 中没有匹配的行。 SELECT column_name(s) FROM table_name1 LEFT JOIN table_name2 ON table_name1.column_name=table_name...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 420,093
精华内容 168,037
关键字:

多表连接必须使用join