#方案1
> create table if not exists info.student(
name varchar(10),
gender varchar(10),
number varchar(10),
age int
)charset utf8;

#方案2
> use info;
> create table student(
name varchar(10),
gender varchar(10)
)charset utf8;

> show tables;
> show tables like ‘s%‘; --效率低

#查看建表语句
> show create table student;
> desc student;

#重命名表
> rename table student to my_student;
#修改表的字符集
> alter table my_student charset=GBK;

#添加一个字段ID到第一个位置
> alter table my_student add column id int first;
#将number学号字段变成固定长度，且放到第二位(id之后)
> alter table my_student modify number char(10) after id;
#重命名字段
> alter table my_student change gender sex varchar(10);
#删除字段
> alter table my_student drop age;

#插入数据
> insert into my_student(id,number,name,sex) values(1,‘001‘,‘tom‘,‘男‘),(2,‘002‘,‘jem‘,‘女‘);

> select * from my_student;
> update my_student set sex=‘female‘ where name=‘jem‘;
> delete from my_student where sex=‘男‘;

#查看服务器识别的字符集
> show character set;
#查看服务器默认的字符集
> show variables like ‘character_set%‘;
#修改服务器认为的客户端数据的字符集GBK
> set character_set_client=gbk;
#修改服务器给定数据的字符集为GBK
> set character_set_results=gbk;
#快捷设置字符集
> set names gbk;  ====>character_set_client,character_set_results,character_set_connection

#增加主键
> create table my_pril(
name varchar(20) not null comment ‘姓名‘,
number char(10) primary key comment ‘学号不能重复‘
)charset utf8;

#方案2 复合主键
> create table my_pril2(
number char(10) comment ‘学号‘,
course char(10) comment ‘课程代码‘,
score tinyint unsigned default 60 comment ‘成绩‘,
primary key(number,course)
)charset utf8;

#方案3
> create table my_pril3(
number char(10) not null comment ‘学号‘,
course char(10) not null comment ‘课程代码‘
)charset utf8;
alter table my_pril3 modify course char(10) primary key comment ‘‘;
或 alert table my_pril3 add primary key(course);

#删除和更新主键
> alter table my_pril3 drop primary key;

#主键自动增长
> create table my_student(
id int primary key auto_increment comment ‘逻辑主键‘,
number char(10) not null,
name varchar(10) not null
)charset utf8;

#修改主键 -- 只能向下修改
> alter table my_auto auto_increment=10;

#查看自增长变量
> show variables like ‘auto_increment%‘;
#删除自增长
> alter table my_auto modify id int;

#唯一键  --默认允许自动为空，而且可以多个为空
> create table my_unique(
number char(10) unique comment ‘学号唯一，允许为空‘,
name varchar(20) not null
)charset utf8;

#方案2
> create table my_unique1(
number char(10) not null comment ‘学号‘,
name varchar(20) not null,
unique key(number)
)charset utf8;

#方案3
> create table my_unique2(
id int primary key auto_increment,
number char(10) not null comment ‘学号‘,
name varchar(20) not null,
)charset utf8;
alter table my_unique2 add unique key(number);

#更新唯一键，删除唯一键  -- 先删除后新增
> alter table my_unique2 drop index number;

#索引  --提升查询数据的效率，约束数据的有效性
#经常作为查询的条件
mysql中提供了多种索引
1.主键索引：primary key
2.唯一索引：unique key
3.全文索引：fulltext index --根据文章内部的关键字进行索引(分词)，问题：如何确定关键字
4.普通索引：index

#主键冲突  --更新和替换
> insert into my_class values(‘php‘,‘b203‘) on duplicate key update room=‘b201‘;
> replace into my_class values(‘php‘,‘111‘);

#蠕虫复制
从已有的数据中获取数据，然后将数据有进行新增操作，数据成倍的增加
表创建高级操作：从已有表创建新表(复制表结构)
> create table my_copy like my_gbk;
#蠕虫复制 --成倍增加
> insert into my_copy select * from my_set;
> insert into my_copy select * from my_copy;
#蠕虫的意义：
1.从已有表中拷贝数据到新表
2.可以迅速的让表中的数据膨胀到一定的数量级：测试表的压力以及效率

#更新数据
> update my_copy set name = ‘c‘ where name = ‘a‘ limit 3;
#删除数据
> delete from my_copy where name = ‘a‘ limit 10;
#先删除该表，后新增该表

