python基础---sql语句

数据库系统：

数据库：文件夹

数据表：文件

表记录：一条数据

sql语句规范

sql是Structured Query Language(结构化查询语言)的缩写。SQL是专为数据库而创建的操做命令集，是一种功能齐全的数据库语言

<1> 在数据库系统中，SQL语句不区分大小写(建议用大写) 。但字符串常量区分大小写。建议命令大写，表名库名小写；

<2> SQL语句可单行或多行书写，以“;”结尾。关键词不能跨多行或简写。

<3> 用空格和缩进来提升语句的可读性。子句一般位于独立行，便于编辑，提升可读性。

1 2	SELECT * FROM tb_table             WHERE NAME="YUAN";

<4> 注释：

单行注释：--

多行注释：/*......*/

<5>sql语句能够折行操做

 

1、mysql的经常使用sql语句：

a.库的操做

1.建立数据库：

create database 库名 [character set utf8（指定字符集，不加默认为拉丁文）];

 

2.查看数据库

show databases;     查看全部数据库

show create database 库名; 查看数据库的建立信息

use 库名;         切换到指定数据库

select database();    查看当前所在的库

 

3.修改数据库（修改字符集）

alter database 库名 [character set utf8（指定字符集，不加默认为拉丁文）];

 

4.删除数据库

drop database 库名;

 

b.表的操做

1.建立表

create table 表名 (

字段 类型[完整性约束条件],

字段 类型[完整性约束条件]

);

 

2.查看表信息

show tables;           查看当前库中全部的表

show create table 表名; 查看表的建表语句

desc 表名;  查看表结构

show columns from 表名;    同上，查看表结构

 

3.修改表结构

alter table 表名(

add 字段 类型[完整性约束条件] [first|after 字段名],          #增长字段

modify 字段 类型[完整性约束条件] [first|after 字段名],     #修改字段类型

change 旧字段 新字段 类型[完整性约束条件][first|after 字段名] #修改字段名

drop 字段;    #删除一列字段

);

rename table 旧表名 to 新表名; 修改表名

 

4.删除表

drop table 表名;      删除表

 

c.表记录的操做

1.增长表记录

增长一条记录：

insert [into] 表名 (字段1,字段2,…) values (值1,值2,…);

增长多条：

insert [into] 表名 (字段1,字段2,…) values (值1,值2,…),

                                     (值1,值2,…),

                                  ……            ;

set插入：

insert [into] 表名 set 字段1=值2,字段2=值2;

 

2.修改表记录

update 表名 set 字段1=值1  where子句

 

3.删除表记录

delete from 表名  where 子句;

 

清空表内全部记录有两种方法：

方式1：

delete from 表名;

方式2：

truncate table 表名;

对比：

delete语句只能删除表中的内容，不能删除表自己，想要删除表，用drop

truncate也能够删除表中的全部数据，语句首先会摧毁表，再新建表，此种方式删除的数据不能在事务中恢复，数据量大时推荐使用

 

4.查询表记录

select * from 表名;        #显示全部的记录信息

 

 

select 字段1,字段2,… from 表名

where 子句  #过滤查询

group by 字段         #分组查询

having   子句           #过滤

order by 字段          #排序

limit                 #记录条数限制

Mysql在执行sql语句时的执行顺序：

from >  where  >  select  > group by  >  having  >  orderby

 

(1)where 子句：

比较运算符：

                        > < >= <=<> !=

                        between 80 and 100 值在10到20之间

                        in(80,90,100) 值是10或20或30

                        like 'yuan%'   （%后面能够接_，表明匹配一个字符，能够接多个）

逻辑运算符

                        在多个条件直接可使用逻辑运算符 and or not

(2)group by 字段：

GROUP BY 语句根据某个列对结果集进行分组,在分组的列上咱们可使用聚合函数进行相关查询

count    计数

sum      总数值

avg 平均值

max      最大值

min 最小值

 

(3)having 子句

过滤

与where 子句的区别：

在sql语句中，二者的书写顺序和执行顺序不同，where写在前面，先执行，having写在后面，后执行，having适用于对查询结果的二次过滤

(4)order by 字段

按指定的列进行排序，排序的列便可是表中的列名，也能够是select语句后指定的别名

语法：select*|field1,field2... from tab_name order by field [Asc|Desc]

 

        -- Asc 升序、Desc 降序，其中asc为默认值 ，ORDER BY 子句应位于SELECT语句的结尾。

(5)limit记录条数限制

(6)正则表达式

 

练习：

先建立一个员工表：

create table emp(

   id       int primary keyauto_increment,

   name     varchar(20),

   gender  enum("male","female","other"),

   age      tinyint,

   dep      varchar(20),

   city     varchar(20),

  salary    double(7,2)

);

 

表内插入信息：

