查看: 20143|回复: 6
select子查询和left join+group by使用的一些看法
求职 : 论坛徽章:5
本帖最后由 刘元俊 于
13:39 编辑
& &拿我们最常用的scott用户下的emp表
create table SCOTT.EMP
&&EMPNO& & NUMBER(4) not null,
&&ENAME& & VARCHAR2(10),
&&JOB& && &VARCHAR2(9),
&&MGR& && &NUMBER(4),
&&HIREDATE DATE,
&&SAL& && &NUMBER(7,2),
&&COMM& &&&NUMBER(7,2),
&&DEPTNO& &NUMBER(2)
create table SCOTT.DEPT
&&DEPTNO NUMBER(2) not null,
&&DNAME&&VARCHAR2(14),
&&LOC& & VARCHAR2(13)
来举个例子，现在有个需求：查询每个部门有多少人，要求显示字段为 部门名称,人数。
我们有两种方式实现这个需求：
1）采用join方式
select d.dname,count(*)
from scott.emp e, scott.dept d
where e.deptno = d.deptno
group by d.
它的执行计划是：
1.jpg (28.89 KB, 下载次数: 19)
13:05 上传
2）采用子查询方式
select (select d.dname from scott.dept d where d.deptno = e.deptno) dname,
& && & count(*)
from scott.emp e
group by e.
它的执行计划是：
2 - 副本.jpg (25.31 KB, 下载次数: 18)
13:05 上传
从上面两个执行计划可以很容易看出来，方式2执行速度更快。
上面的查询中涉及到的两个表数据量很小，上面的查询要求是非常简单的，实际开发中可能会涉及两个或多个数据量很大的表，并且查询显示字段也会很多，
比如实际数据中部门表可能有部门名称，部门编码，部门简称，部门类型，部门所属上级组织等等等等。
这样一来，对于方式二就需要写很多个子查询，比如：
select (select d.dname from scott.dept d where d.deptno = e.deptno) dname,
& && && &(select d.dcode from scott.dept d where d.deptno = e.deptno) dcode,
& && && &(select d.dshortname from scott.dept d where d.deptno = e.deptno) dshortname,
& && && &……
& && & count(*)
from scott.emp e
group by e.
而方法一，可能只需要在group by后面多加几个字段即可，如下：
select d.dname,dcode, dshortname,……
& && && &count(*)
from scott.emp e, scott.dept d
where e.deptno = d.deptno
group by d.dname,dcode, dshortname,……;
相对于sql长度来说，可能方式一更简洁。
所以实际开发中，我们大都会选择方式一（即用join连接)。我之前也一直认为在select语句中使用子查询，感觉会对表进多次扫描，会影响速度。
但是在最近的测试中，经过了多次测试发现当数据量大，并且显示的字段也较多时，
使用子查询的方式在速度上明显要优于使用join后group的方式。
而且group后每多一个字段，耗时就会更长。
有以下两点建议：
一：对于可以不用left join的我们尽量不用，这样会使group by后的字段达到最小。
二：有些时候必须用left join的，比如要对表进行过滤时，可能要对表先进行关联过滤，再group by
这种情况下，不一定就是group by后的字段越少越好了。而是要对关联字段全部group by。
我做过的一次实验就是对3个表进行关联，比如A表有b_id是B表的主键，有c_id是C表的主键，
当我使用group by a.b_id,a.c_id时，发现执行计划先对a,b表进行hash join，然后group by，再和c表进行hash join，然后又一次group by；
当我使用group by a.b_id,a.c_id,b.b_id,c.c_id时 发现执行计划是对a,b表进行hash join，再和c表进行hash join，最后一起group by；
比较一下发现后一种方式更快。
由此可见，group by是一种很耗时的操作。我们在实际开发中应该尽量斟酌使用。
好久没发帖了。写的不怎么流畅，请见谅。也欢迎有不同看法的人指正。
论坛徽章:5
【当我使用group by a.b_id,a.c_id时，发现执行计划先对a,b表进行hash join，然后group by，再和c表进行hash join，然后又一次group by；
当我使用group by a.b_id,a.c_id,b.b_id,c.c_id时 发现执行计划是对a,b表进行hash join，再和c表进行hash join，最后一起group by；】
是不是可以先进行关联，通过关联条件过滤掉一部分数据，在进行分组。。。。。。。
论坛徽章:740
论坛徽章:481
标量子查询有其适用场景（结果集不大，或者条件变化不多）。“方式二就需要写很多个子查询”这有技巧可以避免，即一个SELECT返回多列，上层去解析，或者用OBJECT TYPE.
GROUP BY冗余列可以通过先汇总再连接的方法来避免。就是说emp先按部门汇总算人数，再和dept表连接。
求职 : 论坛徽章:5
newkid 发表于
标量子查询有其适用场景（结果集不大，或者条件变化不多）。“方式二就需要写很多个子查询”这有技巧可以避 ...
，嗯，学习了
求职 : 论坛徽章:5
caroline0803 发表于
【当我使用group by a.b_id,a.c_id时，发现执行计划先对a,b表进行hash join，然后group by，再和c表进行has ...
过滤条件得看用户是否用了，现在的用户你给他很多查询条件，他都不选。呵呵
论坛徽章:1
4l分析的很透彻
标量子查询有其适用场景（结果集不大，或者条件变化不多）。“方式二就需要写很多个子查询”这有技巧可以避免，即一个SELECT返回多列，上层去解析，或者用OBJECT TYPE.
GROUP BY冗余列可以通过先汇总再连接的方法来避免。就是说emp先按部门汇总算人数，再和dept表连接
itpub.net All Right Reserved. 北京盛拓优讯信息技术有限公司版权所有　　　　
　北京市公安局海淀分局网监中心备案编号：10　广播电视节目制作经营许可证：编号（京）字第1149号msyqlleftjoinon后面多个条件
即使你认为自己已对 MySQL 的 LEFT JOIN 理解深刻，但我敢打赌，这篇文章肯定能让你学会点东西！
ON 子句与 WHERE 子句的不同一种更好地理解带有 WHERE ... IS NULL 子句的复杂匹配条件的简单方法
Matching-Conditions 与 Where-conditions 的不同
关于 &A LEFT JOIN B ON 条件表达式& 的一点提醒
ON 条件（&A LEFT JOIN B ON 条件表达式&中的ON）用来决定如何从 B 表中检索数据行。
如果 B 表中没有任何一行数据匹配 ON 的条件,将会额外生成一行所有列为 NULL 的数据
在匹配阶段 WHERE 子句的条件都不会被使用。仅在匹配阶段完成以后，WHERE 子句条件才会被使用。它将从匹配阶段产生的数据中检索过滤。
让我们看一个 LFET JOIN 示例：
& CREATE TABLE `product` (
`id` int(10) unsigned NOT NULL auto_increment,
`amount` int(10) unsigned default NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1
mysql& CREATE TABLE `product_details` (
`id` int(10) unsigned NOT NULL,
`weight` int(10) unsigned default NULL,
`exist` int(10) unsigned default NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1
mysql& INSERT INTO product (id,amount)
VALUES (1,100),(2,200),(3,300),(4,400);
Query OK, 4 rows affected (0.00 sec)
Records: 4 Duplicates: 0 Warnings: 0
mysql& INSERT INTO product_details (id,weight,exist)
VALUES (2,22,0),(4,44,1),(5,55,0),(6,66,1);
Query OK, 4 rows affected (0.00 sec)
Records: 4 Duplicates: 0 Warnings: 0
mysql& SELECT * FROM
| id | amount |
| 1 | 100 |
| 2 | 200 |
| 3 | 300 |
| 4 | 400 |
4 rows in set (0.00 sec)
mysql& SELECT * FROM product_
| id | weight | exist |
| 2 | 22 | 0 |
| 4 | 44 | 1 |
| 5 | 55 | 0 |
| 6 | 66 | 1 |
4 rows in set (0.00 sec)
mysql& SELECT * FROM product LEFT JOIN product_details
ON (product.id = product_details.id);
| id | amount | id | weight | exist |
| 1 | 100 | NULL | NULL | NULL |
| 2 | 200 | 2 | 22 | 0 |
| 3 | 300 | NULL | NULL | NULL |
| 4 | 400 | 4 | 44 | 1 |
4 rows in set (0.00 sec)
ON 子句和 WHERE 子句有什么不同？
一个问题：下面两个查询的结果集有什么不同么？
1. SELECT * FROM product LEFT JOIN product_details
ON (product.id = product_details.id)
AND product_details.id=2;
2. SELECT * FROM product LEFT JOIN product_details
ON (product.id = product_details.id)
WHERE product_details.id=2;
用例子来理解最好不过了：
mysql& SELECT * FROM product LEFT JOIN product_details
ON (product.id = product_details.id)
AND product_details.id=2;
| id | amount | id | weight | exist |
| 1 | 100 | NULL | NULL | NULL |
| 2 | 200 | 2 | 22 | 0 |
| 3 | 300 | NULL | NULL | NULL |
| 4 | 400 | NULL | NULL | NULL |
4 rows in set (0.00 sec)
mysql& SELECT * FROM product LEFT JOIN product_details
ON (product.id = product_details.id)
WHERE product_details.id=2;
| id | amount | id | weight | exist |
| 2 | 200 | 2 | 22 | 0 |
1 row in set (0.01 sec)
第一条查询使用 ON 条件决定了从 LEFT JOIN的 product_details表中检索符合的所有数据行。
第二条查询做了简单的LEFT JOIN，然后使用 WHERE 子句从 LEFT JOIN的数据中过滤掉不符合条件的数据行。
再来看一些示例：
mysql& SELECT * FROM product LEFT JOIN product_details
ON product.id = product_details.id
AND product.amount=100;
| id | amount | id | weight | exist |
| 1 | 100 | NULL | NULL | NULL |
| 2 | 200 | NULL | NULL | NULL |
| 3 | 300 | NULL | NULL | NULL |
| 4 | 400 | NULL | NULL | NULL |
4 rows in set (0.00 sec)
所有来自product表的数据行都被检索到了，但没有在product_details表中匹配到记录（product.id = product_details.id AND product.amount=100 条件并没有匹配到任何数据）
mysql& SELECT * FROM product LEFT JOIN product_details
ON (product.id = product_details.id)
AND product.amount=200;
| id | amount | id | weight | exist |
| 1 | 100 | NULL | NULL | NULL |
| 2 | 200 | 2 | 22 | 0 |
| 3 | 300 | NULL | NULL | NULL |
| 4 | 400 | NULL | NULL | NULL |
4 rows in set (0.01 sec)
同样，所有来自product表的数据行都被检索到了，有一条数据匹配到了。
使用 WHERE ... IS NULL 子句的 LEFT JOIN
当你使用 WHERE ... IS NULL 子句时会发生什么呢？
如前所述，WHERE 条件查询发生在 匹配阶段之后，这意味着 WHERE ... IS NULL 子句将从匹配阶段后的数据中过滤掉不满足匹配条件的数据行。
纸面上看起来很清楚，但是当你在 ON 子句中使用多个条件时就会感到困惑了。
我总结了一种简单的方式来理解上述情况：
将 IS NULL 作为否定匹配条件使用 !(A and B) == !A OR !B 逻辑判断
看看下面的示例：
mysql& SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id AND b.weight!=44 AND b.exist=0
WHERE b.id IS NULL;
| id | amount |
| 1 | 100 |
| 3 | 300 |
| 4 | 400 |
3 rows in set (0.00 sec)
让我们检查一下 ON 匹配子句：
(a.id=b.id) AND (b.weight!=44) AND (b.exist=0)
我们可以把 IS NULL 子句 看作是否定匹配条件。
这意味着我们将检索到以下行：
!( exist(b.id that equals to a.id) AND b.weight !=44 AND b.exist=0 )
!exist(b.id that equals to a.id) || !(b.weight !=44) || !(b.exist=0)
!exist(b.id that equals to a.id) || b.weight =44 || b.exist=1
就像在C语言中的逻辑 AND 和 逻辑 OR表达式一样，其操作数是从左到右求值的。如果第一个参数做够判断操作结果，那么第二个参数便不会被计算求值（短路效果）
看看别的示例：
mysql& SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id AND b.weight!=44 AND b.exist=1
WHERE b.id IS NULL;
| id | amount |
| 1 | 100 |
| 2 | 200 |
| 3 | 300 |
| 4 | 400 |
4 rows in set (0.00 sec)
Matching-Conditions 与 Where-conditions 之战
如果你吧基本的查询条件放在 ON 子句中，把剩下的否定条件放在 WHERE 子句中，那么你会获得相同的结果。
例如，你可以不这样写：
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id AND b.weight!=44 AND b.exist=0
WHERE b.id IS NULL;
你可以这样写：
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id
WHERE b.id is null OR b.weight=44 OR b.exist=1
mysql& SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id
WHERE b.id is null OR b.weight=44 OR b.exist=1;
| id | amount |
| 1 | 100 |
| 3 | 300 |
| 4 | 400 |
3 rows in set (0.00 sec)
你可以不这样写：
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id AND b.weight!=44 AND b.exist!=0
WHERE b.id IS NULL;
可以这样写：
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id
WHERE b.id is null OR b.weight=44 OR b.exist=0;
mysql& SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id
WHERE b.id is null OR b.weight=44 OR b.exist=0;
| id | amount |
| 1 | 100 |
| 2 | 200 |
| 3 | 300 |
| 4 | 400 |
4 rows in set (0.00 sec)
这些查询真的效果一样？
如果你只需要第一个表中的数据的话，这些查询会返回相同的结果集。有一种情况就是，如果你从 LEFT JOIN的表中检索数据时，查询的结果就不同了。
如前所属，WHERE 子句是在匹配阶段之后用来过滤的。
mysql& SELECT * FROM product a LEFT JOIN product_details b
ON a.id=b.id AND b.weight!=44 AND b.exist=1
WHERE b.id is null;
| id | amount | id | weight | exist |
| 1 | 100 | NULL | NULL | NULL |
| 2 | 200 | NULL | NULL | NULL |
| 3 | 300 | NULL | NULL | NULL |
| 4 | 400 | NULL | NULL | NULL |
4 rows in set (0.00 sec)
mysql& SELECT * FROM product a LEFT JOIN product_details b
ON a.id=b.id
WHERE b.id IS NULL OR b.weight=44 OR b.exist=0;
| id | amount | id | weight | exist |
| 1 | 100 | NULL | NULL | NULL |
| 2 | 200 | 2 | 22 | 0 |
| 3 | 300 | NULL | NULL | NULL |
| 4 | 400 | 4 | 44 | 1 |
4 rows in set (0.00 sec)
如果你使用 LEFT JOIN 来寻找在一些表中不存在的记录，你需要做下面的测试：WHERE 部分的 col_name IS NULL(其中 col_name 列被定义为 NOT NULL)，MYSQL 在查询到一条匹配 LEFT JOIN 条件后将停止搜索更多行（在一个特定的组合键下）。left join :左连接，返回左表中所有的记录以及右表中连接字段相等的记录。
right join :右连接，返回右表中所有的记录以及左表中连接字段相等的记录。
inner join: 内连接，又叫等值连接，只返回两个表中连接字段相等的行。
full join:外连接，返回两个表中的行：left join + right join。
cross join:结果是笛卡尔积，就是第一个表的行数乘以第二个表的行数。
关键字:&on
数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。
在使用left&jion时，on和where条件的区别如下：
1、&on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。
2、where条件是在临时表生成好后，再对临时表进行过滤的条件。这时已经没有left&join的含义（必须返回左边表的记录）了，条件不为真的就全部过滤掉。
假设有两张表：
两条SQL:1、select&*&form&tab1&left&join&tab2&on&(tab1.size&=&tab2.size)&where&tab2.name=&AAA&2、select&*&form&tab1&left&join&tab2&on&(tab1.size&=&tab2.size&and&tab2.name=&AAA&)
第一条SQL的过程：
1、中间表on条件:tab1.size&=&tab2.size
2、再对中间表过滤where&条件：tab2.name=&AAA&
第二条SQL的过程：
1、中间表on条件:tab1.size&=&tab2.size&and&tab2.name=&AAA&(条件不为真也会返回左表中的记录)
其实以上结果的关键原因就是left&join,right&join,full&join的特殊性，不管on上的条件是否为真都会返回left或right表中的记录，full则具有left和right的特性的并集。&而inner&jion没这个特殊性，则条件放在on中和where中，返回的结果集是相同的。
阅读(...) 评论()1 .WHERE子句中使用的连接语句，在数据库语言中，被称为隐性连接。INNER JOIN&&ON子句产生的连接称为显性连接。（其他JOIN参数也是显性连接）WHERE 和INNER JOIN产生的连接关系，没有本质区别，结果也一样。但是！隐性连接随着数据库语言的规范和发展，已经逐渐被淘汰，比较新的数据库语言基本上已经抛弃了隐性连接，全部采用显性连接了。2 .无论怎么连接，都可以用join子句，但是连接同一个表的时候，注意要定义别名，否则产生错误！a&inner join：理解为&有效连接&，两张表中都有的数据才会显示left join：理解为&有左显示&，比如on a.field=b.field，则显示a表中存在的全部数据及a\\b中都有的数据，A中有、B没有的数据以null显示b&right join：理解为&有右显示&，比如on a.field=b.field，则显示B表中存在的全部数据及a\\b中都有的数据，B中有、A没有的数据以null显示c&full join：理解为&全连接&，两张表中所有数据都显示，实际就是inner +(left-inner)+(right-inner)3 .join可以分主次表外联接有三种类型：完全外联，左联，右联．完全外联包含两张表的所有记录．左联是以左边的表为主，右边的为辅，右联则相反
table a(id, type):
id&&&& type
----------------------------------
1&&&&& 1&&&&&&&&
2&&&&& 1&&&&&&&&&
3&&&&& 2&&&&&&&&&
table b(id, class):
id&&& class
---------------------------------
sql语句1：select a.*, b.* from a left join b on a.id = b.id and a.type = 1;
sql语句2：select a.*, b.* from a left join b on a.id = b.id where a.type = 1;
sql语句3：select a.*, b.* from a left join b on a.id = b.id and b.class = 1;
sql语句1的执行结果为：
a.id&&& a.type&&& b.id&&& b.class
----------------------------------------
1&&&&&&& 1&&&&&&&&&&& 1&&&&&&& 1
2&&&&&&& 1&&&&&&&&&&& 2&&&&&&& 2
3&&&&&&& 2&&&&&&&&&&&&&&
sql语句2的执行结果为：
a.id&&& a.type&&& b.id&&& b.class
----------------------------------------
1&&&&&&& 1&&&&&&&&&&& 1&&&&&&& 1
2&&&&&&& 1&&&&&&&&&&& 2&&&&&&& 2
sql语句3的执行结果为：
a.id&&& a.type&&& b.id&&& b.class
----------------------------------------
1&&&&&&& 1&&&&&&&&&&& 1&&&&&&& 1
2&&&&&&& 1&&&&&&&&&&&
3&&&&&&& 2&&&&&&&&&&&
由sql语句1可见，left join 中左表的全部记录将全部被查询显示，on 后面的条件对它不起作用，除非再后面再加上where来进行筛选，这就是sql语句2了；由sql语句3可见，on后面的条件中，右表的限制条件将会起作用。
**********************************************************************************
sql语句4：select a.*, b.* from a inner join b on a.id = b.id and a.type = 1;
sql语句5：select a.*, b.* from a inner join b on a.id = b.id where a.type = 1;
sql语句6：select a.*, b.* from a, b where a.id = b.id and a.type = 1;
sql语句7：select a.*, b.* from a, b where a.type = 1 and a.id = b.
这四条语句的执行结果一样，如下：
a.id&&& a.type&&& b.id&&& b.class
----------------------------------------
1&&&&&&& 1&&&&&&&&&&& 1&&&&&&& 1
2&&&&&&& 1&&&&&&&&&&& 2&&&&&&& 2
由此可见，inner join 中on后面的限制条件将全部起作用，这与where的执行结果是一样的。另外，where语句与inner join确实能得到相同的结果，只是效率不同（这个我没有测试过，不过我相信这个结论）。
但是sql语句6是否比sql语句7的效率要低一些，我没有足够的数据量来测试，不过我也相信是如此的。
left outer join 以左表为主，左表内容全显示，右表连接上的内容才显示
right outer join相反
full outer join 左右表未连接的内容全部显示
外联接。外联接可以是左向外联接、右向外联接或完整外部联接。
在 FROM 子句中指定外联接时，可以由下列几组关键字中的一组指定：
LEFT JOIN 或 LEFT OUTER JOIN。
左向外联接的结果集包括 LEFT OUTER 子句中指定的左表的所有行，而不仅仅是联接列所匹配的行。如果左表的某行在右表中没有匹配行，则在相关联的结果集行中右表的所有选择列表列均为空值。
RIGHT JOIN 或 RIGHT OUTER JOIN。
右向外联接是左向外联接的反向联接。将返回右表的所有行。如果右表的某行在左表中没有匹配行，则将为左表返回空值。
FULL JOIN 或 FULL OUTER JOIN。
完整外部联接返回左表和右表中的所有行。当某行在另一个表中没有匹配行时，则另一个表的选择列表列包含空值。如果表之间有匹配行，则整个结果集行包含基表的数据值。
仅当至少有一个同属于两表的行符合联接条件时，内联接才返回行。内联接消除与另一个表中的任何行不匹配的行。而外联接会返回 FROM 子句中提到的至少一个表或视图的所有行，只要这些行符合任何 WHERE 或 HAVING 搜索条件。将检索通过左向外联接引用的左表的所有行，以及通过右向外联接引用的右表的所有行。完整外部联接中两个表的所有行都将返回。
LEFT OUTER JOIN 或 LEFT JOIN
RIGHT OUTER JOIN 或 RIGHT JOIN
FULL OUTER JOIN 或 FULL JOIN
阅读(...) 评论() &40759人阅读
1.【Sql Server】（71）
帖子是原创是，但是在csdn中高手帮我给解决了，其实就是别名，给自己上了一堂别名的课，所谓别人是高手，其实就是自己是菜鸟吧！
表1：------------------------------&【人事表】
&&&&&表名：【Man】
&&&&&字段：&Man_Id,Man_Name，Zw_Id
&&&&&&&&&&&&&&1&&&&&貂蝉&&&&&&&2
&&&&&&&&&&&&&&2&&&&&曹操&&&&&&&1
表2：------------------------------&【职务表】
&&&&&表名：【Zw】
&&&&&字段：&Zw_Id,Zw_Name
&&&&&&&&&&&&&&1&&&&&校长&
&&&&&&&&&&&&&&2&&&&&班主任
表3：------------------------------&【工资表】
&&&&&表名：【GZ】
&&&&&字段：&Man_Id,Money，Sex_Id
&&&&&&&&&&&&&&1&&&&2500&&&&&1
&&&&&&&&&&&&&&2&&&&4000&&&&&2
表3：------------------------------&【性别表】
&&&&&表名：【xb】
&&&&&字段：&Sex_Id,Sex_Name
&&&&&&&&&&&&&&1&&&&女
&&&&&&&&&&&&&&2&&&&男
需要的-------------------------------&【查询结果】：
&&&&&Man_Id,Man_Name,sex_name,Zw_Name,Money
&&&&&&&1&&&&&&貂蝉&&&&&女&&&&&&班主任&&&2500
&&&&&&&2&&&&&&曹操&&&&&男&&&&&&&校长&&&&4000
方法一（推荐）：
select a.man_id,man_name,d.sex_name,zw_name,c.money
from man as a
left join zw as b on a.zw_id=b.zw_id
left join gz as c on a.man_id=c.man_id
left join xb as d on c.sex_id=d.sex_id
select Man_Id,Man_Name,sex_name,Zw_Name,Money from
a.Man_Id,Man_Name,b.Zw_Id,Zw_Name,Money,Sex_Id
[Zw] b on a.Zw_Id=b.Zw_Id
[Gz] c on a.Man_Id=c.Man_Id
left join xb m on m.Sex_Id=t.Sex_Id
select man.man_id,man.man_name,xb.sex_name,zw_name,gz.money
left join zw on man.zw_id=zw.zw_id
left join gz on man.man_id=gz.man_id
left join xb on gz.sex_id=xb.sex_id
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2641303次
积分：21497
积分：21497
排名：第358名
原创：265篇
转载：132篇
评论：160条
(3)(1)(1)(1)(5)(1)(4)(2)(5)(12)(7)(5)(4)(3)(4)(11)(5)(5)(7)(7)(20)(17)(19)(17)(3)(8)(21)(39)(32)(26)(40)(17)(6)(20)(18)(1)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'