#清空表：重置自增长
> truncate my_copy;

#查询数据
完整语法：
select[select 选项] 字段列表／* from 数据源 [where条件子句][group by 子句][having 子句][order by 子句][limit 子句]

[select选项]：
all:默认的，保留所有的结果
distinct:去重，查出来的结果，将重复的去除(所有字段都相同)
select distinct from my_copy;
#别名
select id,number as 学号,name as 姓名 from my_student;

数据源：--数据表
单表与多表数据源 --笛卡尔积(交叉连接)，尽量避免
> select * from my_student,my_class;

#子查询: --会临时建立表
> select * from (select * from my_student) as s;

#where子句：返回结果：0或者1，0代表false;1代表true
比较运算符：>,<,>=,<=,!=,<>,=,like,between and,in/not in
逻辑运算符：&&(and),||(or),!(not)
原理：where是唯一一个直接从磁盘获取数据的时候开始判断的条件，从磁盘取出一条记录，开始进行where判断，判断的结果如果成立保存到内存中，如果失败直接放弃
> select * from my_student where id in(1,2,4);
> select * from my_student where height between 170 and 190;
> select * from my_student where 1;--查询所有，保证sql语句的完整

#分组 --group by,默认升序(asc/desc)
> select * from my_studet group by sex;
意义是：统计数据，按分组字段进行数据统计
count()
max()
min()
avg():统计平均值
sum()
> select sex,count(*),max(height),min(height),avg(age),sum(age) from my_student group by sex desc;
#多字段分组
> select c_id,sex,count(*),group_concat(name) from my_student group by c_id,sex;

#回溯统计
> select c_id,count(*) from my_student group by c_id with rollup;
#多字段回溯统计
> select c_id,sex,count(*),group_concat(name) from my_student group by c_id,sex with rollup;


#having 子句 --进行条件判断，进入内存之后，进行分组操作
> select c_id,count(*) as total from my_student group by c_id having total>=2;

#order by 排序，依赖校对集
多字段排序
> select * from my_student order by c_id,sex desc;

#limit 子句,限制数量
> select * from my_student limit 4,2;  -- 从4条开始找两条，实现分页
offset=(页面-1)*每页显示量

#连接查询
连接查询分类：
内连接、外连接、自然连接、交叉连接(形成的结果是笛卡尔积)

#交叉连接 --尽量避免
> select * from my_student cross join my_class;
#内连接 --where没有on效率高
> select * from my_student inner join my_class on my_student.c_id=my_class.id; --查出会有相同的字段，需要用别名

#外左连接
> select s.*,c.name as c_name,c.room from my_student as s left join my_class as c on s.c_id = c.id  --记录数大于等于左表
#外右连接
> select s.*,c.name as c_name,c.room from my_student as s right join my_class as c on s.c_id = c.id  --记录数不小于右表

#自然内连接
> select * from my_student natural join my_class;  --自然连接自动使用同名字字段作为连接条件；连接之后会合并同名字段
#自然左外连接
> select * from my_student natural left join my_class; 


#创建外键
> create table my_foreign(
id int primary key auto_increment,
name varchar(20) not null,
c_id int,
foregin key(c_id) references my_class(id)
)charset utf8;
#增加外键
> create table my_foreign(
id int primary key auto_increment,
name varchar(20) not null,
c_id int,
)charset utf8;
> alter table my_foreign add 
constraint student_class 
foreign key(c_id) 
references my_class(id);
#删除外键 --查看创建语句，有没有真的删掉
> alter table my_foreign drop foreign key c_id;

#外键的约束
外键约束有三种约束模式 -- 都是针对父表的约束
    District:严格模式(默认的)，父表不能删除一个或着更新一个被子表数据引用的记录
    cascade:级联模式，父表的操作，对应子表关联的数据也跟着操作删除
    set null:制空模式，父表的操作之后，子表对应的数据(外键字段)被置空

通常的一个合理的做法(约束模式)：删除的时候，子表制空，更新的时候子表级联操作

#创建外键：指定模式：删除置空，更新级联
> create table my_forign(
id int primary key auto_increment,
name varchar(20) not null,
c_id int,
-- 增加外键
foreign key(c_id)
-- 引用表
references my_class(id)
-- 指定删除模式
on delete set null
-- 指定更新默认
on update cascade)charset utf8;