insert into emp(name,gender,age,dep,city,salary) values

               ("yuan","male",24,"教学部","河北省",8000),

               ("egon","male",34,"保安部","山东省",8000),

               ("alex","male",28,"×××部","山东省",10000),

                ("景丽阳","female",22,"教学部","北京",9000),

                ("张三", "male",24,"教学部","河北省",6000),

                ("李四", "male",32,"保安部","北京",12000),

                ("王五", "male",38,"教学部","河北省",7000),

                ("赵六", "male",19,"保安部","河北省",9000),

                ("猪七", "female",24,"×××部","北京",9000);

 

查看表记录信息：

mysql> select * from emp;

+----+--------+--------+------+--------+--------+----------+

| id | name   | gender | age  | dep   | city   | salary   |

+----+--------+--------+------+--------+--------+----------+

|  1| yuan   | male   |   24| 教学部 | 河北省 | 8000.00 |

|  2| egon   | male   |   34| 保安部 | 山东省 | 8000.00 |

|  3| alex   | male   |   28| ×××部 | 山东省 | 10000.00 |

|  4| 景丽阳 | female|   22 | 教学部 | 北京   | 9000.00 |

|  5| 张三   | male  |   24 | 教学部 | 河北省 |  6000.00 |

|  6| 李四   | male  |   32 | 保安部 | 北京   | 12000.00 |

|  7| 王五   | male  |   38 | 教学部 | 河北省 |  7000.00 |

|  8| 赵六   | male  |   19 | 保安部 | 河北省 |  9000.00 |

|  9| 猪七   | female |  24 | ×××部 | 北京  |  9000.00 |

+----+--------+--------+------+--------+--------+----------+

 

查询语句实例：

查询全部name、salary字段的值

select name,salary from emp;

查询全部name、salary字段的值并设置别名

select name as 姓名,salary as 薪水 from emp;    #as能够省略不写

1. where 子句

查询全部年龄大于20的：

select * from emp where age>20;

查询全部年龄大于20的name、salary：

select name,salary from emp whereage>20;

查询全部年龄除以10大于2的name、age:

select name,age from emp where age/10>2;

查询全部年龄在20到30岁之间的name、age：

select name,age from emp where age between20 and 30;  #闭区间，包含20和30

查询全部姓张的name、age：

select name,age from emp where name like"张%";

查询全部性别为male且年龄大于25的name、age：

select name,age from emp wheregender="male" and age>25;

 

2.group by 字段

查询每一个部门的人数：

select dep,count(*) from emp group by dep;

查询每一个部门里的最高工资：

select dep,max(salary) from emp group bydep;

查询男生、女生的人数：

select gender,count(*)  from emp group by gender;

查询每一个省份的最高工资：

select city,avg(salary) from emp group bycity;

 

3.having 子句：

查询平均工资大于8000的省份：

select city,avg(salary) from emp group bycity having avg(salary)>8000;

 

4.order by

按员工薪资从低到高排序：

select * from emp order by salary;

按员工薪资从高到低排序：

select * from emp order by salary desc;

 

5.limit

查询表内前5条记录：

select * from emp limit 5;

查询第2条记录之后的3条记录：

select * from emp limit 2,3;        #不包含第2条

 

2、多表查询

建立练习表：

首先建立员工表emp：

create table emp(

   id int primary key auto_increment,

   name varchar(20),

   salary double(7,2),

   dep_id int

);

插入员工信息（dep_id对应dep表中的id）：

insert into emp (name,salary,dep_id) values("张三",8000,2),

                           ("李四",12000,1),

                           ("王五",5000,2),

                          ("赵六",8000,3),

                           ("猪七",9000,1),

                          ("周八",7000,4),

                          ("蔡九",7000,2);

 

建立部门表dep：

create table dep(

     id int primary key auto_increment,

     name varchar(20)

);

插入部门信息：

insert into dep (name) values ("教学部"),

                              ("销售部"),

                              ("人事部");

 

笛卡尔积查询：

mysql> select * from emp,dep;

+----+------+----------+--------+----+--------+

| id | name | salary   | dep_id | id | name   |

+----+------+----------+--------+----+--------+

|  1| 张三 |  8000.00 |     2 |  1 | 教学部 |

|  1| 张三 |  8000.00 |     2 |  2 | 销售部 |

|  1| 张三 |  8000.00 |     2 |  3 | 人事部 |

|  2| 李四 | 12000.00|      1 |  1 | 教学部 |

|  2| 李四 | 12000.00|      1 |  2 | 销售部 |

|  2| 李四 | 12000.00|      1 |  3 | 人事部 |

|  3| 王五 |  5000.00 |     2 |  1 | 教学部 |

|  3| 王五 |  5000.00 |     2 |  2 | 销售部 |

|  3| 王五 |  5000.00 |     2 |  3 | 人事部 |

|  4| 赵六 |  8000.00 |     3 |  1 | 教学部 |

|  4| 赵六 |  8000.00 |     3 |  2 | 销售部 |

|  4| 赵六 |  8000.00 |     3 |  3 | 人事部 |

|  5| 猪七 |  9000.00 |     1 |  1 | 教学部 |

|  5| 猪七 |  9000.00 |     1 |  2 | 销售部 |

