精华内容
下载资源
问答
  • --创建数据库和表 CREATE DATABASE `mybatis_db`; USE `mybatis_db`; CREATE TABLE `user` ( `id` int(11) NOT NULL auto_increment, `username` varchar(32) NOT NULL COMMENT '用户名称', `birthday` datetime ...

    数据准备

    --创建数据库和表
    CREATE DATABASE `mybatis_db`;
    USE `mybatis_db`;
    CREATE TABLE `user` (
    `id` int(11) NOT NULL auto_increment,
    `username` varchar(32) NOT NULL COMMENT '用户名称',
    `birthday` datetime default NULL COMMENT '生日',
    `sex` char(1) default NULL COMMENT '性别',
    `address` varchar(256) default NULL COMMENT '地址',PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    -- insert....
    insert into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'子
    慕','2020-11-11 00:00:00','男','北京海淀'),(2,'应颠','2020-12-12 00:00:00','男','北
    京海淀');
    DROP TABLE IF EXISTS `orders`;
    CREATE TABLE `orders` (
    `id` INT(11) NOT NULL AUTO_INCREMENT,
    `ordertime` VARCHAR(255) DEFAULT NULL,
    `total` DOUBLE DEFAULT NULL,
    `uid` INT(11) DEFAULT NULL,
    PRIMARY KEY (`id`),
    KEY `uid` (`uid`),
    CONSTRAINT `orders_ibfk_1` FOREIGN KEY (`uid`) REFERENCES `user` (`id`)
    ) ENGINE=INNODB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    -- ----------------------------
    -- Records of orders
    -- ----------------------------
    INSERT INTO `orders` VALUES ('1', '2020-12-12', '3000', '1');
    INSERT INTO `orders` VALUES ('2', '2020-12-12', '4000', '1');
    INSERT INTO `orders` VALUES ('3', '2020-12-12', '5000', '2');
    -- ----------------------------
    -- Table structure for sys_role
    -- ----------------------------
    DROP TABLE IF EXISTS `sys_role`;
    CREATE TABLE `sys_role` (
    `id` INT(11) NOT NULL AUTO_INCREMENT,
    `rolename` VARCHAR(255) DEFAULT NULL,
    `roleDesc` VARCHAR(255) DEFAULT NULL,
    PRIMARY KEY (`id`)
    ) ENGINE=INNODB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
    -- ----------------------------
    -- Records of sys_role
    -- ----------------------------
    INSERT INTO `sys_role` VALUES ('1', 'CTO', 'CTO');
    INSERT INTO `sys_role` VALUES ('2', 'CEO', 'CEO');
    -- ----------------------------
    -- Table structure for sys_user_role
    -- ----------------------------
    DROP TABLE IF EXISTS `sys_user_role`;
    CREATE TABLE `sys_user_role` (
    `userid` INT(11) NOT NULL,
    `roleid` INT(11) NOT NULL,
    PRIMARY KEY (`userid`,`roleid`),
    KEY `roleid` (`roleid`),
    CONSTRAINT `sys_user_role_ibfk_1` FOREIGN KEY (`userid`) REFERENCES `sys_role`
    (`id`),
    CONSTRAINT `sys_user_role_ibfk_2` FOREIGN KEY (`roleid`) REFERENCES `user`
    (`id`)
    ) ENGINE=INNODB DEFAULT CHARSET=utf8;
    -- ----------------------------
    -- Records of sys_user_role
    -- ----------------------------
    INSERT INTO `sys_user_role` VALUES ('1', '1');
    INSERT INTO `sys_user_role` VALUES ('2', '1');
    INSERT INTO `sys_user_role` VALUES ('1', '2');
    INSERT INTO `sys_user_role` VALUES ('2', '2');
    
    //创建订单实体类
    public class Orders {
    
        private Integer id;
        private String ordertime;
        private Double total;
        private Integer uid;
        //表示当前订单属于哪个用户
        private User user;
        .
        .
        //get&set&toString
        .
        .
    }
    
    //创建用户实体类
    public class User {
    
        private Integer id;
        private String username;
        private Date birthday;
        private String sex;
        private String address;
        //一个用户有多个订单
        private List<Orders> ordersList;
        //一个用户担任多个角色
        private List<User> roleList;
    

    1.多表查询

    1.1 一对一查询

    • 一对一查询的需求:查询所有订单,与此同时查询出每个订单所属的用户

    步骤一:在对应的OrderMapper接口中创建方法

    //查询所有订单信息和订单所属的用户信息 1:1关系
    public List<Orders> findAllOrderUser();
    

    步骤二:配置OrderMapper.xml文件

    <mapper namespace="com.zhoufengbin.mapper.OrderMapper">
    
        <!--配置映射信息-->
        <resultMap id="ordersMap" type="com.zhoufengbin.domain.Orders">
            <id property="id" column="id"/>
            <result property="ordertime" column="ordertime"/>
            <result property="total" column="total"/>
            <result property="uid" column="uid"/>
            <!--
                在一对一(多对一)使用association标签关联
                property="user" 封装实体的属性名
                javaType="user" 封装实体的属性类型
            -->
            <association property="user" javaType="com.zhoufengbin.domain.User">
                <id property="id" column="uid"/>
                <result property="username" column="username"/>
                <result property="birthday" column="birthday"/>
                <result property="sex" column="sex"/>
                <result property="address" column="address"/>
            </association>
        </resultMap>
    
        <!--多表查询之一对一查询:查询所有订单,与此同时查询出每个订单所属的用户
    		由于订单表中没有用户表中的信息 ,需要进行关联查询,且还需要将查询到的所有字段封装到具体的实体类中,因此需要使用
    		resultMap和association 属性配置映射关系
    		-->
        <select id="findAllOrderUser" resultMap="ordersMap">
            SELECT * FROM orders o LEFT OUTER JOIN USER u ON o.`uid` = u.`id`;
        </select>
    </mapper>
    

    步骤三:进行单元测试

    1.2 一对多查询

    • 一对多查询的需求:查询所有用户,与此同时查询出该用户具有的订单
    public List<User> findAllWithUserOrder();
    

    步骤一:在对应的UserMapper接口中创建方法

    //查询所有用户信息和用户拥有的订单信息 1:n 
    public List<User> findAllWithUserOrder();
    

    步骤二:配置UserMapper.xml文件

    <resultMap id="userOrderMap" type="com.zhoufengbin.domain.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
            <!--
                一对多使用collection标签关联,当实体类中由集合时使用。
                property="orderList" 封装到集合的属性名
                ofType="order" 封装集合的泛型类型
            -->
            <collection property="ordersList" ofType="com.zhoufengbin.domain.Orders">
                <id property="id" column="oid"/>
                <result property="ordertime" column="ordertime"/>
                <result property="total" column="total"/>
                <result property="uid" column="uid"/>
            </collection>
        </resultMap>
    	<!--一对多查询的需求:查询所有用户,与此同时查询出该用户具有的订单
    	resultMap和collection 属性配置映射关系
    	-->
        <select id="findAllWithUserOrder" resultMap="userOrderMap">
            SELECT *,o.id oid, ordertime, total, uid FROM USER u LEFT JOIN orders o ON u.`id` = o.`uid`;
        </select>
    

    1.3 多对多查询

    • 多对多查询的需求:查询所有用户同时查询出该用户的所有角色

    步骤一:在对应的UserMapper接口中创建方法

    //查询所有用户同时查询出该用户的所有角色 n:m
    public List<User> findAllWithRole();
    

    步骤一:在对应的UserMapper接口中创建方法

        <resultMap id="userRoleMap" type="com.zhoufengbin.domain.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
            <collection property="roleList" ofType="com.zhoufengbin.domain.Role">
                <id property="id" column="rid"/>
                <result property="rolename" column="rolename"/>
                <result property="roleDesc" column="roleDesc"/>
            </collection>
        </resultMap>
        
        <select id="findAllWithRole" resultMap="userRoleMap">
            SELECT u.*,r.`id` rid, r.`rolename`, r.`roleDesc` 
            FROM USER u LEFT OUTER JOIN sys_user_role ur ON u.`id`=ur.`userid`   
                        LEFT OUTER JOIN sys_role r ON r.`id`=ur.`roleid`
        </select>
    

    2. 嵌套查询

    • 嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询,再使用MyBatis的语法嵌套在一
      起。

    2.1 一对一嵌套查询

    • 需求:查询一个订单,与此同时查询出该订单所属的用户
    -- 1.查询说有订单信息
    SELECT * FROM orders;
    -- 2.根订单中的外键uid查询到用户信息,假设订单表中的uid = 1
    SELECT * FROM USER WHERE id = 1
    -- 3.使用MyBatis将上面两布嵌套起来
    

    步骤一:在OrderMapper接口中创建方法

        /**
         * 查询每一个订单,与此同时查询出该订单所属的用户 1:1
         * 先查询出所有的订单信息
         * @return
         */
        public List<Orders> findAllOrders();
    

    步骤二:在UserMapper接口中创建方法

        /**
         * 查询一个订单,与此同时查询出该订单所属的用户
         * 根据订单表中查询出的uid查询订单的用户信息
         * @param id
         * @return
         */
        public  User findOneUserById(Integer id);
    

    步骤三:在OderMapper.xml中进行相应的配置

        <!--嵌套查询1:1:查询一个订单,与此同时查询出该订单所属的用户-->
        <resultMap id="orderUserMap" type="com.zhoufengbin.domain.Orders">
            <id property="id" column="id"/>
            <result property="ordertime" column="ordertime"/>
            <result property="total" column="total"/>
            <result property="uid" column="uid"/>
            <!--使用association属性引入其他映射文件中sql,根据username.id-->
            <!--
                property 的值为订单实体类中的User属性的属性名,应为该sql查询的结果需要封装到订单实体类中的user中。
                javaType user的全限定名。(表名user的类型为User类型)
                column 传入到引入sql语句中的参数
                select 值为引入sql的唯一标识符,表示需要引入该sql.
            -->
            <association property="user" javaType="com.zhoufengbin.domain.User" column="uid" select="com.zhoufengbin.mapper.UserOrderMapper.findOneUserById"/>
        </resultMap>
        <select id="findAllOrders" resultMap="orderUserMap" parameterType="int">
            select * from orders;
        </select>
    

    步骤四:在UserMapper.xml中进行相应的配置,代引入的sql

        <!--根据订单表中查询出的uid查询订单的用户信息-->
        <select id="findOneUserById" parameterType="int" resultType="com.zhoufengbin.domain.User">
            select * from user where id = #{uid}
        </select>
    

    2.2 一对多嵌套查询

    • 需求:查询所有用户,与此同时查询出该用户具有的订单 1:n

    步骤一:在UserMapper接口中创建查询方法

    /**需求:查询所有用户,与此同时查询出该用户具有的订单
         * 1. 查询所有用户信息
         * @return
         */
        public List<User> findAllUser();
    

    步骤二:在OrderMapper接口中创建查询方法

        /**
         * 需求:查询所有用户,与此同时查询出该用户具有的订单
         * 2. 根据用户表查询的id,查询订单信息
         * @param id
         * @return
         */
            public Orders findOneOrdersById(Integer id);
            
    

    步骤三:在OrderMapper.xml配置相应的信息

        <!--查询所有用户,与此同时查询出该用户具有的订单 1:n-->
        <resultMap id="userOrderMap1" type="com.zhoufengbin.domain.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
            <collection property="ordersList" ofType="com.zhoufengbin.domain.Orders" column="id" select="com.zhoufengbin.mapper.OrderMapper.findOneOrdersById"/>
        </resultMap>
        <select id="findAllUser" resultMap="userOrderMap1">
            select * from USER
        </select>
    

    步骤四:在OrderMapper.xml配置相应的信息

        <select id="findOneOrdersById" parameterType="int" resultType="com.zhoufengbin.domain.Orders">
            SELECT * FROM orders WHERE uid = #{id};
        </select>
    

    2.3 多对多嵌套查询

    • 需求:查询用户 同时查询出该用户的所有角色
    -- 需求:查询用户 同时查询出该用户的所有角色
    -- 查询用户信息
    	SELECT * FROM USER;
    -- 查询用户对应的角色信息
    	SELECT r.id,r.`rolename` rolename,r.`roleDesc` roleDesc 
    	FROM sys_role r LEFT OUTER JOIN sys_user_role ur ON r.id = ur.roleid
    	                LEFT OUTER JOIN USER u ON u.id = ur.`userid`
    	                WHERE u.`id` = 1
    	                         
    	SELECT r.id,r.`rolename` ,r.`roleDesc` 
    	FROM sys_role r
    	INNER JOIN sys_user_role ur ON r.`id` = ur.`roleid` 
    	WHERE ur.`userid` = 1
    

    步骤一:在UserMapper接口中创建方法

        /**需求:查询用户 同时查询出该用户的所有角色
         * 1.查询所用用户信息
         * @return
         */
        public List<User> findAllUser2();
    

    步骤二:在RoleMapper接口中创建方法

        /**需求:查询用户 同时查询出该用户的所有角色
         * 2.根据用户id查询所有角色信息
         * @param id
         * @return
         */
        public List<Role> findAllRole(Integer id);
    
    

    步骤二:在UserMapper.xml中配置相应的信息

        <!--嵌套查询多对多:查询所用用户信息-->
        <resultMap id="userRoleMap2" type="com.zhoufengbin.domain.User">
            <id property="id" column="id"/>
            <result property="username" column="username"/>
            <result property="birthday" column="birthday"/>
            <result property="sex" column="sex"/>
            <result property="address" column="address"/>
            <collection property="roleList" ofType="com.zhoufengbin.domain.Role" column="id" select="com.zhoufengbin.mapper.RoleMapper.findAllRole"/>
        </resultMap>
        <select id="findAllUser2" resultMap="userRoleMap2" resultType="com.zhoufengbin.domain.User">
            select * from user
        </select>
    

    步骤三:在RoleMapper.xml中配置相应的信息

    //带引入的sql
        <select id="findAllRole"  parameterType="int" resultType="com.zhoufengbin.domain.Role">
            SELECT r.id,r.`rolename` ,r.`roleDesc` FROM sys_role r
                    INNER JOIN sys_user_role ur ON r.`id` = ur.`roleid` WHERE ur.`userid` = #{userId}
        </select>
    
    展开全文
  • 数据仓储不像java、C++、JS等开发语言,而是数据库仓储更用于对接产品工作,查询数据、分析数据、得出产品未来发展方向,这才是产品经理日常工作的部分,而联表查询和嵌套查询作为数据库基础的查询方法,学习使用...

    数据仓储不像java、C++、JS等开发语言,而是数据库仓储更多用于对接产品工作,查询数据、分析数据、得出产品未来发展方向,与产品经理相关联,而联表查询和嵌套查询作为数据库基础的查询方法,学习使用,方便技术人员从数据库的角度收集数据、给产品经理分析、整理需求。

    查看源图像

    相信大家最烦的一件事情就是常常遇到大片知识盲区,而数据库就是我们的知识盲区之一,在工作的时候通过会遇到两种情况,一种是工作过于繁重,需要调取数据时需要自己调取,另一种就是由于与产品经理沟通所得出的数据分析结果无法满足自己的使用,身为产品经理的我们只能被迫进行数据收集、分析。

    因此,这就让我们有必要学习数据查询相关的知识咯,防止我们看到数据库就害怕,看到数据库就瑟瑟发抖,因此以下为各位产品经理介绍联表查询和嵌套查询。

    一、联表查询和嵌套查询是什么?

    联表查询:

    分为两表连接查询和多表连接查询;

    连接又分为内连接和外连接,

    内连接就是使用比较运算符(包括=、>、<、<>、>=、<=、!>和!<)进行表间的比较操作,查询与连接条件相匹配的数据。根据比较运算符不同,内连接分为等值连接和不等连接两种。 1. 仅将两个表中满足连接条件的行组合起来作为结果集。 2. 关键: inner join(也可叫join) 3. 概念:在连接条件中使用等于号(=)运算符,其查询结果中列出被连接表中的所有列,包括其中的重复列。

    外连接分为: 1. 左连接(LEFT JOIN) 2. 右连接(RIGHT JOIN) 3. 全连接(FULL JOIN) ,常用LEFT JOIN。4. 概念:返回左表中的所有行,如果左表中行在右表中没有匹配行,则结果中右表中的列返回空值null。

    嵌套查询:

    指在一个外层查询中包含有另一个内层查询。. 其中外层查询称为主查询,内层查询称为子查询。. SQL允许多层嵌套,由内而外地进行分析,子查询的结果作为主查询的查询条件。子查询中一般不使用order by子句,只能对最终查询结果进行排序

    二、联表查询和嵌套查询的区别

    联表查询可以理解为处于统一层级的互动,联表查询的数据之间的关系不需要确定表的建立时间,实体的所有信息通常都存储在表中。

    而嵌套查询就是我们俗称的俄罗斯套娃,即一个查询内包含一个或多个子查询。

    实例

    (1)SELECT 查询字段(多个表 表的别名:字段名) FROM关联表 LEFT JOIN 被关联表 ON 关联关系的表达式=相同含义相同值。

    (2)SELECT * FROM ...  LEFT JOIN ... ON... (SELECT * FROM ...  WHERE...)正常的FROM是一个表,用于查询一个结果集,给一个别名来替代这个表。

    从上面可以看出(1)是联表查询,而(2)是嵌套查询;联表查询可以讲查询的每个条件当成一个同级的表,而嵌套查询则当成一个数据表使用。

    三、联表查询和嵌套查询的实际运用

    如果看到这里小伙伴们还是不太懂,就实际运用给大家看吧

    本人自己做的供应链管理系统查询

    联表查询

    SELECT customer_order_no, order_phone,user_name,customer_order_money

    FROM yc_order WHERE customer_order_money BETWEEN 50 AND 80

    GROUP BY customer_order_no, order_phone,user_name

    从订单表中查询用户订单编号,手机号、用户名称、用户订单金额,筛选条件为订单金额为50到80元,并按照顾客订单编号、手机号和用户名分类。

    嵌套查询

    SELECT order_no,order_province,user_name,b.area_name FROM yc_order as a

    LEFT JOIN (SELECT * FROM yc_area WHERE area_type=1) as b

    ON a.order_province=b.area_code WHERE a.order_no=1116277441689450414

    从订单表连接区域表,并查询区域表中区域类型为1的等于订单表中的省份,当订单编号为1116277441689450414时,查询订单编号,订单省份、用户名和区域表中的用户名。

    相信看到这里大家已经可以看出两者的区别了吧,在实际进行数据查询时,一定要注意注意代码与代码之间的占位符和格式的正确,防止一片红色让人头大,理清逻辑才能写好正确的查询语句,在使用字符时记住一定要加英文的引号哦,要不然哭着找错误。

    简单的说,联表查询就是独立的表格之间,将有关系的值联系起来,找到想要的数据;而嵌套查询就是在一个数据表中找到你想要的条件匹配的值,单身狗不配在嵌套查询中存在,只能在联表查询中存在。

    从产品工作来说,战略层定大方向需要你进行数据分析,自己会查询数据,就不会因为与技术人员沟通时出现分歧导致得到的数据不准确,无法进行准确的数据分析,想要达到后端和数据类产品经理,为企业制定项目规划并维持产品运营,学会数据查询方式得出想要的数据,必然躲不过数据收集、分析、整理,在评审会上用客观的数据说话,为企业提供本质的需求。

    展开全文
  • 1.查询 1.创建数据库 t_emps create table t_emps ( id varchar(32) not null primary key, name varchar(20) null, sex varchar(3) null, birth date null, salary double null, deptId int null ); ...

    1.查询

    1.创建数据库

    • t_emps

    • create table t_emps ( id varchar(32) not null primary key, name varchar(20) null, sex varchar(3) null, birth date null, salary double null, deptId int null );

    • t_dept

    • create table t_dept ( did int auto_increment primary key, dname varchar(30) null, dlocation varchar(30) null, leader varchar(20) null );

    • 在t_dept中插入数据
      在这里插入图片描述

    • 在t_emps中插入数据
      -

    2.单表查询

    • 条件查询

    • SELECT * FROM t_emps WHERE sex <>'女' AND salary BETWEEN 5000 and 10000 and deptId IN (1,3);
      
    • 聚合函数

    • SELECT COUNT(*) FROM t_emps --总行数
      
      SELECT SUM(salary) FROM t_emps --总工资
      SELECT MAX(salary) FROM t_emps --最高工资
      SELECT MIN(salary) FROM t_emps --最低工资
      SELECT AVG(salary) FROM t_emps --平均工资
      
    • 分页

    • SELECT * FROM t_emps LIMIT 0,5 --第一页
      SELECT * FROM t_emps LIMIT 5,5 --第二页
      SELECT * FROM t_emps LIMIT 10,5 --第三页
      SELECT * FROM t_emps LIMIT 15,5 --第四页
      
    • 排序

    • SELECT * FROM t_emps ORDER BY salary ASC  --员工工资升序
      SELECT * FROM t_emps ORDER BY salary DESC  --员工工资降序
      SELECT * FROM t_emps WHERE deptId = 2 ORDER BY salary ASC --deptId为2的员工工资升序
      SELECT * FROM t_emps WHERE deptId = 2 ORDER BY salary DESC --deptId为2的员工工资降序
      SELECT * FROM t_emps ORDER BY birth --生日升序(默认升序)
      SELECT * FROM t_emps ORDER BY birth DESC --生日降序
      SELECT * FROM t_emps ORDER BY birth ,salary DESC --生日升序,工资降序
      SELECT * FROM t_emps ORDER BY birth  DESC,salary --生日降序,工资升序
      
    • 分组

    • SELECT COUNT(*),sex FROM t_emps GROUP BY sex --以性别分组
      SELECT COUNT(*),deptId FROM t_emps GROUP BY deptId --以deptId分组
      
    • 模糊查询

    • SELECT * FROM t_emps WHERE NAME LIKE '%曹%' --查询所有带"曹"字的人
      SELECT * FROM t_emps WHERE NAME LIKE '_乔'  --查询名字为两个字且第二个字是"乔"的人
      SELECT * FROM t_emps WHERE NAME LIKE '_小_'  --查询名字为三个字且第二个字"小"字的人
      SELECT * FROM t_emps WHERE NAME LIKE '曹%'  --查询所有姓曹的人
      

    3.多表查询

    1.内连接

    SELECT * FROM t_dept ,t_emps --(查询两个表所有的连接可能-->笛卡儿积n*m)
    
    SELECT * FROM t_dept d,t_emps e WHERE d.did = e.deptid --内连接方言版(只有部分数据库可以用)
    
    SELECT * FROM t_dept d INNER JOIN t_emps e ON d.did = e.deptid --内连接官方版(通用)
    
    

    2.外连接

    SELECT * FROM t_dept d LEFT JOIN t_emps e ON d.did = e.deptid --左外连接
    
    SELECT * FROM t_dept d RIGHT JOIN t_emps e ON d.did = e.deptid --右外连接
    
    SELECT * FROM t_dept d FULL JOIN t_emps e ON d.did = e.deptid --全外连接(mysql不支持)
    
    (mysql模拟全外连接 关键字unionSELECT * FROM t_dept d LEFT JOIN t_emps e ON d.did = e.deptid 
    UNION
    SELECT * FROM t_dept d RIGHT JOIN t_emps e ON d.did = e.deptid
    
    
    

    3.嵌套查询

    1.工资最高的人所在的部门名称

    ---->首先在员工表中查到最高工资是多少
    SELECT MAX(salary) FROM t_emps
    
    ---->然后通过最高工资在员工表找到对应的部门编号
    SELECT deptid FROM t_emps WHERE salary =(SELECT MAX(salary) FROM t_emps)
    
    ---->最后通过部门编号在部门表找到相应的部门名称
    SELECT dname FROM t_dept WHERE did in (SELECT deptid FROM t_emps WHERE salary =(SELECT MAX(salary) FROM t_emps))
    
    

    2.工资在平均工资上下浮动3000以内的人和部门的信息

    ---->首先从员工表中查出平均工资
    SELECT AVG(salary) FROM t_emps
    
    ---->然后根据平均工资在员工表中查出所在部门号
    SELECT deptId FROM t_emps WHERE salary BETWEEN (SELECT AVG(salary) FROM t_emps) -3000 AND (SELECT AVG(salary) FROM t_emps)+3000
    
    ---->根据部门号在员工表和部门表中查到人和部门信息
    SELECT * FROM t_dept d INNER JOIN t_emps e ON d.did = e.deptid WHERE did in ( SELECT deptId FROM t_emps WHERE salary BETWEEN (SELECT AVG(salary) FROM t_emps) -3000 AND (SELECT AVG(salary) FROM t_emps)+3000)
    
    

    3.人数最多的是哪个部门

    ---->统计数量
    SELECT COUNT(*) c,deptId FROM t_emps GROUP BY deptId
    
    ---->找到最大值
    SELECT MAX(e.c)  FROM (SELECT COUNT(*) c,deptId FROM t_emps GROUP BY deptId) e
    
    ---->显示
    SELECT COUNT(*) c,d.dname FROM t_dept d INNER JOIN t_emps e ON d.did =e.deptId GROUP BY d.did  HAVING  c=(SELECT MAX(e.c)  FROM (SELECT COUNT(*) c,deptId FROM t_emps GROUP BY deptId) e)
    
    
    展开全文
  • 一个多表嵌套查询的sql语句select batch_no "批次号",get_id "分类" from (select(select plan1.batch_no from product_plan plan1 where plan1.item_no=(select head1.product_code from wo_head head1 where head1...

    一个多表嵌套查询的sql语句

    select batch_no "批次号",get_id "分类" from (

    select(

    select plan1.batch_no from product_plan plan1 where plan1.item_no=(select head1.product_code from wo_head head1 where head1.order_no =bbb)) batch_no,

    (select decode(get_id,'BUY','外购件','MAK','自制件','MB','未定') from item where item_no= aaa) get_id

    from (select req.item_no aaa,req.order_no bbb from process_req req where req.status_id='C'and req.order_no in(select head.order_no  from wo_head head where head.batch_no in (select batch_no from product_plan) or head.product_code in ( select item_no from product_plan )))) order by qty desc

    相关文档:

    通常,你需要获得当前日期和计算一些其他的日期,例如,你的程序可能需要判断一个月的第一天或者最后一天。你们大部分人大概都知道怎样把日期进行分割(年、月、日等),然后仅仅用分割出来的年、月、日等放在几个函数中计算出自己所需要的日期!

    在这篇文章里,我将告诉你如何使用DATEADD和DATEDIFF函数来计算出在你 ......

    ORACLE SQL性能优化

    我要讲的题目是Oracle SQL性能优化,只是Oracle性能优化中的一项。Oracle的性能优化包含很多方面,比如调整物理存取,调整逻辑存取,调整内存使用,减少网络流量等。这里选择SQL性能优化是因为这部分内容我们测试人员最容易接触到,另外开发人员写SQL脚本时有时很随意,不知不觉就会造成程序性能上的� ......

    1. 死锁原理

    根据操作系统中的定义:死锁是指在一组进程中的各个进程均占有不会释放的资源,但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态。

    死锁的四个必要条件:

    互斥条件(Mutual exclusion):资源不能被共享,只能由一个进程使用。

    请求与保持条件(Ho ......

    1、 强大的group by

    1 select stdname,2 isnull(sum( case stdsubject when ' 化学 ' then Result end), 0 ) [化学],3 isnull(sum( case stdsubject when ' 数学 ' then Result end), 0 ) [数学],4 isnull(sum( case stdsubject when ' 物理 ' then Result end), 0 ) [物理],5 isnull(sum( case stdsubject when ' 语文 ' t ......

    很多时候,我们需要把数据库Sequence设置到某个特定的值开始,但是又不想重建这个Sequence 那下面的SQL语句就可以实现这样的功能: 其中user_seq是需要操作的Sequence名称,1 .. 100是递增100次 DECLARE

    rowCount1 NUMBER;

    BEGIN

    FOR cc IN 1 .. 100

    LOOP

    SELECT user_seq.NEXTVAL INTO rowCount1 f ......

    展开全文
  • 嵌套查询也称为子查询 #子查询 #查询工资最高的员工信息 SELECT * FROM emp,dept WHERE emp.dept_id = dept.id AND emp.salary = (SELECT MAX(emp.salary) FROM emp); -- 最高工资 #查询工资小于平均工资的...
  • 嵌套查询多表联查

    2021-07-14 15:11:36
    1、内连接:只取两张有对应关系的记录 select * from emp2 inner join dep2 on emp2.dep_id = dep2.id; select * from emp2 inner join dep2 on emp2.dep_id = dep2.id and dep2.name = ‘技术’; 2、left join 2...
  • 有学生老师两个实体集,假设学生与辅导员老师的关系是一位老师教个学生,一个学生只有一位辅导员老师。建表、建maven项目、导入依赖、写配置文件等等 1、对一 一个学生只有一位辅导员老师,则学生的实体类...
  • mysql 嵌套查询,并把查询结果命名为新的 代码实例: select * from (select id,city from 表名 where 查询条件='值') as 新名称 where 新的中的字段=值 效果: Mysql嵌套循环分组统计数目后再查询语句 代码...
  • 查询的作用:1、进行过滤:实例1:检索订购物品TNT2的所有客户的ID = + 一般,在WHERE子句中对于能嵌套的子查询的数目没有限制,不过在实际使用时由于性能的限制,不能嵌套的子查询。注意:列必须匹配 ——在...
  • 我拿到一个合适的值14,在以下的查询中会用到它。这是用来查询category 14 中所有item数大于2000的subcategory的语句:select c.idfrom subcategory as cinner join item as i on i.subcategory = c.idwhere c....
  • 4. select 订货单号,进货量 from 商品,订货 where 商品.商品编号=订货.商品编号 and 商品名称='螺母'5. select 订货单号,进货价格 from 商品,订货 where 商品.商品编号=订货.商品编号 and 商品名称=...
  • 一、(having,group by,select嵌套放在select里)可参考https://www.jianshu.com/p/8b135d373df1二、(not in,distinct去重,select嵌套放在where里)的内容如下: 实现功能:查询没学过"张三"老师授课的同学的信息...
  • 查询游戏历史成绩最高分前100Sql代码SELECT ps.* FROM cdb_playsgame ps WHERE ps.credits=(select MAX(credits)FROM cdb_playsgame ps1where ps.uid=ps1.uid AND ps.gametag=ps1.gametag) AND ps.gametag='yeti3'...
  • mysql 多表查询

    2021-01-19 03:29:55
    一:多表连接查询- 外连接语法:- select 字段列表from 表1 inner|left|right join 表2on 表1.字段 = 表2.字段;(1)直接交叉连接:生成笛卡儿积,不适用于任何匹配条件mysql> select * fromemployee,department;+...
  • 许多人都觉得MySQL不支持嵌套查询,其实MySQl从4.11版后已经完全支持嵌套查询了,那么下面我举些简单的嵌套查询的例子吧(源程序来自MySQL User Manual):1. SELECT语句的子查询:语法: (注意:AS 可省略)CODE:SELECT ...
  • Mybatis链表查询/嵌套查询

    千次阅读 2021-12-03 15:37:37
    链表查询 order user ...1,创建的实体类 User表和Order ...order类中的 private User user 用来关系两个类(连接起来) ...查询:根据order订单号查询订单用户所有信息 ...嵌套查询 userda...
  • 多表查询实验报告.doc

    2021-02-02 08:19:30
    多表查询实验报告《数据库系统概论》实验报告实验名称: 多表查询实 验 人:实验地点: 实验楼317实验日期: 2009-10-12实验准备1.硬件及软件环境要求为了使该实验顺利进行,需要有一台计算机,计算机必须安装...
  • 虽然多表查询,在计算机的必须课,数据库,里面已经大讲特讲,但是这个难点很多老师都没有讲深讲透。跟你净扯一大堆,左连接右连接的东西,让人一头雾水。老师把虽然多表查询,在计算机的必须课,数据库,里面已经大...
  • mysql嵌套查询和查询优化方法时间:2019-01-19 11:57作者:网友投稿嵌套查询糟糕的优化在上面我提到过,不考虑特殊的情况,联查询要比嵌套查询更有效。尽管两条查询表达的是同样的意思,尽管你的计划是告诉...
  • 嵌套查询和嵌套结果。 嵌套查询: 是指通过执行另外一条SQL映射语句来返回预期的复杂类型。 会执行条sql语句 嵌套结果查询: 是使用嵌套结果映射来处理重复的联合结果的子集。 只会执行一条复杂的sql语句 简单来说...
  • 最近学习MyBatis框架 用到多表查询比较多,以前学的不是很好,今特意回来补上。呜呜呜。先看我的数据库表总共4张表老师职位表 tb_position 学生表(为了好辨认效果) tb_student 老师表 (id 班级 老师名字 职位对应表)...
  • 例3.42 查询每个学生及其选修课课程的情况 SELECT STUDENT.*,SC.* FROM STUDENT,SC WHERE STUDENT.SNO=SC.SNO; 当去掉 where 子句 这就是笛卡尔乘积 例3.50 对例3.49用自然连接完成 SELECT STUDENT.SNO,SNAME,...
  • 2.熟练掌握简单的数据连接查询和嵌套查询的操作方法。 实验内容: 创建教学管理数据库“JXGL”,在“JXGL”数据库中创建3-2中的三张表并添加数据,实现数据的单查询操作。 实验步骤: 写出下列操作的SQL语句 在...
  • 实验五 连接查询和嵌套查询一、实验目的二、实验内容及要求(请同学们尝试每道题均使用连接和嵌套两种方式来进行查询,如果可以的话)1. 找出所有任教“数据库”的教师的姓名。2. 取出学号为“980101011”的学生...
  • 嵌套查询单值嵌套查询值返回结果是一个值的嵌套查询称为单值嵌套查询对Sales数据库,列出市场部的所有员工的编号USE SaleGOSELECT employee_id FROM employeeWHERE department_id=(SELECT department_...
  • 嵌套查询的弊端:即嵌套查询的N+1问题 尽管嵌套查询大量的简化了存在关联关系的查询,但它的弊端也比较明显:即所谓的N+1问题。关联的嵌套查询显示得到一个结果集,然后根据这个结果集的每一条记录进行关联查询。 ...
  • MySQL 提供了功能强大、灵活的语句来实现这些操作,本章将介绍如何使用 SELECT 语句查询数据中的一列或列数据、使用集合函数显示查询结果、连接查询、子查询以及使用正则表达式进行查询等。重要提示:查询的能力...
  • 嵌套类型查询

    2021-05-07 07:38:39
    示例查询表中nested.nested_keyword列值为'sub'的数据。$request = array('table_name' => 'php_sdk_test','index_name' => 'php_sdk_test_search_index','search_query' => array('offset' => 0,'limit...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 225,719
精华内容 90,287
关键字:

多表查询和嵌套查询

友情链接: VC6.rar