• python之路--MySQl单表查询


     一.  关键字的执行优先级(重点)

    from
    where
    group by
    having  # 使用是要放在group by 后面而且前面必须有group by
    select
    distinct  # 去重 要放在字段的前面,而且字段只能有一个
    order by  # 排序,默认升序, order by desc 是降序
    limit  #  后面写多少就显示多少条数
    
    关键字执行优先级

    二 .  简单查询

    #我们来创建一个员工表,然后对员工表进行一个简单的查询,来看一下效果,下面是员工表的字段
    company.employee
        员工id      id                  int             
        姓名        emp_name            varchar
        性别        sex                 enum
        年龄        age                 int
        入职日期     hire_date           date
        岗位        post                varchar
        职位描述     post_comment        varchar
        薪水        salary              double
        办公室       office              int
        部门编号     depart_id           int
    
    
    
    #创建表
    create table employee(
        id int not null unique auto_increment,
        name varchar(20) not null,
        sex enum('male','female') not null default 'male', #大部分是男的
        age int(3) unsigned not null default 28,
        hire_date date not null,
        post varchar(50),
        post_comment varchar(100),
        salary double(15,2),
        office int, #一个部门一个屋子
        depart_id int
    );
    
    
    #查看表结构
    mysql> desc employee;
    +--------------+-----------------------+------+-----+---------+----------------+
    | Field        | Type                  | Null | Key | Default | Extra          |
    +--------------+-----------------------+------+-----+---------+----------------+
    | id           | int(11)               | NO   | PRI | NULL    | auto_increment |
    | name         | varchar(20)           | NO   |     | NULL    |                |
    | sex          | enum('male','female') | NO   |     | male    |                |
    | age          | int(3) unsigned       | NO   |     | 28      |                |
    | hire_date    | date                  | NO   |     | NULL    |                |
    | post         | varchar(50)           | YES  |     | NULL    |                |
    | post_comment | varchar(100)          | YES  |     | NULL    |                |
    | salary       | double(15,2)          | YES  |     | NULL    |                |
    | office       | int(11)               | YES  |     | NULL    |                |
    | depart_id    | int(11)               | YES  |     | NULL    |                |
    +--------------+-----------------------+------+-----+---------+----------------+
    
    #插入记录
    #三个部门:教学,销售,运营
    insert into employee(name,sex,age,hire_date,post,salary,office,depart_id) values
    ('egon','male',18,'20170301','老男孩驻沙河办事处外交大使',7300.33,401,1), #以下是教学部,全都是老师
    ('alex','male',78,'20150302','teacher',1000000.31,401,1),
    ('wupeiqi','male',81,'20130305','teacher',8300,401,1),
    ('yuanhao','male',73,'20140701','teacher',3500,401,1),
    ('liwenzhou','male',28,'20121101','teacher',2100,401,1),
    ('jingliyang','female',18,'20110211','teacher',9000,401,1),
    ('jinxin','male',18,'19000301','teacher',30000,401,1),
    ('成龙','male',48,'20101111','teacher',10000,401,1),
    
    ('歪歪','female',48,'20150311','sale',3000.13,402,2),#以下是销售部门
    ('丫丫','female',38,'20101101','sale',2000.35,402,2),
    ('丁丁','female',18,'20110312','sale',1000.37,402,2),
    ('星星','female',18,'20160513','sale',3000.29,402,2),
    ('格格','female',28,'20170127','sale',4000.33,402,2),
    
    ('张野','male',28,'20160311','operation',10000.13,403,3), #以下是运营部门
    ('程咬金','male',18,'19970312','operation',20000,403,3),
    ('程咬银','female',18,'20130311','operation',19000,403,3),
    ('程咬铜','male',18,'20150411','operation',18000,403,3),
    ('程咬铁','female',18,'20140512','operation',17000,403,3)
    ;
    
    #ps:如果在windows系统中,插入中文字符,select的结果为空白,可以将所有字符编码统一设置成gbk

      查询操作

    简单查询
        SELECT id,name,sex,age,hire_date,post,post_comment,salary,office,depart_id 
        FROM employee;
    
        SELECT * FROM employee; #不推荐用* ,查询的时候*的效率低,至于为什么低,后面会讲到,先知道一下就行了
    
        SELECT name,salary FROM employee;
    
    #避免重复DISTINCT
       SELECT post FROM employee;#直接这样查询我们会看到很多重复的内容,我只想看一下有哪些职位,那么多重复的内容是没用的,所以我们加一个去重的功能,叫做distinct 
      SELECT DISTINCT post FROM employee;  #对查询出来的记录进行去重,如果post职位有重复的,就会被剔除,剩下不重复的内容,注意,因为我们查询出来的记录里面只有一个字段post,才会根据post来进行去重
       SELECT DISTINCT post,salary FROM employee;#但是如果这样写,你会发现,貌似没有起到根据post来去重的效果,因为你的去重条件变成了post和salary两个字段的数据,只有他俩合起来是一个重复记录的时候才会去重   
       
      看一下下面这两句的效果就明白了:注意一点,使用distinct对记录进行去重的时候,distinct必须写在所有查询字段的前面,不然会报错,当然有些特别的用法可以结合着写到字段的中间或者后面,这个后面学到了我们再说
       select post,sex from employee;
       select distinct post,sex from employee;
    
    #通过四则运算查询
        SELECT name, salary*12 FROM employee; #查询每个人的年薪,月薪我们有记录,查年薪呢?简单的乘以12就可以了,from 库.表的时候,我们已经通过use 库名;来指定了库了,所以from的时候直接写from 表,就行了
        #你会发现,结果是出来了,但是我们的那个薪资的字段名变成了salary*12,是因为我们通过查询语句查询出来的也是一张表,但是这个表是不是内存当中的一个虚拟表,并不是我们硬盘中存的那个完整的表,对吧,虚拟表是不是也有标题和记录啊,既然是一个表,我们是可以指定这个虚拟表的标题的,通过as+新字段名来指定
    
        SELECT name, salary*12 AS Annual_salary FROM employee; #as + 新字段名,就是起一个别名的意思,上面的那个salary*12的字段名也是一个别名,只不过不直观,是mysql自动给你写上的
        SELECT name, salary*12 Annual_salary FROM employee;
      #除了乘法以外,加减乘除都是可以的
    
    
    #自定义显示格式,自己规定查询结果的显示格式
       CONCAT() 函数用于连接字符串
       SELECT CONCAT('姓名: ',name,'  年薪: ', salary*12)  AS Annual_salary  #我想让name这个字段显示的字段名称是中文的姓名,让salary*12显示的是中文的年薪,
       FROM employee;#看结果:通过结果你可以看出,这个concat就是帮我们做字符串拼接的,并且拼接之后的结果,都在一个叫做Annual_salary的字段中了
        +---------------------------------------+
        | Annual_salary                              |
        +---------------------------------------+
        | 姓名: egon  年薪: 87603.96            |
        | 姓名: alex  年薪: 12000003.72         |
        | 姓名: wupeiqi  年薪: 99600.00         |
        | 姓名: yuanhao  年薪: 42000.00         |
        .....
           +---------------------------------------+
       SELECT CONCAT('姓名: ',name,'  年薪: ', salary*12)  AS Annual_salary,CONCAT('性别:',sex) from employee;#还可以这样分成两列  
    
    
       CONCAT_WS() 第一个参数为分隔符来进行字符串拼接
       SELECT CONCAT_WS(':',name,salary*12)  AS Annual_salary  #通过冒号来将name和salary连接起来
       FROM employee;
       #上面这个效果我们也可以通过concat来实现:SELECT CONCAT(name,':',salary*12)  AS Annual_salary from employee;
       结合CASE语句:结合条件来对查询的结果进行一些加工操作
       SELECT
           (
               CASE
               WHEN NAME = 'egon' THEN
                   NAME
               WHEN NAME = 'alex' THEN
                   CONCAT(name,'_BIGSB')
               ELSE
                   concat(NAME, 'SB')
               END
           ) as new_name,sex
       FROM
           employee;
    
    #看结果:
        +--------------+--------+
        | new_name   | sex      |
        +--------------+--------+
        | egon            | male   |
        | alex_BIGSB   | male   |
        | wupeiqiSB     | male   |
        | yuanhaoSB    | male   |
        | liwenzhouSB  | male   |
        | jingliyangSB  | female |
        | jinxinSB        | male   |
        | 成龙SB          | male   |
        ...
        +--------------+

    三 . where约束

      where语句中可以使用:

        之前我们用where 后面跟的语句是不是id=1这种类型的啊,用=号连接的,除了=号外,还能使用其他的,看下面:

        1. 比较运算符:> < >= <= <> !=
        2. between 80 and 100 值在80到100之间
        3. in(80,90,100) 值是80或90或100
        4. like 'egon%'
          pattern可以是%或_,
          %表示任意多字符
          _表示一个字符
        5. 逻辑运算符:在多个条件直接可以使用逻辑运算符 and or not

    #1:单条件查询
        SELECT name FROM employee
            WHERE post='sale';  #注意优先级,我们说where的优先级是不是比select要高啊,所以我们的顺序是先找到这个employee表,然后按照post='sale'的条件,然后去表里面select数据
            
    #2:多条件查询
        SELECT name,salary FROM employee 
            WHERE post='teacher' AND salary>10000;
    
    #3:关键字BETWEEN AND 写的是一个区间
        SELECT name,salary FROM employee 
            WHERE salary BETWEEN 10000 AND 20000; #就是salary>=10000 and salary<=20000的数据
    
        SELECT name,salary FROM employee 
            WHERE salary NOT BETWEEN 10000 AND 20000; #加个not,就是不在这个区间内,薪资小于10000的或者薪资大于20000的,注意没有等于,
        
    #4:关键字IS NULL(判断某个字段是否为NULL不能用等号,需要用IS) 判断null只能用is
        SELECT name,post_comment FROM employee 
            WHERE post_comment IS NULL;
    
        SELECT name,post_comment FROM employee 
            WHERE post_comment IS NOT NULL;
            
        SELECT name,post_comment FROM employee 
            WHERE post_comment=''; 注意''是空字符串,不是null,两个是不同的东西,null是啥也没有,''是空的字符串的意思,是一种数据类型,null是另外一种数据类型
        ps:
            执行
            update employee set post_comment='' where id=2;
            再用上条查看,就会有结果了
    
    #5:关键字IN集合查询
        SELECT name,salary FROM employee 
            WHERE salary=3000 OR salary=3500 OR salary=4000 OR salary=9000 ; #这样写是不是太麻烦了,写一大堆的or,下面我们用in这个简单的写法来搞
        
        SELECT name,salary FROM employee 
            WHERE salary IN (3000,3500,4000,9000) ;
    
        SELECT name,salary FROM employee 
            WHERE salary NOT IN (3000,3500,4000,9000) ;
    
    #6:关键字LIKE模糊查询,模糊匹配,可以结合通配符来使用
        通配符’%’  #匹配任意所有字符
        SELECT * FROM employee 
                WHERE name LIKE 'eg%';
    
        通配符’_’  #匹配任意一个字符   
        SELECT * FROM employee 
                WHERE name LIKE 'al__'; #注意我这里写的两个_,用1个的话,匹配不到alex,因为al后面还有两个字符ex。

      练习题

    1. 查看岗位是teacher的员工姓名、年龄
    2. 查看岗位是teacher且年龄大于30岁的员工姓名、年龄
    3. 查看岗位是teacher且薪资在9000-1000范围内的员工姓名、年龄、薪资
    4. 查看岗位描述不为NULL的员工信息
    5. 查看岗位是teacher且薪资是10000或9000或30000的员工姓名、年龄、薪资
    6. 查看岗位是teacher且薪资不是10000或9000或30000的员工姓名、年龄、薪资
    7. 查看岗位是teacher且名字是jin开头的员工姓名、年薪
    select name,age from employee where post = 'teacher';
    select name,age from employee where post='teacher' and age > 30; 
    select name,age,salary from employee where post='teacher' and salary between 9000 and 10000;
    select * from employee where post_comment is not null;
    select name,age,salary from employee where post='teacher' and salary in (10000,9000,30000);
    select name,age,salary from employee where post='teacher' and salary not in (10000,9000,30000);
    select name,salary*12 from employee where post='teacher' and name like 'jin%';
    答案

    四 . 分组查询

    #1、首先明确一点:分组发生在where之后,即分组是基于where之后得到的记录而进行的
    
    #2、分组指的是:将所有记录按照某个相同字段进行归类,比如针对员工信息表的职位分组,或者按照性别进行分组等
    
    #3、为何要分组呢?是因为我们有时候会需要以组为单位来统计一些数据或者进行一些计算的,对不对,比方说下面的几个例子
        取每个部门的最高工资  
        取每个部门的员工数
        取男人数和女人数  
    
        小窍门:‘每’这个字后面的字段,就是我们分组的依据,只是个小窍门,但是不能表示所有的情况,看上面第三个分组,没有''字,这个就需要我们通过语句来自行判断分组依据了
        我们能用id进行分组吗,能,但是id是不是重复度很低啊,基本没有重复啊,对不对,这样的字段适合做分组的依据吗?不适合,对不对,依据性别分组行不行,当然行,因为性别我们知道,是不是就两种啊,也可能有三种是吧,这个重复度很高,对不对,分组来查的时候才有更好的意义
      
    #4、大前提:
        可以按照任意字段分组,但是分组完毕后,比如group by post,只能查看post字段,如果想查看组内信息,需要借助于聚合函数
    
    #注意一点,在查询语句里面select 字段 from 表,这几项是必须要有的,其他的什么where、group by等等都是可有可无的

      1 group by

    单独使用GROUP BY关键字分组
        SELECT post FROM employee GROUP BY post;
        注意:我们按照post字段分组,那么select查询的字段只能是post,想要获取组内的其他相关信息,需要借助函数
    
    GROUP BY关键字和GROUP_CONCAT()函数一起使用,比如说我想按部门分组,每个组有哪些员工,都显示出来,怎么搞
        SELECT post,GROUP_CONCAT(name) FROM employee GROUP BY post;#按照岗位分组,并查看组内所有成员名,通过逗号拼接在一起
        SELECT post,GROUP_CONCAT(name,':',salary) as emp_members FROM employee GROUP BY post;
    
    GROUP BY一般都会与聚合函数一起使用,聚合是什么意思:聚合就是将分组的数据聚集到一起,合并起来搞事情,拿到一个最后的结果
        select post,count(id) as count from employee group by post;#按照岗位分组,并查看每个组有多少人,每个人都有唯一的id号,我count是计算一下分组之后每组有多少的id记录,通过这个id记录我就知道每个组有多少人了
    
    关于集合函数,mysql提供了以下几种聚合函数:count、max、min、avg、sum等,上面的group_concat也算是一个聚合函数了,做字符串拼接的操作

      2 聚合函数

    #强调:聚合函数聚合的是组的内容,若是没有分组,则默认一组
    
    示例:
        SELECT COUNT(*) FROM employee;  #count是统计个数用的
        SELECT COUNT(*) FROM employee WHERE depart_id=1;  #后面跟where条件的意思是统计一下满足depart_id=1这个的所有记录的个数
        SELECT MAX(salary) FROM employee;  #max()统计分组后每组的最大值,这里没有写group by,那么就是统计整个表中所有记录中薪资最大的,薪资的值
        SELECT MIN(salary) FROM employee;
        SELECT AVG(salary) FROM employee;
        SELECT SUM(salary) FROM employee;
        SELECT SUM(salary) FROM employee WHERE depart_id=3;

      3 小练习

    1. 查询岗位名以及岗位包含的所有员工名字
    #通过上面的需求来整理逻辑:a、先看一下和哪个表有关系:所有的信息都在employee这个表里面,所以先写from employee,找到表了
    #                      b、看有没有什么过滤条件,大于小于啊什么的,没有吧,所以是不是不需要写where条件啊
    #                      c、看看有没有分组的内容,也就是看看上面的需求里面有没有分类的概念,发现是不是有啊,按照岗位来分组,对不对,所以该写什么了:from employee group by post;
    #                      d、然后再看需要查什么字段出来,发现是不是要看岗位名和所有员工的名字啊,所以怎么写:select post,group_concat(name) from employee group by post;这就是完整语句了,不信你试试
    
    下面的题都按照上面这个逻辑来搞一搞:
    2. 查询岗位名以及各岗位内包含的员工个数
    3. 查询公司内男员工和女员工的个数
    4. 查询岗位名以及各岗位的平均薪资
    5. 查询岗位名以及各岗位的最高薪资
    6. 查询岗位名以及各岗位的最低薪资
    7. 查询男员工与男员工的平均薪资,女员工与女员工的平均薪资。 #这道题我们自己提炼一下分组依据,是不是就是性别啊
    
    #总结:先from打开文件,然后按照where后面的条件,将硬盘的数据读到内存,内存中的到一张虚拟表,然后按照虚拟表来进行group by分组。group by 必须写在where条件之后,写在where之前会报错,语法规定的
    #我们说聚合函数是跟着分组来的,你看这样一句话:select max(salary) from employee;直接也是可以使用聚合函数的,因为没有where,那么默认是表中所有的数据,没有group by,默认整个表是一组
    
    8.统计各部门年龄在30岁及以上的员工平均薪资
    #想一下怎么写,1、from 表  2、where age>=30得到一张虚拟表 3、对虚拟表按部门group by  4、select 部门和聚合函数avg
    #答案:select post,avg(salary) from employee where age>=30 group by post;
    #看结果:
        mysql> select post,avg(salary) from employee where age>=30 group by post;#因为有的部门里面的员工没有大于30岁的,所以没有显示出所有的部门
        +---------+---------------+
        | post    | avg(salary)   |
        +---------+---------------+
        | sale    |   2500.240000 |
        | teacher | 255450.077500 |
        +---------+---------------+
    rows in set (0.09 sec)
    到这里我们的group by就讲完了,看一下我们完整查询语句里面还有什么
    SELECT distinct 字段1,字段2... FROM 库名.表名 
                      WHERE 条件       
                      GROUP BY field(字段)   
                      HAVING 筛选      #过滤,过滤之后执行select后面的字段筛选,就是说我要确定一下需要哪个字段的数据,你查询的字段数据进行去重,然后在进行下面的操作
                      ORDER BY field(字段)   #将结果按照后面的字段进行排序
                      LIMIT 限制条数 
    注意:虽然语法里面我们先写的select,但是并不是先执行的select,按照mysql自己的规范来执行的下面关键字的优先级
      from
      where
      group by
      having
      select
      distinct
      order by
      limit
    #题1:分组
    mysql> select post,group_concat(name) from employee group by post;
    
    
    #题目2:
    mysql> select post,count(id) from employee group by post;
    
    
    #题目3:
    mysql> select sex,count(id) from employee group by sex;
    
    
    #题目4:
    mysql> select post,avg(salary) from employee group by post;
    
    
    #题目5
    mysql> select post,max(salary) from employee group by post;
    
    
    #题目6
    mysql> select post,min(salary) from employee group by post;
    
    
    #题目七
    mysql> select sex,avg(salary) from employee group by sex;
           
    答案

    五 . having 过滤

    having的语法格式和where是一模一样的,只不过having是在分组之后进行的进一步的过滤,where不能使用聚合函数,having是可以使用聚合函数的
    #!!!执行优先级从高到低:where > group by > having 
    #1. Where 发生在分组group by之前,因而Where中可以有任意字段,但是绝对不能使用聚合函数。
    
    #2. Having发生在分组group by之后,因而Having中可以使用分组的字段,无法直接取到其他字段,having是可以使用聚合函数

      having简单测试

    #来个需求:统计各部门年龄在30岁及以上的员工的平均薪资,并且保留平均工资大于10000的部门
    答案:select post,avg(salary) as new_sa from employee where age>=30 group by post having avg(salary) > 10000;
    看结果:
      +---------+-------------------+
      | post      | new_sa              |
      +---------+-------------------+
      | teacher  | 255450.077500 |
      +---------+-------------------+
    row in set (0.00 sec)
    然后我们看这样一句话:select * from employee having avg(salary) > 10000;
    只要一运行就会报错:
        mysql> select * from employee having avg(salary) > 10000;
        ERROR 1140 (42000): Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause
    是因为having只能在group by后面运行

      练习题

    1. 查询各岗位内包含的员工个数小于2的岗位名、岗位内包含员工名字、个数
    3. 查询各岗位平均薪资大于10000的岗位名、平均工资
    4. 查询各岗位平均薪资大于10000且小于20000的岗位名、平均工资
    #题1:
    mysql> select post,group_concat(name),count(id) from employee group by post having count(id) < 2;
    +-----------------------------------------+-----------------------+-----------+
    | post                                               | group_concat(name) | count(id) |
    +-----------------------------------------+------------------------+-----------+
    | 老男孩驻沙河办事处外交大使                 | egon                        |         1   |
    +-----------------------------------------+------------------------+-----------+
    
    #题目2:
    mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000;
    +-----------+------------------+
    | post         | avg(salary)       |
    +-----------+------------------+
    | operation |  16800.026000  |
    | teacher    | 151842.901429 |
    +-----------+------------------+
    
    #题目3:
    mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000 and avg(salary) <20000;
    +-----------+----------------+
    | post         | avg(salary)    |
    +-----------+----------------+
    | operation | 16800.026000 |
    +-----------+-----------------+
    答案

      distinct : 去重

        将查询的结果进行去重:select distinct post from employee; 注意distinct去重要写在查询字段的前面,不然会报错,关于distinct使用时的其他问题看下面的总结.

    有时需要查询出某个字段不重复的记录,这时可以使用mysql提供的distinct这个关键字来过滤重复的记录,但是实际中我们往往用distinct来返回不重复字段的条数(count(distinct id)),其原因是distinct只能返回他的目标字段,而无法返回其他字段,distinct 想写在其他字段后面需要配合聚合函数来写。
    
    mysql> select id,count(distinct post) from employee;
    ERROR 1140 (42000): Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause
    报错了:是因为distinct不能返回其他的字段,只能返回目标字段
    mysql> select count(distinct post) from employee;
    +----------------------+
    | count(distinct post) |
    +----------------------+
    |                           4 |
    +----------------------+
    row in set (0.00 sec)
    distinct的注意问题

    六 . 查询排序:order by

    按单列排序
        SELECT * FROM employee ORDER BY salary; #默认是升序排列
        SELECT * FROM employee ORDER BY salary ASC; #升序
        SELECT * FROM employee ORDER BY salary DESC; #降序
    
    按多列排序:先按照age升序,如果年纪相同,则按照薪资降序
        SELECT * from employee
            ORDER BY age, #注意排序的条件用逗号分隔
            salary DESC;

      练习题

    1. 查询所有员工信息,先按照age升序排序,如果age相同则按照hire_date降序排序
    2. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资升序排列
    3. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资降序排列
    #题目1
    mysql> select * from employee ORDER BY age asc,hire_date desc;
    
    #题目2 
    mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000 order by avg(salary) asc;
    #注意:查询语句的语法是固定上面这样写的,但是运行顺序是这样的:1、from  2、where  3、group by  4、having  5、select  6、distinct 7、order by  8、limit,我们下面要学的
    +-----------+---------------+
    | post         | avg(salary)   |
    +-----------+---------------+
    | operation |  16800.026000 |
    | teacher    | 151842.901429 |
    +-----------+---------------+
    
    #题目3
    mysql> select post,avg(salary) from employee group by post having avg(salary) > 10000 order by avg(salary) desc;
    +-----------+---------------+
    | post         | avg(salary)   |
    +-----------+---------------+
    | teacher    | 151842.901429 |
    | operation |  16800.026000 |
    +-----------+---------------+
    答案

    七 . 限制查询的记录数:limit

    示例:
      #取出工资最高的前三位
        SELECT * FROM employee ORDER BY salary DESC 
            LIMIT 3;                    #默认初始位置为0,从第一条开始顺序取出三条 
        
        SELECT * FROM employee ORDER BY salary DESC
            LIMIT 0,5; #从第0开始,即先查询出第一条,然后包含这一条在内往后查5条 
    
        SELECT * FROM employee ORDER BY salary DESC
            LIMIT 5,5; #从第5开始,即先查询出第6条,然后包含这一条在内往后查5条   不够5条剩多少显示多少

    八 . 使用正则表达式查询

    #之前我们用like做模糊匹配,只有%和_,局限性比较强,所以我们说一个正则,之前我们是不是学过正则匹配,你之前学的正则表达式都可以用,正则是通用的
    SELECT * FROM employee WHERE name REGEXP '^ale';
    
    SELECT * FROM employee WHERE name REGEXP 'on$';
    
    SELECT * FROM employee WHERE name REGEXP 'm{2}';
    
    
    小结:对字符串匹配的方式
    WHERE name = 'egon';
    WHERE name LIKE 'yua%';
    WHERE name REGEXP 'on$';
  • 相关阅读:
    倍数求和
    最大(小)值
    数组扁平化:(多维数组 -> 一维数组)
    任意数求和
    找到重复最多项
    Linux 标准 I/O 库
    Linux文件操作函数
    Linux文件的IO操作 一
    Linux文件系统概述二
    Linux文件系统概述
  • 原文地址:https://www.cnblogs.com/attila/p/10284660.html
Copyright © 2020-2023  润新知