#联合查询 -- 将多次查询（多条select语句），在记录上进行拼接（字段不会增加），记录上会增加
union 选项：与select选项有两个
    all：保留所有（不管重复）
    distinct:去重复（整个重复）默认的

> select * from my_class  --只保留这个查询的字段
union all
select * from my_student
用处：
1、查询同一张表，需求不同；如查询学生信息，男生身高升序，女生身高降序
2、多表查询：多张表的结构式完全一样的，保存的数据（结构）也是一样的

> (select * from my_student where sex=‘男‘ order by age asc limit 99999999)
union --有order by必须扩起来
(select * from my_student where sex=‘女‘ order by age desc limit 99999999)


#子查询 --查询在某个查询结果之上进行
按位置分类：
    from子查询：子查询跟在from之后
    where子查询：子查询出现在where条件中
    exits子查询：子查询出现在exits里面 --是否存在，(跨表)，exists是接在where之后，exits返回的结果是0、1
    select * from my_student where exists(select * from my_class);
    
    
按结果分类：
    标量子查询：子查询得到的结果是一行一列
> select * from my_student where id=(select id from my_class where c_name=‘php1207‘);
    列子查询：子查询得到的结果是一列多行
> select * from my_student where c_id in(select id from my_class); --in等于=any等于=some；或！=in；   =all 等于全部所有结果
    行子查询：子查询得到的结果是多列一行（多行多列）
> select * from my_student where (age,height)=(select max(age),max(height) from my_student);
        上面几个出现的位置都是在where之后
    表子查询：子查询得到的结果是多行多列(出现的位置是在from之后)      
> select * from (select * from my_student order by height desc) as student group by c_id;



#视图 -- 实质就是封装了select语句

#创建单表视图
> create view my_v as select * from my_student;
#创建多表视图
> select view my_v as 
select s.*,c.c_name,c.room from my_student as s 
left join my_class c
on s.c_id=c.id;
#修改视图
> alter view my_v as select id,name,age,sex,height,c_id from my_student;
#删除视图
> drop view my_v;
#视图意义：
    1、节省sql语句，将一条复杂的查询语句使用视图进行保存，以后直接对视图进行操作
    2、数据安全，主要针对查询的，不影响基表数据
    3、视图在大项目，多系统使用；可以对外提供有效的数据，数据安全
    4、视图对外提供友好型；不同的视图提供不同的数据，对外好像专门设计
    5、视图能够更好的进行权限控制
    
#视图数据操作
-- 新增
    1、多表视图不能新增数据
    2、可以向单表视图插入数据，但是视图中包含的字段必须有基表中所有不能为空（或者没有默认值）字段
> insert into my_v values(2,‘php001‘,‘D302‘);
-- 删除
    1、多表视图不能删除
    2、单表视图可以删除数据    
> delete from my_v where id=1;
-- 更新(都可以操作) 
> update my_v set c_id=3 where id=5;
#更新限制
> create view my_v as 
select * from my_student where age>30 with check option --update age必须大于30
#视图算法
    系统对视图以及外部查询视图的select语句的一种解析方式
    1、undefind:未定义（默认的）
    2、temptable:临时表算法：系统应该先执行视图的select语句，后执行外部查询语句
    3、merge：合并算法，系统应该先将视图对应的select语句与外部查询视图的select语句进行合并，然后执行(效率高：常态)

-- 算法指定：
> create algorithm=temptable view my_v as 
select * from my_student order by height desc;
-- 视图算法选择：
如果视图的select语句中会包含一个查询子句（五子句），而且很有可能顺序比外部的查询语句要靠后，一定要使用算法temptable,其他情况可以不用指定(默认即可)

#数据表备份：
    存储引擎：innodb、myisam(免费).    select @@version; --查看版本
    innodb:只有表结构，数据全部存储到ibdata1文件中
    myisam:表、数据和索引全部都是单独分开存储
-- 单表数据备份
> select * into outfile ‘/Users/walker/Documents/Resource/backup/db/tmp/sysuser.txt‘ from sys_user;
-- 高级备份
> select */字段列表 into outfile 文件路径 fields 字段处理 lines 行处理 from 数据源；
fields：字段处理
    enclosed by:字段使用什么内容包裹，默认时‘’，空字符串
    terminated by:字段以什么结束，默认时“\t”,tab键
    escaped by:特殊符号用什么方式处理，默认是‘\\’,使用反斜杠转义
lines：行处理
    starting by :每行以什么开始，默认是‘’，空字符串
    terminated by :每行以什么结束，默认是“\r\n”,换行符