|  5| 猪七 |  9000.00 |     1 |  3 | 人事部 |

|  6| 周八 |  7000.00 |     4 |  1 | 教学部 |

|  6| 周八 |  7000.00 |     4 |  2 | 销售部 |

|  6| 周八 |  7000.00 |     4 |  3 | 人事部 |

|  7| 蔡九 |  7000.00 |     2 |  1 | 教学部 |

|  7 |蔡九 |  7000.00 |     2 |  2 | 销售部 |

|  7| 蔡九 |  7000.00 |     2 |  3 | 人事部 |

+----+------+----------+--------+----+--------+

21 rows in set (0.00 sec)

 

a.内链接查询

select  * from 表1 inner join 表2 on 子句

inner join(等值链接) 只返回两个表中联结字段相等的行

查询两张表中都有的关联数据,至关于利用条件从笛卡尔积结果中筛选出了正确的结果

查询张三所在的部门：

select emp.name,dep.name from emp,dep whereemp.dep_id=dep.id and emp.name="张三";

或者

mysql> select emp.name,dep.name from empinner join dep on emp.dep_id=dep.id where emp.name="张三";

 

b.外链接查询
left join(左联接) 返回包括左表中的全部记录和右表中联结字段相等的记录

right join(右联接) 返回包括右表中的全部记录和左表中联结字段相等的记录

 

以左表为主，打印出全部信息（包含左表的全部记录）：

select * from emp left join dep onemp.dep_id=dep.id order by emp.id;

以右表为主，打印出全部信息（包含右表的全部记录）：

select * from emp right join dep onemp.dep_id=dep.id order by emp.id;

 

3、完整性约束

完整性约束是对字段进行限制，从而符合该字段达到咱们指望的效果好比字段含有默认值，不能是NULL等 。直观点说：若是插入的数据不知足限制要求，数据库管理系统就拒绝执行操做

a. 惟一约束

能够有多个但索引列的值必须惟一，索引列的值容许有空值

若是能肯定某个数据列将只容许包含不相同的值，在为这个数据列建立索引的时候就应该使用关键字unique

 

在建表时添加惟一约束：

create table 表名(

 id   int auto_increment,          #id字段设置自增

  namevarchar(20) default null,

 primary key (id),              #id字段设置为主键

 unique key 索引别名 (name)   #name设置为惟一索引

);

 

在建表后添加惟一约束:

alter table 表名 add constraint 索引别名 unique (name);

 

若是不须要惟一约束，则能够这样删除

alter table 表名 drop index 索引别名;

 

b.自增约束

MySQL 每张表只能有1个自动增加字段，这个自动增加字段一般做为主键，也能够用做非主键使用，可是请注意将自动增加字段当作非主键使用时必须为其添加惟一索引，不然系统将会报错

create table 表名(

id int not null,

namevarchar(20),

age int uniqueauto_increment #把age字段设置为自增字段和惟一索引

);

 

c.主键约束

主键是用于惟一标识一条记录的约束，如同×××

主键有两个约束：非空且惟一

建表时添加主键的两种方式：

方式1：

create table 表名(

字段 类型 primary key auto_increment,    #设置字段为主键且自增

字段 类型

);

 

方式2：

create table 表名(

字段 类型 not null,

字段 类型

);

 

建表后添加主键：

alter table 表名 add primary key(字段名)

 

设置主键注意：

1、一张表中最多只能有一个主键

2、表中若是没有设置主键，默认设置NOT NULL的字段为主键；此外，表中若是有多个NOT NULL的字段，则按顺序将第一个设置NOT NULL的字段设为主键。

主键必定是非空且惟一，但非空且惟一的字段不必定是主键。

3、主键类型不必定必须是整型

 

删除主键：

alter table 表名 drop primary key;

删除主键注意：

若是主键是auto_increment，须要先取消auto_increment，由于auto_increment只能加在key上

create table 表名(字段 类型 primary key auto_increment);

alter table 表名 modify 字段 类型;          #删除自增，主键依然存在

alter table 表名 drop primary key;          #删除主键

 

复合主键：

复合主键 就是指表的主键含有一个以上的字段

若是一列不能惟一区分一个表里的记录时，能够考虑多个列组合起来达到区分表记录的惟一性

建立复合主键：

create table 表名 (

      字段1 int,

      字段2 int,

      字段3 int,

primary key (字段1,字段2)

); 

修改复合主键：

alter table 表名 add primary key (字段1,字段2,字段3);

 

d.外键约束

外键的定义语法：

[constraint symbol] foreign key [id](index_col_name, ...)

                    references tbl_name(index_col_name, ...)

[on delete {restrict | cascade | set null | no action | set default}]

    [on update {restrict | cascade | set null | no action | set default}]

 

 

 

表关系：

表与表之间的关系（两张表）：

一对多

将关联字段设置在多的表中（多）

有外键的叫子表，没有外键的叫主表

 

多对多

两表彼此一对多，就是多对多的关系

借助第三张表来实现

 

一对一

能够将关联字段设在任意一张表上，但约束必须为unique