精华内容
下载资源
问答
  • having子句与where子句

    千次阅读 2020-10-11 20:10:50
    1.相同点 都是对记录进行筛选 2.不同点 ...where子句where子句仅仅用于从from子句中返回的值,from子句返回的每一行数据都会用where子句中的条件进行判断筛选,where子句中允许使用比较运算符和逻辑运算

    1.相同点
    都是对记录进行筛选
    2.不同点
    2.1 where 不能放在group by后面

    2.2 having 是跟group by连在一起用的,放在group by 后面,此时的作用相当于where

    2.3 where 后面的条件中不能有聚集函数,比如SUM(),AVG()等,而HAVING可以。

    一、where子句

    where子句:where子句仅仅用于从from子句中返回的值,from子句返回的每一行数据都会用where子句中的条件进行判断筛选,where子句中允许使用比较运算符和逻辑运算符

    二、having子句

    having子句:having子句通常是与group by子句一起使用的,因为having的作用是对使用group by 进行分组统计后的结果进行进一步的筛选。
    三、下面通过where子句和having子句的对比,更进一步的理解他们

    在查询过程中聚合函数(SUM,MIN,MAX,AVG,COUNT)要比having子句优先执行,简单的理解为只有有了统计结果后我才能执行筛选。where子句在查询过程中执行优先级别优先于聚合函数(SUM,MIN,MAX,AVG,COUNT),因为他是一句一句筛选的,HAVING子句可以让我们筛选成组后的对各组数据筛选。而WHERE子句在聚合前筛选记录,如:现在我们想要部门号不等于10的部门并且工资总和大于8000的部门编号?

    分析:通过where子句筛选除部门编号不为10的部门,然后对部门工资进行统计,然后使用having子句对统计结果进行筛选。

     select deptno,sum(sa1) from emp
    
        where deptno<>'10'  group by deptno
    
        having sum(sa1)>8000;
    

    FAQ:1.既然where 和having 都可以对记录进行筛选 那么为什么不直接用having?
    HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销。
    2.为什么group by 之后不可以用where 子句 ?
    答:1).首先 我们看一下数据库的书写顺序 以及 执行顺序
    书写顺序:select … from … where … group by … having … order by … limit …
    好的 我们看到 书写顺序应该是where 在 group by 之前 ,你要问我为啥,
    我会说甲鱼的屁股–规定。。。

    2).然后我们再看一下执行顺序
    执行顺序:from–>where–>select–>group by–>having–>order by–>limit…
    我们可以看到 where 子句 是在 group by 之前执行的 也就是说 我们先找到表,再根据where子句的条件进行筛选 ,再进行查询操作 ,之后再进行分组等操作 ,所以说 group by 是对 基于where 条件查询的结果进行操作。 having子句是会在分组后对分组形成的结果进行过滤。

    也正是因为执行顺序所以where中可以使用表别名但是不能使用列别名 ,而having中可以使用表别名 也可以使用列别名。

    小结:where子句只能接受from子句输出的数据,而having子句则可以接受来自group by ,where或者from子句的输入。

    参考了很多大佬的文章 ,侵删。
    以上。

    展开全文
  • Where子句

    千次阅读 2017-04-22 10:20:24
    Where子句 1、查询emp表中20号部门的员工信息 select * from emp where deptno = 20;   2、查询姓名是SMITH的员工,字符串使用'',内容大小写敏感 select * from emp where ename = 'SMITH';     3、查询...

    Where子句

    1、查询emp表中20号部门的员工信息

    select * from emp where deptno = 20;

     

    2、查询姓名是SMITH的员工,字符串使用'',内容大小写敏感

    select * from emp where ename = 'SMITH';

     

     

    3、查询19801217日入职的员工,注意oracle默认日期格式(DD-MON-RR表示2位的年份)

    select * from emp where hiredate = '17-12-80';

     

    4、查询工资大于1500的员工

    select * from emp where sal > 1500;

     

    5、查询工资不等于1500的员工【!=<>

    select * from emp where sal <> 1500;

     

    6、查询薪水在13001600之间的员工,包括13001600

    select * from emp where (sal>=1300) and (sal<=1600);

    select * from emp where sal between 1300 and 1600;

     

    7、查询薪水不在13001600之间的员工,不包括13001600

    select * from emp where sal NOT between 1300 and 1600;

     

    8、查询入职时间在"1981-2-20""1982-1-23"之间的员工

    select * from emp where hiredate between '20-2-81' and '23-1-82';

    注意:

    1)对于数值型,小数值在前,大数值在后

    2)对于日期型,年长值在前,年小值在后

     

    9、查询20号或30号部门的员工,例如:根据ID号,选中的员工,批量删除

    select * from emp where (deptno=20) or (deptno=30);

    select * from emp where deptno in (30,20);

     

    10、查询不是20号或30号部门的员工

    select * from emp where deptno NOT in (30,20);

     

    11、查询姓名以大写字母S开头的员工,使用%表示0个,1个或多个字符

    select * from emp where ename like 'S';

    等价

    select * from emp where ename = 'S';

    select * from emp where ename like 'S%';

     

    注意:

    凡是精确查询用=符号

    凡是不精确查询用like符号,我们通常叫模糊查询

     

    12、查询姓名以大写字母N结束的员工

    select * from emp where ename like '%N';

     

    13、查询姓名第一个字母是T,最后一个字母是R的员工

    select * from emp where ename like 'T%R';

     

    14、查询姓名是4个字符的员工,且第二个字符是I,使用_只能表示1个字符,不能表示0个或多个字符

    select * from emp where ename like '_I__';

     

    15、插入一条姓名为'T_IM'的员工,薪水1200

    insert into emp(empno,ename) values(1111,'T_IM');

     

    16、查询员工姓名中含有'_'的员工,使用\转义符,让其后的字符回归本来意思【like '%\_%' escape '\'

    select * from emp where ename like '%\_%' escape '\';

     

    17、插入一个姓名叫'的员工

    insert into emp(empno,ename) values(2222,'''');

     

    18、插入一个姓名叫''的员工

    insert into emp(empno,ename) values(2222,'''''');

     

    19、查询所有员工信息,使用%%%

    select * from emp;

    select * from emp where ename like '%';

    select * from emp where ename like '%_%';

     

    20、查询佣金为null的员工

    select * from emp where comm is null;

    注意:null不能参数=运算

          null能参数number/date/varchar2类型运算

     

    21、查询佣金为非null的员工

    select * from emp where comm is not null;

     

    22、查询无佣金且工资大于1500的员工

    select *

    from emp

    where (comm is null) and (sal>1500);

     

    23、查询工资是150030005000的员工

    select *

    from emp

    where sal in (4000,10000,1500,3,300,3000,5000);

     

    24、查询职位是"MANAGER"或职位不是"ANALYST"的员工(方式一,使用!=<>

    select *

    from emp

    where (job='MANAGER') or (job<>'ANALYST');

     

    25、查询职位是"MANAGER"或职位不是"ANALYST"的员工(方式二,使用not

    select *

    from emp

    where (job='MANAGER') or (not(job='ANALYST'));

     

     

    展开全文
  • 易语言学习进阶WHERE子句源码,学习进阶WHERE子句
  • SQL WHERE 子句

    2018-10-04 19:25:23
    SQL WHERE 子句 WHERE 子句用于过滤记录。 SQL WHERE 子句 WHERE 子句用于提取那些满足指定标准的记录。 SQL WHERE 语法 SELECT column_name,column_name FROM table_name WHERE column_name operator value; 演示...

    SQL WHERE 子句
    WHERE 子句用于过滤记录。

    SQL WHERE 子句
    WHERE 子句用于提取那些满足指定标准的记录。

    SQL WHERE 语法

    SELECT column_name,column_name
    FROM table_name
    WHERE column_name operator value;
    

    演示数据库
    在本教程中,我们将使用 RUNOOB 样本数据库。

    下面是选自 “Websites” 表的数据:

    +----+--------------+---------------------------+-------+---------+
    | id | name         | url                       | alexa | country |
    +----+--------------+---------------------------+-------+---------+
    | 1  | Google       | https://www.google.cm/    | 1     | USA     |
    | 2  | 淘宝          | https://www.taobao.com/   | 13    | CN      |
    | 3  | 菜鸟教程      | http://www.runoob.com/    | 4689  | CN      |
    | 4  | 微博          | http://weibo.com/         | 20    | CN      |
    | 5  | Facebook     | https://www.facebook.com/ | 3     | USA     |
    +----+--------------+---------------------------+-------+---------+
    

    WHERE 子句实例
    下面的 SQL 语句从 “Websites” 表中选取国家为 “CN” 的所有网站:
    实例:

    SELECT * FROM Websites WHERE country='CN';
    

    执行输出结果:
    在这里插入图片描述
    文本字段 vs. 数值字段
    SQL 使用单引号来环绕文本值(大部分数据库系统也接受双引号)。

    在上个实例中 ‘CN’ 文本字段使用了单引号。

    如果是数值字段,请不要使用引号。
    实例

    SELECT * FROM Websites WHERE id=1;
    

    执行输出结果:
    在这里插入图片描述
    WHERE 子句中的运算符
    下面的运算符可以在 WHERE 子句中使用:
    在这里插入图片描述

    展开全文
  • Java WHERE子句

    千次阅读 2012-05-31 20:14:18
    WHERE子句 本书前面已经接触过WHERE子句的用法,这一节将详细讨论WHERE子句中查询条件的构成。WHERE子句必须紧跟FROM子句之后,在WHERE子句中,使用一个条件从FROM子句的中间结果中选取行。其基本格式为: WHERE...

    WHERE子句

     

    本书前面已经接触过WHERE子句的用法,这一节将详细讨论WHERE子句中查询条件的构成。WHERE子句必须紧跟FROM子句之后,在WHERE子句中,使用一个条件从FROM子句的中间结果中选取行。其基本格式为:

    WHERE where_definition

    其中,where_definition为查询条件。语法格式为:

    where_definition:

       <precdicate>

        |<precdicate>{ AND | OR } <precdicate>

        |(where_definition)

        |NOT where_definition

    其中,predicate为判定运算,结果为TRUE、FALSE或UNKNOWN。

    <predicate>:

      expression { = | < | <= | > | >= | <=> | <> | !=} expression                      /*比较运算*/

      |match_expression [ NOT ] LIKE match_expression [ ESCAPE 'escape_character ' ]

                                                                                                                                                    /*LIKE运算符*/

      |match_expression [ NOT ][ REGEXP | RLIKE ] match_expression

                                                                                                                                                                                   /*REGEXP运算符*/

      |expression [ NOT ] BETWEEN expression AND expression                                   /*指定范围*/

      | expression IS [ NOT ] NULL                                                                                          /*是否空值判断*/

      |expression [ NOT ] IN ( subquery | expression [,…n] )                                        /*IN子句*/

      |expression { = | < | <= | > | >= | <=> | <> | !=} { ALL| SOME | ANY } ( subquery )

                                                                                                                                                     /*比较子查询*/

      |EXIST ( subquery )                                                                                                       /*EXIST子查询*/

    WHERE子句会根据条件对FROM子句的中间结果中的行一行一行地进行判断,当条件为TRUE的时候,一行就被包含到WHERE子句的中间结果中。

    说明:

    IN关键字既可以指定范围,也可以表示子查询。

    在SQL中,返回逻辑值(TRUE或FALSE)的运算符或关键字都可称为谓词。

    判定运算包括比较运算、模式匹配、范围比较、空值比较和子查询。

    1.  比较运算

    比较运算符用于比较两个表达式值,MySQL支持的比较运算符有:=(等于)、<(小于)、<=(小于等于)、>(大于)、>=(大于等于)、<=>(相等或都等于空)、<>(不等于)、!=(不等于)。

    比较运算的语法格式为:

    expression { = | < | <= | > |>= | <=> | <> | != } expression

    其中expression是除TEXT和BLOB外类型的表达式。

    当两个表达式值均不为空值(NULL)时,除了“<=>”运算符,其他比较运算返回逻辑值TRUE(真)或FALSE(假);而当两个表达式值中有一个为空值或都为空值时,将返回UNKNOWN。

    MySQL有一个特殊的等于运算符“<=>”,当两个表达式彼此相等或都等于空值时,它的值为TRUE,其中有一个空值或都是非空值但不相等,这个条件就是FALSE。没有UNKNOWN的情况。

    查询XS表中备注为空的同学的情况。

    SELECT 姓名,学号,出生日期,总学分

        FROM XS

        WHERE 备注<=>NULL;

    从查询条件的构成看出,可以将多个判定运算的结果通过逻辑运算符(AND、OR、XOR和NOT)组成更为复杂的查询条件。有关逻辑运算符,第6章会具体介绍。

    查询XS表中专业为计算机,性别为女(0)的同学的情况。

    SELECT 姓名,学号,性别,总学分

        FROM XS

        WHERE 专业名='计算机' AND 性别=0;

    查询结果为:

     

     

    2.  模式匹配

    (1)LIKE运算符

    LIKE运算符用于指出一个字符串是否与指定的字符串相匹配,其运算对象可以是char、varchar、text、datetime等类型的数据,返回逻辑值TRUE或FALSE。LIKE谓词表达式的格式为:

    match_expression [ NOT ] LIKEmatch_expression [ ESCAPE 'escape_character' ]

    使用LIKE进行模式匹配时,常使用特殊符号_和%,可进行模糊查询。“%”代表0个或多个字符,“_”代表单个字符。

    escape_character:转义字符,escape_character 没有默认值,且必须为单个字符。当要匹配的字符串中含有与特殊符号(_和%)相同的字符时,此时应通过该字符前的转义字符指明其为模式串中的一个匹配字符。使用关键字ESCAPE可指定转义符。

    由于MySQL默认不区分大小写,要区分大小写时需要更换字符集的校对规则。

    查询XSCJ数据库XS表中姓“王”的学生学号、姓名及性别。

    SELECT 学号,姓名,性别

      FROM XS

      WHERE 姓名 LIKE '王%';

    执行结果为:

     

     

    查询XSCJ数据库XS表中学号倒数第二个数字为0的学生学号、姓名及专业名。

    SELECT 学号,姓名,专业名

      FROM XS

      WHERE 学号 LIKE '%0_';

    执行结果为:

     

     

    如果我们想要查找特殊符号中的一个或全部(_和%),我们必须使用一个转义字符。

    查询XS表中名字包含下画线的学生学号和姓名。

    SELECT 学号,姓名

      FROM XS

      WHERE 学号 LIKE '%#_%'ESCAPE '#';

    说明:由于没有学生满足这个条件,所以这里没有结果返回。定义了“#”为转义字符以后,语句中在“#”后面的“_”就失去了它原来特殊的意义。

    (2)REGEXP运算符

    REGEXP运算符用来执行更复杂的字符串比较运算。REGEXP是正则表达式(regularexpression)的缩写。和LIKE运算符一样,REGEXP运算符有多种功能,但它不是SQL标准的一部分,REGEXP运算符的一个同义词是RLIKE。

    语法格式:

    match_expression [ NOT ][ REGEXP | RLIKE ]match_expression

    LIKE运算符有两个符号具有特殊的含义:“_”和“%”。而REGEXP运算符则有更多的符号有特殊的含义,参见表4.11。

     

     

    查询姓李的同学的学号、姓名和专业名。

    USE XSCJ

    SELECT 学号,姓名,专业名

        FROM XS

        WHERE 姓名 REGEXP '^李';

    执行结果:

     

    查询学号里包含4、5、6的学生学号、姓名和专业名。

    SELECT 学号,姓名,专业名

        FROM XS

        WHERE 学号 REGEXP'[4,5,6]';

    执行结果为:

     

    查询学号以08开头,以08结尾的学生学号、姓名和专业名。

    SELECT 学号,姓名,专业名

       FROM XS

       WHERE 学号 REGEXP'^08.*08$';

    执行结果为:

     

     

    3.  范围比较

    用于范围比较的关键字有两个:BETWEEN和IN。

    当要查询的条件是某个值的范围时,可以使用BETWEEN关键字。BETWEEN关键字指出查询范围,格式为:

    expression [ NOT ] BETWEEN expression1 ANDexpression2

    当不使用NOT时,若表达式expression的值在表达式expression1与expression2之间(包括这两个值),则返回TRUE,否则返回FALSE;使用NOT时,返回值刚好相反。

    注意:expression1的值不能大于expression2的值。

    使用IN关键字可以指定一个值表,值表中列出所有可能的值,当与值表中的任一个匹配时,即返回TRUE,否则返回FALSE。使用IN关键字指定值表的格式为:

    expression IN ( expression [,…n])

    查询XSCJ数据库XS表中不在1989年出生的学生情况。

    SELECT 学号, 姓名, 专业名, 出生日期

       FROM XS

       WHERE 出生日期 NOTBETWEEN '1989-1-1' and '1989-12-31';

    执行结果为:

     

    查询XS表中专业名为“计算机”、“通信工程”或“无线电”的学生的情况。

    SELECT *

        FROM XS

       WHERE 专业名 IN  ('计算机', '通信工程', '无线电');

    该语句与下列语句等价:

    SELECT *

      FROM XS

      WHERE 专业名 ='计算机' OR 专业名 = '通信工程'  OR 专业名 = '无线电';

    说明:IN关键字最主要的作用是表达子查询。

    4.  空值比较

    当需要判定一个表达式的值是否为空值时,使用IS NULL关键字,格式为:

    expression IS [ NOT ] NULL

    当不使用NOT时,若表达式expression的值为空值,返回TRUE,否则返回FALSE;当使用NOT时,结果刚好相反。

    查询XSCJ数据库中总学分尚不定的学生情况。

    SELECT *

      FROM XS

      WHERE 总学分 IS NULL;

    本例即查找总学分为空的学生,结果为空。

    5.  子查询

    在查询条件中,可以使用另一个查询的结果作为条件的一部分,例如,判定列值是否与某个查询的结果集中的值相等,作为查询条件一部分的查询称为子查询。SQL标准允许SELECT多层嵌套使用,用来表示复杂的查询。子查询除了可以用在SELECT语句中,还可以用在INSERT、UPDATE及DELETE语句中。子查询通常与IN、EXIST谓词及比较运算符结合使用。

    (1)IN子查询

    IN子查询用于进行一个给定值是否在子查询结果集中的判断,格式为:

    expression [ NOT ] IN  ( subquery )

    其中,subquery是子查询。当表达式expression与子查询subquery的结果表中的某个值相等时,IN谓词返回TRUE,否则返回FALSE;若使用了NOT,则返回的值刚好相反。

    查找在XSCJ数据库中选修了课程号为206的课程的学生的姓名、学号。

    SELECT 姓名,学号

           FROMXS

           WHERE学号 IN

                         (SELECT 学号

                         FROMXS_KC 

                         WHERE课程号 = '206'

                         );

    查询结果如下:

    说明:在执行包含子查询的SELECT语句时,系统先执行子查询,产生一个结果表,再执行查询。本例中,先执行子查询:

    SELECT 学号

       FROM  XS_KC

       WHERE 课程号= '206';

    得到一个只含有学号列的表,XS_KC中的每个课程名列值为206的行在结果表中都有一行。再执行外查询,若XS表中某行的学号列值等于子查询结果表中的任一个值,则该行就被选择。

    注意:IN子查询只能返回一列数据。对于较复杂的查询,可以使用嵌套的子查询。

    查找未选修离散数学的学生的姓名、学号、专业名。

    SELECT 姓名,学号,专业名

           FROMXS

           WHERE学号 NOT IN

                  (

                         SELECT学号

                                FROMXS_KC

                                WHERE课程号 IN

                                       (SELECT 课程号

                                              FROMKC

                                              WHERE  课程名 ='离散数学'

                                      )

                  );

    执行结果为:

     

     

     

    (2)比较子查询

    这种子查询可以认为是IN子查询的扩展,它使表达式的值与子查询的结果进行比较运算,格式为:

    expression { < | <= | = | > |>= | != | <> } { ALL | SOME | ANY } ( subquery )

    其中,expression为要进行比较的表达式,subquery是子查询。ALL、SOME和ANY说明对比较运算的限制。

    如果子查询的结果集只返回一行数据时,可以通过比较运算符直接比较。

    ALL指定表达式要与子查询结果集中的每个值都进行比较,当表达式与每个值都满足比较的关系时,才返回TRUE,否则返回FALSE;

    SOME或ANY是同义词,表示表达式只要与子查询结果集中的某个值满足比较的关系时,就返回TRUE,否则返回FALSE。

    查找选修了离散数学的学生学号。

    SELECT 学号

           FROMXS_KC

           WHERE  课程号 =

                  (

                         SELECT课程号

                         FROMKC

                         WHERE 课程名 ='离散数学'

                  );

    查询结果为:

    查找XS表中比所有计算机系的学生年龄都大的学生学号、姓名、专业名、出生日期。

    SELECT 学号, 姓名, 专业名, 出生日期

           FROMXS

           WHERE  出生日期 <ALL

                   (

                         SELECT出生日期

                                FROMXS

                                WHERE专业名 ='计算机'

                   );

    执行结果为:

     

     

    查找XS_KC表中课程号206的成绩不低于课程号101的最低成绩的学生的学号。

    SELECT 学号

           FROMXS_KC

           WHERE课程号 ='206'  AND 成绩 >=ANY

                    (

                         SELECT成绩

                                FROMXS_KC

                                WHERE课程号 ='101'

                    );

    执行结果为:

     

     

    (3)EXISTS子查询

    EXISTS谓词用于测试子查询的结果是否为空表,若子查询的结果集不为空,则EXISTS返回TRUE,否则返回FALSE。EXISTS还可与NOT结合使用,即NOT EXISTS,其返回值与EXIST刚好相反。格式为:

    [ NOT ] EXISTS ( subquery )

    查找选修206号课程的学生姓名。

    SELECT 姓名

      FROM XS

      WHERE EXISTS

         (

               SELECT *

                    FROM XS_KC

                    WHERE 学号 = XS.学号 AND 课程号 = '206'

         );

    执行结果为:

     

     

    分析:

    ① 本例在子查询的条件中使用了限定形式的列名引用XS.学号,表示这里的学号列出自表XS。

    ② 本例与前面的子查询例子不同点是,前面的例子中,内层查询只处理一次,得到一个结果集,再依次处理外层查询;而本例的内层查询要处理多次,因为内层查询与XS.学号有关,外层查询中XS表的不同行有不同的学号值。这类子查询称为相关子查询,因为子查询的条件依赖于外层查询中的某些值。其处理过程是:首先查找外层查询中XS表的第一行,根据该行的学号列值处理内层查询,若结果不为空,则WHERE条件就为真,就把该行的姓名值取出作为结果集的一行;然后再找XS表的第2、3、…行,重复上述处理过程直到XS表的所有行都查找完为止。

    查找选修了全部课程的同学的姓名。

    SELECT 姓名

      FROM XS

      WHERE NOT EXISTS

         (

             SELECT *

                   FROM KC

                   WHERE NOT EXISTS

                   ( SELECT *

                      FROM XS_KC

                       WHERE 学号=XS.学号 AND 课程号=KC.课程号

                   )

         );

    说明:由于没有人选了全部课程,所以结果为空。

    MySQL区分了4种类型的子查询:返回一个表的子查询是表子查询;返回带有一个或多个值的一行的子查询是行子查询;返回一行或多行,但每行上只有一个值的是列子查询;只返回一个值的是标量子查询。从定义上讲,每个标量子查询都是一个列子查询和行子查询。上面介绍的子查询都属于列子查询。

    另外,子查询还可以用在SELECT语句的其他子句中。

    表子查询可以用在FROM子句中,但必须为子查询产生的中间表定义一个别名。

    从XS表中查找总学分大于50的男同学的姓名和学号。

    SELECT 姓名,学号,总学分

       FROM  (  SELECT 姓名,学号,性别,总学分

                      FROM XS

                      WHERE 总学分>50

               ) AS STUDENT

       WHERE 性别='1';

    查询结果:

     

     

    说明:在这个例子中,首先处理FROM子句中的子查询,将结果放到一个中间表中,并为表定义一个名称STUDENT,然后再根据外部查询条件从STUDENT表中查询出数据。另外,子查询还可以嵌套使用。

    SELECT关键字后面也可以定义子查询。

    从XS表中查找所有女学生的姓名、学号,以及与081101号学生的年龄差距。

    SELECT 学号, 姓名, YEAR(出生日期)-YEAR(

                                             (SELECT 出生日期

                                               FROM XS

                                               WHERE 学号='081101'

                                             )  )  AS 年龄差距

       FROM XS

       WHERE 性别='0';

    查询结果:

     

     

    说明:本例中子查询返回值中只有一个值,所以这是一个标量子查询。YEAR函数用于取出DATE类型数据的年份。

    在WHERE子句中还可以将一行数据与行子查询中的结果通过比较运算符进行比较。

    查找与081101号学生性别相同、总学分相同的学生学号和姓名。

    SELECT 学号,姓名

       FROM XS

       WHERE  (性别,总学分)=( SELECT 性别,总学分

                                FROM XS

                                WHERE 学号='081101'

                              );

    查询结果:

     

     

     

     

    展开全文
  • where子句和having子句区别

    千次阅读 2017-10-21 17:21:34
    where子句和having子句的区别:  1.where 不能放在group by后面  2.having 是跟group by连在一起用的,放在group by 后面,此时的作用相当于where  3.where 后面的条件中不能有聚集函数,比如SUM(),AVG()等,而...
  • SQLite WHere子句

    千次阅读 2018-01-26 19:08:00
    SQLite的WHERE子句用于指定从一个表或多个表中获取数据的条件。如果满足给定的数据,即为真(true)时,则从表中返回特定的值。您可以使用WHERE子句过滤记录,只获取需要的记录。  WHERE子句不仅可用在SELECT语句中...
  • 这里的where子句内容是( )。 a.s.s# = sc.s# and c.c# = sc.c# and sage>=20 and cname=‘access’ b.s.s# = sc.s# and c.c# = sc.c# and sage in>=20 and cname in ‘access’ c.sage in>=...
  • WHERE 子句运算符

    2016-09-10 08:16:30
    where 子句运算符
  • where 子句的执行顺序

    2020-09-11 10:16:11
    貌似在2005之前的版本中,where子句的顺序是从前往后的。但是又貌似在2005的版本中进行了优化,所有的顺序都被统一成了以过滤能力进行排序的语句。
  • Having子句和Where子句

    千次阅读 2019-05-14 14:45:10
    where 子句和having子句中的区别(此文章为借鉴的总结) 1.where 不能放在GROUP BY 后面 2.HAVING 是跟GROUP BY 连在一起用的,放在GROUP BY 后面,此时的作用相当于WHERE 3.WHERE 后面的条件中不能有聚集函数,...
  • 1.5.2 WHERE子句

    千次阅读 2016-02-02 16:18:33
    1.5.2 WHERE子句正在更新内容,请稍后
  • 主要介绍了在oracle中where 子句和having子句中的区别,本文通过sql语句给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 详析SQL语言的WHERE子句与HAVING子句.pdf
  • 主要给大家介绍了关于SQL中where子句与having子句的区别的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了详解MySQL中WHERE子句的用法,是MySQL入门学习中的基础知识,需要的朋友可以参考下
  • where子句与having子句的区别

    千次阅读 2015-11-08 22:09:22
    where子句:是在分组之前使用,表示从所有数据中筛选出部分数据,以完成分组的要求,  在where子句中不允许使用统计函数,没有group by子句也可以使用。 having子句:是在分组之后使用的,表示对分组统计后的数据...
  • SQLite中的WHERE子句

    2018-05-03 10:05:28
    SQLite中的WHERE子句WHERE子句用于从FROM子句生成的工作表中过滤行。它提供了对每一行进行判断的表达式。当表达式返回的值为false或NULL时,此行就会被丢弃。这种丢弃只是删除记录,并不会被当作错误处理。所以,在...
  • HAVING子句会在分组之后对分组形成的结果进行过滤。 ...这个过程需要聚合、排序,因此如果通过WHERE子句限制记录而省略HAVING子句,是可以提升性能的。 点击(此处)折叠或打开 ...
  • Mysql中的where子句

    千次阅读 2017-04-18 21:46:37
    Mysql中的where子句 1、基本使用 在SELECT语句中,数据根据WHERE子句中指定的搜索条件进行过滤。WHERE子句在表名( FROM子句)之后给出。例如: SELECT * FROM book WHERE number=3 结果如下: 这条语句从...
  • T-SQL中where子句与having子句的对比分析.pdf
  • WHERE子句设置查询条件,过滤掉不需要的数据行。  例如下面语句查询年龄大于10的数据: SELECT * FROM student WHERE age>10  WHERE子句可包括各种条件运算符: 运算符 表示形式 比较运算符(大小比较) >、...
  • 易语言学习进阶WHERE子句源码
  • HAVING子句与WHERE子句的区别

    千次阅读 2014-08-07 21:01:24
    HAVING子句用于筛选组,而WHERE子句用于筛选记录。
  • PHP MySQL Where 子句

    千次阅读 2011-07-29 13:28:10
    如需选取匹配指定条件的数据,请向 SELECT 语句添加 WHERE 子句WHERE 子句如需选取匹配指定条件的数据,请向 SELECT 语句添加 WHERE 子句。语法SELECT column FROM table WHERE column operator value下
  • Oracle 过滤(where子句

    千次阅读 2019-03-07 19:04:04
    过滤:使用WHERE 子句,将不满足条件的行过滤掉。Where子句紧随from子句语句
  • SQL Where 子句

    千次阅读 2007-03-30 11:05:00
    The WHERE clause is used to specify a selection criterion.WHERE子句可以规定选择的依据(符合要求才会选中)WHERE 子句To conditionally select data from a table, a WHERE clause can be added to the SELECT ...
  • Where子句常用查询条件

    千次阅读 2020-01-08 16:38:03
    IN:IN 操作符允许我们在 WHERE 子句中规定多个值。 LIKE:LIKE 操作符用于在 WHERE 子句中搜索列中的指定模式,一般通配符使用,详情点击:通配符 IS NULL:条件字段内容不为空 EXISTS:用于检查子查询是否至少...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 213,724
精华内容 85,489
关键字:

where子句的内容是