> select * into outfile ‘/Users/walker/Documents/Resource/backup/db/tmp/sysuser.txt‘
fields
enclosed by ‘"‘
terminated by ‘|‘
lines
starting by ‘START:‘
from sys_user;

#数据还原：
load data infile 文件所在路径 into table 表名[(字段列表)] feilds 字段处理 lines 行处理；

load data infile ‘/Users/walker/Documents/Resource/backup/db/tmp/sysuser.txt‘
into table sys_user
fields
enclosed by ‘"‘
terminated by ‘|‘
lines
starting by ‘START:‘;


#SQL 备份 --主要针对表结构,会浪费空间(额外的sql指令)
-- 单表备份
> mysqldump -uroot -p123456 basic sys_user > /Users/walker/Documents/Resource/backup/db/tmp/sysuser.sql       
-- 整库备份
> mysqldump -uroot -p123456 basic > /Users/walker/Documents/Resource/backup/db/tmp/basic.sql
#SQL 还原 --mysql客户端还原
> mysql -uroot -p123456 basic < /Users/walker/Documents/Resource/backup/db/tmp/sysuser.sql
-- SQL 指令还原sql备份
> source /Users/walker/Documents/Resource/backup/db/tmp/sysuser.sql


#增量备份 -- 大项目
不是针对数据或者sql指令进行备份：是针对mysql服务器的日志文件进行备份
增量备份：指定时间段开始进行备份，备份数据不会重复，而且所有的操作都会备份


#事务 -- 一系列要发生的连续的操作
-- 事务安全：保证数据操作的完整性
> create table my_account(
number char(16) not null unique comment ‘账户‘,
name varchar(20) not null,
money decimal(10,2) default 0.0 comment ‘账户余额‘
)charset utf8;

> insert into my_account values
(‘000000000001‘,‘张三‘,1000),
(‘000000000002‘,‘李四‘,2000);

-- 事务操作： 原理：事物开始后，所有操作都会保存到事务日志，只有commit命令才会同步到数据库
    自动事务(默认)，手动事务
-- 手动事务
    1、开启事务(先存放到事务日志)
    2、start transaction;
> update my_account set money=money-1000 where id=2;
> update my_account set money=money+1000 where id=1;
    3、关闭事务
        提交事务：同步数据表(操作成功) -- commit;
        回滚事务：直接清空事务日志表(操作失败) -- rollback;
回滚点：-- 在事务多的情况下
    前面成功，可以在当前成功的位置设置一个回滚点
    设置回滚点语法：savepoint 回滚点名字；
    回到回滚点语法：rollback to 回滚点名字；  
    1、start transaction;
    2、update my_account set money=money+10000 where id=1;
       savepoint sp1; -- 设置回滚点
       update my_account set money=money-10000*0.05 where id =2; -- 错误
        rollback to sp1; -- 回滚到回滚点
        update my_account set money=money-10000*0.05 where id =1;
    3、commit;   
    
-- 自动事务
    用户操作完会立即同步到数据表中
    
    自动事务：系统通过autocommit
    show variables like ‘autocommit‘;   
    set autocommit=0;-- 关闭自动事务
    
#事务特性(四大特性ACID)
    Atomic:原子性，事务的整个是一个整体，不可分割，要么全部成功，要么全部失败；
    consistency：一致性，事务操作的前后，数据表中的数据没有变化
    isolation:隔离性，事务操作是相互隔离不受影响
        锁机制innodb默认是行锁，但是如果在事务操作的过程中，没有使用索引，那么系统会自动全表检索数据，自动升级为表锁
        行锁：只有当前行被锁住，别的用户不能操作
        表锁：整张表被锁住，别的用户都不能操作
    durability:持久性，数据一旦提交，不可改变，永久的改变数据表数据

show variables; -- 查看所有系统变量
select @@autocommit

-- 会话级别的修改
set autocommit=0;
set @@autocommit=0;
-- 全局修改
set global autocommit=0;

-- 自定义变量
 set @变量名=值   set @name=‘张三‘  set @age := 18
 
 -- 从表中获取数据赋值给变量 , 会话级别
 select number,name from my_account where id=1 into @number,@age;


#触发器
事先为某张表绑定一段代码，当表中某些内容发生改变的时候(增删改)，系统会自动触发代码，执行
触发器：事件类型、触发时间、触发对象
事件类型：增删改insert、delete、update
触发时间：before、after
触发对象：表中的每一条记录

一张表中只有拥有一种触发时间的一种类型的触发器：最多一张表能有6个触发器
-- 创建触发器
    语法：
    1、临时修改语句结束符
    delimiter 自定义符号：后续代码中只有碰到自定义符号才算结束
    create trigger 触发器名字 触发时间 事件类型 on 表名 for each row
    begin
    
    end
    
    delimiter;
    
    
    create table my_goods(
    id int primary key auto_increment,
    name varchar(20) not null,
    price decimal(10,2) default 1,
    inv int comment ‘库存数量‘)charset utf8;

    insert into my_goods values(null,‘iphone6s‘,5288,100),(null,‘三星‘,5288,200);
    
    create table my_order(
    id int primary key auto_increment,
    g_id int not null comment ‘商品ID‘,
    g_number int comment ‘商品数量‘)charset utf8;
    
    delimiter $$ 
    create trigger after_order after insert on my_order for each row 
    begin 
    update my_goods set inv = inv -1 where id=2;
    end
    $$
    delimiter ; --有空格
    
    show triggers; -- 查看所有触发器
    show triggers\G;
    show create trigger 触发器名字
    show create trigger after_order
    
    所有触发器都会保存到information_schema.triggers\G表中
    
-- 使用触发器
    insert into my_order values(null,1,2);
    
-- 触发器删除
    drop trigger after_order;
    
-- 触发器记录
    不管触发器是否触发了，只要当某种操作准备执行，系统就会将当前要操作的记录的当前状态和即将执行之后的状态给分别保留下来，供触发器使用；其中，要操作的当前状态保存到old中，操作之后可能形态保存给new
    
    delimiter $$ 
    create trigger after_order after insert on my_order for each row 
    begin 
    update my_goods set inv = inv - new.g_number where id= new.g_id;
    end
    $$
    delimiter ; --有空格
    
    insert into my_order values(null,1,2);
    
    -- 库存判断
    delimiter %% 
    create trigger before_order before insert on my_order for each row 
    begin 
    
       select inv from my_goods where id=new.g_id into @inv;
       if @inv < new.g_number then
          insert into XXX values(XXX);
       end if;
       
    end
    %%
    delimiter ;
    
    insert into my_order values(null,1,20000);
    
    
-- 循环结构
    while循环(没有for循环)
    
    while 条件判断 do
    
    end while;
    
    循环控制：在循环内部控制循环判断和控制
    iterate:迭代，类似continue,后面的代码不执行，循环重新来过
    leave:离开，类似break，整个循环接收
    
    使用方式：iterate／leave 循环名字
    
    -- 定义循环名字
    循环名字：while 条件 do
      --循环体
      --循环控制
      iterate／leave 循环名字
    end while;
    
    
#函数(系统函数、自定义函数)
    将一段代码块封装到一个结构中，在需要执行代码块的时候，调用结构执行即可(代码复用)

-- 系统函数
    mysql中，字符串的基本操作单位
    substring:字符串截取（字符为单位）
    char_length:字符长度
    length:字节长度
    instr:判断字符串是否在某个具体的字符串中存在，存在返回位置
    lpad:左填充，将字符串按照某个指定的填充方式，填充到指定长度(字符)
    insert:替换，找到目标位置，指定长度的字符串，替换成目标字符串
    strcmp:字符串比较    
    
set @cn=‘世界你好‘;
set @en=‘hello world‘;
select substring(@cn,1,1);
select substring(@en,1,1);  
select char_length(@cn),char_length(@en),length(@cn),length(@en);
select instr(@cn,‘界‘); -- 0 代表没有找到
select lpad(@cn,20,‘欢迎‘);
select insert(@en,3,3,‘y‘); -- 第三个位置，变3个

set @f=‘hello‘;
set @s=‘hey‘;
set @t=‘HEY‘;
select strcmp(@f,@s),strcmp(@s,@t),strcmp(@s,@f); -- 不区分大小写


-- 自定义函数
    create function 函数名([形参列表])returns 数据类型
    begin
        -- 函数体
    end

create function displayl() returns int
return 100;

select displayl(); -- 函数调用

show create function displayl\G;

修改函数&删除函数
    函数只能先删除后新增，不能修改
    drop function 函数名;
    drop function desplayl;
    
函数参数
    形参、实参
    
    delimiter $$
    create function desplayl(int_1 int) returns int
    begin
       set @i=1;
       set @res=0;
       while @i <= int_1 do
            set @res = @res + @i;  -- 没有+= ++
            set @i = @i + 1;
       end while;
       return @res;
       
    end
    $$
    delimiter ;
13340323263
    select desplayl(10);
    select @res,@i;   -- 在函数内部用@定义的变量在函数外部也可以访问
    
-- 作用域
    全局变量可以在任何地方使用；局部变量只能在函数内部使用
    
    全局变量：使用set关键字定义，使用@符号标志
    局部变量：使用declare关键字声明，没有@符号，所有的局部变量的声明，必须在函数体开始之前
    
    
    delimiter $$
    create function desplay2(int_1 int) returns int
    begin
       declare i int default 1;
       declare res int default 0;
       
       mywhile:while i <= int_1 do
          if i % 5 =0 then
             set i=i+1;
             iterate mywhile;
          end if;
          
          set res = res + i;
          
          set i=i+1;
          
       end while;
       
       return res;
        
    end
    $$
    delimiter ;



-- 存储过程
    是一种没有返回值的函数
    create procedure 过程名字([参数列表])
    begin
        -- 过程体
    end
    
    
    create procedure pro1() select * from my_account; --创建存储过程
    show procedure status like ‘pro%‘\G; -- 查看过程
    
    show create procedure pro1; -- 查看过程创建语句
    
    -- 调用过程
        call pro1();
        
    drop procedure pro1; -- 删除存储过程
    
    -- 过程参数(三种类型)
     in:数据只有从外部传入给内部使用，可以是数值也可以是变量
     out:只允许过程内部使用，给外部使用的（引用传递：外部的数据会被先清空才会进入内部）：只能是变量
     inout:外部可以在内部使用，内部修改也可以给外部使用：典型的引用传递：只能传变量
     
     delimiter $$
     create procedure pro1(in int_1 int,out int_2 int,inout int_3 int)
     begin
          select int_1,int_2,int_3;  -- int_2的值一定为null
     end
     $$
     delimiter ;    
    
    调用：out和inout 类型的参数必须传入变量，而不能是数值
    set @int_1 := 1;
    set @int_2 := 2;
    set @int_3 := 3;
    select @int_1,@int_2,@int_3;
    call pro1(@int_1,@int_2,@int_3);
    select @int_1,@int_2,@int_3;
    
    
    存储过程对于变量的操作(返回)是滞后的；是在存储过程调用结束的时候，才会重新将内部修改的值赋值给外部传入的全局变量
    delimiter $$
     create procedure pro2(in int_1 int,out int_2 int,inout int_3 int)
     begin
          select int_1,int_2,int_3;  -- int_2的值一定为null
          -- 修改局部变量
          set int_1 = 100;
          set int_2 = 200;
          set int_3 = 300;
          
          select int_1,int_2,int_3; -- 查看局部变量
          select @int_1,@int_2,@int_3; -- 查看全局变量
          
          -- 修改全局变量
          set @int_1 = ‘a‘;
          set @int_2 = ‘b‘;
          set @int_3 = ‘c‘;
          select @int_1,@int_2,@int_3;
          
     end
     $$
     delimiter ;    
     
     set @int_1 := 1;
     set @int_2 := 2;
     set @int_3 := 3;
     call pro2(@int_1,@int_2,@int_3);
     
     在存储过程调用结束之后，系统会将局部变量重复返回给全局变量(out 和 inout)
    
2.日期的操作
date_format(date, format) 函数，MySQL日期格式化函数date_format()
unix_timestamp() 函数
str_to_date(str, format) 函数
from_unixtime(unix_timestamp, format) 函数，MySQL时间戳格式化函数from_unixtime
时间转字符串
select date_format(now(), ‘%Y-%m-%d‘);  
#结果：2016-01-05  
时间转时间戳
select unix_timestamp(now());  
#结果：1452001082  
字符串转时间
select str_to_date(‘2016-01-02‘, ‘%Y-%m-%d %H‘);  
#结果：2016-01-02 00:00:00  
字符串转时间戳
select unix_timestamp(‘2016-01-02‘);  
#结果：1451664000  
时间戳转时间
select from_unixtime(1451997924);  
#结果：2016-01-05 20:45:24  
时间戳转字符串
select from_unixtime(1451997924,‘%Y-%d‘);  
//结果：2016-01-05 20:45:24