改表名 rename table 旧表名 to 新表名 
表头 create table 表名(字段名 类型 约束,..)
增列 alter table 表名 add 列名 类型  约束；
改列 alter table 表名 change 旧列名 新列名 类型 约束
删列 alter table 表名 drop 列名
插行 insert into 表名 values(值1,值2......)
改行 update 表名 set age=22 where id=2
删行 delete from 表名 where 列名=值 

查库 show databases;
查字符集 show create database db; 
进库 use lb 查有多少张表:show tables;
查建表语句:show create table 表名
查看表结构 desc 表名;  

但所有行:select*from from1;
查1行:SELECT*FROM star WHERE id=3 WHERE price>3000 HAVING TYPE=1
多行:select*from form1 where id in(1,3,5,7,15,20) HAVING price>3000

模糊 select*from from1 where name like %波_;
区间 select*from from1 where price between 2000 and 6000;  [bɪˈtwin] 
降序 select * from from1 order by price asc升/desc降;
去重并年龄升序SELECT DISTINCT price FROM star ORDER BY 年龄 ASC; 

逻辑和 select * from from1 where price>3000 and age>30;
select*from user where username='张三' and password='123456'
逻辑或 select * from from1 where price>5000 or name like "周%";
逻辑非 select * from from1 where not(name like "周%");

查1列/多个列:SELECT 姓名 FROM star; 
并筛选:SELECT id,年龄 FROM star WHERE 年龄>30; 

聚合算条目数不能有where: select count(*) from from1
聚合算总和值 select sum(price) from from1
聚合最大值 select max(age) from star;
聚合最小值 select min(age) from from1;
分组聚合算平均值 SELECT TYPE, AVG(price)FROM star GROUP BY TYPE;

分组:整个表分组并把年龄*2的结果 单独列出 SELECT*,年龄*2 FROM star
以年龄分组 并把年龄大于30单独统计 SELECT 姓名,年龄>30 FROM star
以分组形式把姓名列出:SELECT TYPE,GROUP_CONCAT(姓名)FROM star GROUP BY TYPE
各个分组身份的平均值 select type,avg(price) from star group by type;
各个分组身份的最大的 select type,min(price) from star group by type;
各个分组身份的条目数 select type,count(*) from star group by type;

各个分组身份的条目数 并大于2的显示条目
select type,count(*)from star group by type having count(*)>2;
每组 条目里年龄大于30的显示条目;WHERE只能在分组前
SELECT TYPE,COUNT(*)FROM star WHERE 年龄>30 GROUP BY TYPE
每组 条目里年龄大于30的 并且条目大于2的 显示条目;HAVING可以分组后再过滤
SELECT TYPE,COUNT(*)FROM star WHERE 年龄>30 GROUP BY TYPE HAVING COUNT(*)>2

MySQL多表 商品表的外键和分类表的主键
添加一个外键:alter table 表名 add foreign key(外键字段的字段名) references 主键表名 (主键字段名) ['ɔ:ltə] [ˈfɒrən][ˈrefrənsiz]  [ˈkætəgɔri]
alter table star add foreign key(type)references category(cid)
删除一个外键：alter table 表名 drop foreign key 约束名
ALTER TABLE star DROP FOREIGN KEY star_ibfk_1

- 一对多(重点)
  - 应用场景:学生和班级、商品和分类、用户和订单
    - 建表原则:在多的一方添加一个外键，指向一的一方的主键
- 多对多(重点)
  - 应用场景:商品和订单、学生和选课
  - 建表原则：创建一张第三方表，该表除了id字段之外，还至少得有两字段，分别作为外键指向两张表的主键
- 一对第一
  - 应用场景:人和身份证号
  - 建表原则:先当成一对多来处理，再给多的一方的外键字段添加一个唯一约束

交叉查询得到的结果是一个笛卡尔积，这个结果中包含错误数据。
select*from star,category

连接查询:为了筛选交叉查询中获取带的正确数据(重点)
  其实就是在交叉查询的基础上添加一个条件进行筛选正确数据

满足条件则显示，不满足则不显示 两种结果一样
隐式内连接查询 查询结果是a的外键star.type=b的主键(cid)/两个int相同就显示 b的主键对应的数据(cname) 简写的结果一模一样只是精简了代码
  - select * from a表,b表where 条件(a表的外键=b表的主键)

SELECT*FROM star,category WHERE star.type=category.cid
SELECT*FROM star s,category c WHERE s.type=c.cid 可以用别名简化
显式 内连接查询 显示里面的,on只能用主外键关联作为条件,如果还有其它条件,后面加where
  - select * from a表 inner join b表 on 条件

SELECT*FROM star s JOIN category c ON s.type=c.cid
SELECT*FROM star s JOIN category c ON s.type=c.cid 简化

外连接查询：显示主表 的所有数据，从表 的数据若满足条件则显示，不满足则以null显示
- 左外连接:以join左边的表为主表/star
select * from a表left outer join b表 on 条件

SELECT*FROM star s LEFT  OUTER JOIN category c ON s.type=c.cid
- 右外连接:以join右边的表为主表 /category
  - select * from a right outer join b on 条件
SELECT*FROM star s RIGHT  OUTER JOIN category c ON s.type=c.cid

子查询(重点)
定义：一个select语句中嵌套另外一个完整的select语句，也就是说一个select语句作为另外一个select语句的条件

1--先查出最高身价明星 2再根据最高身价查出明星信息
SELECT MAX(price) FROM star
SELECT*FROM star WHERE price=5050
子查询就可以合并成一句查询 嵌套
SELECT*FROM star WHERE price=(SELECT MAX(price)FROM star)

--1查宝宝的身价2.以宝宝的身份去查询身价大于这个数的明星信息--
SELECT price FROM star WHERE NAME="宝宝"
SELECT*FROM star WHERE price>5000
SELECT*FROM star WHERE price>(SELECT price FROM star WHERE NAME="宝宝")

--1查出小白的类别2 根据这个类别查同类别明星信息--
SELECT TYPE FROM star WHERE NAME="小白"
SELECT*FROM star WHERE TYPE=2
SELECT*FROM star WHERE TYPE=(SELECT TYPE FROM star WHERE NAME="小白")
SELECT*FROM star WHERE TYPE=(SELECT TYPE FROM star WHERE NAME="小白")AND NAME!="罗永浩"//后面还可以加上不等于的语句

SELECT*FROM star WHERE TYPE=(SELECT cid FROM category WHERE cname="宝剑队"); //查所有类别为宝剑队的明星

联合查询(了解)：合并两个select语句查询到的结果集

- union,去重
- union all，不去重

分页查询(重点)

- 关键字:limit a,b
  - a代表从第几个下标开始查询
SELECT*FROM star LIMIT 0,4; //第二次 4,4
  - b代表查询多少条数据，也就是每页显示的数据条数
- 将客户端传入的要查询的页数"page"转换成a
 a=(page-1)*b
对明星进行按价格从高到低排序，然后取第一个明星信息
SELECT * FROM star ORDER BY price DESC LIMIT 0,1

SELECT ename,job FROM emp WHERE deptno=10 //10号部门员工和工作
SELECT deptno,AVG(sal)FROM emp GROUP BY deptno 以部门分组 查出平均工资

SELECT * FROM tab;

       create tablespace 表空间的名称
       datafile '存放的未知'
       size   初始大小
       autoextend on
       next  每次增长多少

create table person(
    pid number primary key,
    name varchar2(20) unique,
    age number not null,
    sex varchar2(20) check(sex in('男','女','妖'))
);
-- male,female,ladyboy
insert into person values(1,'zhangsan',18,'妖');
insert into person values(2,'lisi',18,'妖');

create table category(
       cid number primary key,
       cname varchar2(20)
);

create table product(
       pid number primary key,
       pname varchar2(20),
       cno number
);

insert into category values(1,'手机数码');
insert into product values(100,'锤子',11);

truncate table product;
-- 添加外键约束
alter table product add foreign key(cno) references category(cid);
insert into product values(100,'锤子',1);

-- 删除主表: 先取消外键约束,再删除自己
drop table category cascade constraint;

-- 级联删除,添加外键约束
-- 
alter table product add foreign key(cno) references category(cid) on delete cascade;

-- 删除category主表中的记录
-- 级联删除: 先去从表中查看有没有关联的数据,如果有,则先删除从表中的记录,再删除主表中记录
delete from category where cid=1;

select * from category;
select * from product;

/*
       插入数据 insert into 
*/
-- 使用子查询插入数据
select * from emp;
select * from emp1;

-- 将10号部门的所有员工信息插入到emp1中
insert into emp1 select * from scott.emp where deptno=10;

/*
      删除所有数据:
      delete     和      truncate
      逐条删除数据       先删除再创建表
      DML                 DDL
      支持事务           不支持事务
                         效率高
*/

/*
   事务: 一组操作,要么都成功,要么都失败
   
   事务特型:
       原子性
       一致性
       隔离性
       持久性
       
   不考虑隔离级别的问题：　脏读，　虚读／幻读，不可重复读
   
   mysql隔离级别:
        READ UNCOMMITTED 读取未提交  脏读，　虚读／幻读，不可重复读
        READ COMMITTED   读取已提交, 虚读／幻读，不可重复读
        REPEATABLE READ  可重复读, 虚读／幻读，
        SERIALIAZABLE   串行化 
        
  Oracle隔离级别:
        READ COMMITTED (默认)
        SERIALIAZABLE
        READ ONLY 
        
   事务回滚点/保存点
        savepoint 保存点的名称
        
        rollback to 保存点  
        
    主要使用场景: 数据迁移的时候, 1000万  100万提交一次, 50万的时候,            
*/
create table lou(
   f number primary key
);



-- PLSQLB编程
declare
  -- 声明部分
begin
  -- 业务逻辑
  insert into lou values(1);
  insert into lou values(2);
  insert into lou values(3);
  savepoint aa;
  insert into lou values(3);
  insert into lou values(4);
  insert into lou values(5);
  commit;
exception -- 捕获异常
  when others then -- 处理异常
     rollback to aa;
     commit;
end;

select * from lou;

/*
   视图view: 
       实际是对查询结果的封装,视图本身不存储任何数据,所有的数据都存放在原来的表中
       作用:
           封装复杂查询语句
           屏蔽表中的细节
           
       语法:
           create [or replace] view 视图名称 as 查询语句 [with read only]
*/
-- 封装员工表
create or replace view view_test1 as select ename,job,mgr from emp;
select * from view_test1;

-- 同义词
create synonym yuangong for view_test1;
select * from yuangong;


-- 通过视图去修改数据
update view_test1 set ename='SMITHaaaa' where ename='SMITH';

select * from emp;

-- 创建只读视图
create or replace view view_test2 as select ename,job,mgr from emp with read only;
update view_test2 set ename='SMITHaaaa' where ename='SMITH';

/*
    序列: 
        1,2,3,4,5,6,7
    模拟类似auto_increment作用
    作用: Oracle中主要是用来生成自增的编号 
    
    语法:
        create sequence 序列的名称
        start with 从几开始
        incrementby 每次增长多少
        minvalue | nominvalue
        maxvalue | nomaxvalue
        cycle | nocycle
        cache n 缓存
          
        cache 5
              1,2,3,4,5
                        6,7,8,9,10 
                        
      序列的属性:
          currval : 当前值 , 必须是调用过一次nextval之后
          nextval  : 下一个值  
          
      注意: 序列中的数,一旦取过了, 无论回滚还是异常,都是永不回头的向下递增                
*/
-- 1,3,5,7,9,1,3,5,7,9.....
create sequence seq_test1
start with 1
increment by 2
minvalue 1
maxvalue 9
cycle
cache 3;

-- 获取当前值
select seq_test1.currval from dual;

-- 获取下一个值
select seq_test1.nextval from dual;


-- 通常创建序列的写法
create sequence seq_test2;
select seq_test2.nextval from dual;

truncate table lou;

select * from lou;

insert into lou values(seq_test2.nextval);

-- 创建测试数据500万
-- 创建一张表
create table wbw(
   c1 number primary key,    
   c2 varchar2(20),
   c3 varchar2(20)
); 

-- 插入500万条记录索引
create sequence seq_wbw;


-- PLSQL中的循环
declare

begin
   for i in 1..5000000 loop
     insert into wbw values(seq_wbw.nextval,'c2:'||i,'c3:'||i);
   end loop;  
   commit;  
end;

select count(*) from wbw;

-- 在没有创建索引的情况下 6.489s
select * from wbw where c2='c2:4000000';

-- 0.023
select * from wbw where c1=4000000;


-- 创建索引
create index wbw_c2 on wbw(c2);

/*
  if条件判断
     if 条件1 then
      elsif 条件2 then
      else
      end if;
*/
-- 根据不同年龄输出信息
declare
   age number := &请输入;--&会弹出输入框 请输入 为输入名称输入的 为值
begin
   if age<=18 then
     dbms_output.put_line('未成年人');  
   elsif age>18 and age<=24 then
     dbms_output.put_line('年轻人');
   elsif age>24 and age<48 then
     dbms_output.put_line('中年人');
   else
     dbms_output.put_line('老年人');
   end if;  
end;

三种循环语法
for循环: for 变量名 in 起始值..结束值  loop
       end loop; 
       
while循环语法:     while 条件 loop
          end loop;
         loop
         
exit循环语法:    exit when 退出的条件
     循环体
   end loop;

-- 输出1-10
declare
  
begin
  for i in 1..10 loop
    dbms_output.put_line(i);
  end loop;
end;

-- 输出10-1
declare
   
begin
  for i in reverse 1..10 loop
    dbms_output.put_line(i);
  end loop;
end;

-- 输出1-10
declare
  i number :=1; --变量i赋值为1
begin
  while i<=10 loop
    dbms_output.put_line(i);
    i := i+1;--i的变化为+1
  end loop;
end;


-- 输出1-10
declare
   i number :=1;
begin
   loop
     exit when i>10;
     dbms_output.put_line(i);
     i := i+1;
   end loop;
end;

   游标: (光标/指针)  是对查询结果集的封装, 相当于是jdbc中的ResultSet
      语法:
        声明游标:
cursor 游标名 is 查询语句
cursor 游标名(参数名 参数类型) is 查询语句 where empno=参数名
                        
        开发步骤:
            1.打开游标 open 游标名
            2.从游标中提取数据:
                   fetch 游标名 into 变量
                         游标名%notfound  没有数据
                         游标名%found     找到数据
            3.关闭游标 close 游标名               
 

-- 输出所有员工的信息
declare
   cursor vemps is select * from emp; -- 声明游标
    vrow emp%rowtype;-- 声明变量
begin
     open vemps; --1. 打开游标
       loop  --2. 提取数据
        fetch vemps into vrow;--赋值给vrow
         exit when vemps%notfound;-- 判断无数据就退出查询
                dbms_output.put_line('姓名:'||vrow.ename||' 工资:'||vrow.sal);-- 打印数据
   end loop;
       close vemps; -- 关闭游标
end;


-- 输出指定部门的员工信息
declare
   -- 声明游标
   cursor vemps(vdeptno number) is select * from emp where deptno = vdeptno;
      vrow emp%rowtype;  -- 声明记录型变量
begin
      open vemps(20);-- 1. 打开游标
  loop-- 2.循环遍历游标
      fetch vemps into vrow;
      exit when vemps%notfound;--判断没有数据就退出
      -- 打印数据
      dbms_output.put_line('姓名:'||vrow.ename||' 工资:'||vrow.sal);
   end loop;
      close vemps;-- 3. 关闭游标
end;

-- 按照职位涨工资,总裁涨1000 , 经理涨800 , 其他人涨400
/*
   游标: 所有员工
   遍历所有员工
       根据职位涨工资    
*/
declare
  -- 声明游标
  cursor vemps is select * from emp;    
  -- 声明记录型变量
  vrow emp%rowtype; 
begin
  -- 1.打开游标
  open vemps;
  
  -- 2.游标 循环提取数据给变量
  loop
     fetch vemps into vrow;
     exit when vemps%notfound;--游标没有查询了才退出
     
     -- 根据职位涨工资    
     if vrow.job = 'PRESIDENT' then
        update emp set sal=sal+1000 where empno=vrow.empno;
     elsif vrow.job = 'MANAGER' then
        update emp set sal=sal+800 where empno=vrow.empno;  
     else
        update emp set sal=sal+400 where empno=vrow.empno;
     end if;
  end loop;
  -- 关闭游标
  close vemps;
  
  -- 提交数据
  commit;
end;


/*
  excel产品 --- > xml,json   php,python
  扩展: 使用for循环遍历游标
  
*/
declare
 -- 声明游标
 cursor vemps is select * from emp;
begin
  for vrow in vemps loop
      dbms_output.put_line(vrow.ename);
  end loop;
end;

/*
  例外 (意外): 相当于是java异常
    语法:
      declare
         声明部分
      begin
         业务逻辑
      exception
         处理例外
         when 例外1 then
           when 例外2 then
              when others then
              end;
      
  常见的系统的例外
      zero_divide : 除零例外
      value_error : 类型转换
      no_data_found : 没有找到数据例外
      too_many_rows : 查询出多行记录,但是赋值给了单行变量
*/
declare
  i number;   
   vrow emp%rowtype; 
begin
  -- i := 5/0;
  -- i := 'aaa';
  -- select * into vrow from emp where empno=1234567;
    select * into vrow from emp ;
exception
  when too_many_rows then
    dbms_output.put_line('查询出多行记录,但是赋值给了单行变量');
  when no_data_found then
    dbms_output.put_line('发生了没有找到数据例外');
  when value_error then
     dbms_output.put_line('发生了类型转换的例外');
  when zero_divide then  
     dbms_output.put_line('发生除零例外');
  when others then
     dbms_output.put_line('发生了未知的例外');
end;

/*
     自定义例外
         声明:
              例外名称 exception;
         抛出自定义例外:
              raise 例外名称
*/
declare
   -- 声明例外
   no_emp_found exception;           
begin
  -- 抛出例外
   raise no_emp_found;
exception
  -- 捕获例外
  when no_emp_found then
    dbms_output.put_line('自定义例外');   
  when others then
    dbms_output.put_line('未知例外');   
end;


- 查询指定编号的员工,若这个员工没有找到,则抛出自定义的例外
-- 正确做法:
declare
   -- 声明例外
   no_emp_found exception;
   -- 定义记录型变量
   vrow emp%rowtype;
   -- 声明游标
   cursor vemps is select * from emp where empno=1234567;
begin
   -- 打开游标
   open vemps;
   
   -- 向下移动游标
   fetch vemps into vrow;
   
   -- 判断游标是否找到数据
   if vemps%notfound then
      raise no_emp_found;
   end if;
   
   -- 关闭游标
   close vemps;
exception 
   when no_emp_found then
     dbms_output.put_line('捕获了自定义的例外');
   when others then
     dbms_output.put_line('未知的例外');   
end;

/*相当于是在java main函数里面写了一些业务逻辑
-- 将main函数中的业务逻辑抽取成单个的方法
    存储过程: 实际上是将一段已经编译好的PLSQL代码片断,封装在数据库中
           作用:
              1. 提高执行效率
              2. 提高代码复用性
          
          语法:
              create [or replace] procedure 过程名称(参数1 in|out 参数类型,参数2 in|out 参数类型)
              is | as
                 -- 声明部分
              begin
                 -- 业务逻辑
              end;
*/ 
-- in代表输入参数 out代表输出参数
-- 给指定员工涨薪,并打印涨薪前和涨薪后的工资
-- 员工编号 : 输入参数
-- 涨多少 : 输入参数
/*
   1. 查询当前工资
   2. 打印涨薪前工资
   3. 涨工资
   4. 打印涨薪后的工资
   5. 提交数据
*/
-- select * from emp where empno=1234567; ---> 发送给数据库 ---> 分析编译---> 执行

-- 给指定员工涨工资, 并且打印涨工资前的工资和涨工资之后的工资
-- 参数: 员工编号 in
-- 参数: 涨薪数量 in
create or replace procedure proc_updatesal(vempno in number,vcount in number)
is
  -- 声明变量,接收当前工资
  vsal emp.sal%type;
begin
  -- 1.查询当前工资
  select sal into vsal from emp where empno=vempno;
  -- 2.打印当前工资
  dbms_output.put_line('涨薪前:'||vsal);
  -- 3.涨工资update
  update emp set sal=vsal+vcount where empno=vempno; 
  -- 4.打印涨薪后的工资
  dbms_output.put_line('涨薪后:'||(vsal+vcount));
  -- 5.提交事务
  commit;
end; 

-- 调用存储过程,方式1
call proc_updatesal(7369,100);

-- 方式2
declare

begin
   proc_updatesal(7369,200);
end;

-- 封装一个获取指定编号员工年薪的存储过程
-- 参数: 员工编号 in
-- 参数: 年薪     out
create or replace procedure proc_getyearsal(vempno in number,vyearsal out number)
is       
begin
   select sal*12+nvl(comm,0) into vyearsal from emp where empno=vempno;
end;

-- 调用获取年薪
declare
   yearsal number;
begin
   proc_getyearsal(7369,yearsal);
   
   dbms_output.put_line('年薪:'||yearsal);
end;


-- 获取指定编号员工的年薪
/*
   编号: in  输入
   年薪: out 输出
*/
create or replace procedure proc_getyearsal(vempno in number,vyearsal out number)
is
       
begin
  select sal*12+nvl(comm,0) into vyearsal from emp where empno=vempno;
end;

-- plsql代码片断中调用
declare
   yearsal number;
begin
   proc_getyearsal(7369,yearsal);
   dbms_output.put_line(yearsal);
end;


-- 封装存储过程,输出的是游标类型, 所有员工
/*
   sys_refcursor : 系统引用游标
*/
create or replace procedure proc_getemps(vemps out sys_refcursor)
is

begin
    -- 打开游标, 谁调用谁关闭
    open vemps for select * from emp;   
end;

declare
  vemps sys_refcursor;
  vrow emp%rowtype;
begin
  -- 调用存储过程
  proc_getemps(vemps);
  
  loop
     fetch vemps into vrow; 
     exit when vemps%notfound;  
     dbms_output.put_line(vrow.ename);
  end loop;
  -- 关闭游标
  close vemps;
end;

/*
    存储函数: 实际上是将一段已经编译好的PLSQL代码片断,封装在数据库中    
          作用:
              1. 提高执行效率
              2. 提高代码复用性
         语法:
create [or replace] function 函数名称(参数1 in|out 参数类型) return 返回类型
              is
              begin
              end; 
              
          存储过程和存储函数:
              1. 函数有返回值,过程没有
              2. 函数可以直接在SQL语句中使用,过程不可以
              3. 函数能实现的功能,过程能实现
              4. 过程能实现的功能,函数也能实现
              
              5. 函数和过程本质上没有区别
              
           通常情况下,我们自己开发封装的是存储过程
*/
-- 存储函数: 获取指定编号员工的年薪
-- 参数 : 员工编号
-- 返回 : 年薪
create or replace function func_getyearsal(vempno number) return number
is 
  -- 声明变量
  vyearsal number;
begin
  select sal*12+nvl(comm,0) into vyearsal from emp where empno=vempno;
  return vyearsal;
end;

-- 调用
declare
  yearsal number; 
begin
  yearsal := func_getyearsal(7369);
  dbms_output.put_line('年薪:'||yearsal);
end;
-- 直接在SQL语句中使用
select emp.*,func_getyearsal(empno) from emp;



/*
    使用java调用数据库中封装好了存储过程
    
    用户注册 ---> 数据校验
    javaEE后台什么校验都不写, 直接将所有校验都丢给数据库存储过程
    
    java调用存储过程的步骤:
         JDBC开发步骤:
               1. 注册驱动
               2. 获取连接
               3. 获取执行SQL的对象
               4. 执行SQL
               5. 获取结果
               6. 释放资源
*/
-- java 调用一个获取年薪的存储过程
-- 练习 : java调用输出类型为游标的存储过程
/*
   cursor 游标名 is 查询结果
   
   sys_refcursor : 系统引用游标, 游标类型声明
*/
create or replace procedure proc_getemps(vemps out sys_refcursor)
is

begin
   -- 输出sys_refcursor20号部门下的所有员工
   -- 打开游标的时候,指定结果集
   open vemps for select * from emp where deptno=20;
   -- 谁用谁关闭
end;
-- 调用
declare
  emps sys_refcursor;
  vrow emp%rowtype;
begin
  -- 已经打开并且指定了结果集
  proc_getemps(emps);
  
  --循环提取游标中的数据
  loop
     fetch emps into vrow;  
     exit when emps%notfound;
     
     dbms_output.put_line('姓名:'||vrow.ename);
  end loop;
  -- 关闭游标
  close emps;
end;


/*
   自定义例外
   存储过程
   存储函数
   java调用存储过程
   
   触发器:
         当用户对表执行了insert | update | delete 这些操作的时候,
                        可以使用触发器去触发一段PLSQL代码逻辑的执行
           作用:
                监听表中数据变化
                对表中数据进行校验             
          
         
           语法:
                create or replace trigger 触发器名称
                before | after
                insert | update | delete
                on 表名
                [for each row]
                declare
                
                begin
                  
                end;  
                
         触发器的分类:
               行级触发器: 一条SQL语句, 影响了多少行记录, 触发器就会执行多少次
                      两个内置对象:
                               :new   新的记录  
                               :old   旧的记录
                      update emp set sal=sal+100;
                      
                           :new.sal  ---> sal+100
                           :old.sal  ---> sal
                               
               语句级触发器: 一条SQL语句, 无论影响了多少行记录, 都只触发一次                                
*/
-- 若用户向表中插入数据之后, 打印一句话
create or replace trigger tri_test1
after
insert 
on emp
declare

begin
   dbms_output.put_line('有人插入了....');
end;

insert into emp(empno,ename) values(9527,'华安');
-- 执行一条更新工资的语句

-- 周二老板不在,不能办理员工入职(不能向员工表中插入数据)
-- 触发器
-- before insert
-- 判断今天是否是周二
select trim(to_char(sysdate,'day')) from dual;

create or replace trigger tri_checkday
before
insert
on emp
declare
   vday varchar2(20);
begin
   -- 查询当前周几
   select trim(to_char(sysdate,'day')) into vday from dual;
   -- 判断是否为周二,若为周二,则需要中断插入操作
   if vday = 'tuesday' then
     --                   -20000 - -20999
     raise_application_error(-20001,'周二老板不在,不能插入');
   end if;
end;

insert into emp(empno,ename) values(9527,'华安');

select * from emp;

-- 语句级触发器
create trigger tri_test3
before
update
on emp
declare

begin
  dbms_output.put_line('语句级触发器'); 
end;

-- 行级触发器
create or replace trigger tri_test4
before
update
on emp
for each row
declare

begin
  dbms_output.put_line('行级触发器,旧的工资:'||:old.sal||'  新的工资:'||:new.sal); 
end;

update emp set sal=sal+100;

-- 6个月 ---> 人事 加薪 ---> 加10块钱 ---> 老板签字
-- 校验员工薪资 调整后的工资一定要 大于 薪资调整前的工资
-- 触发器:  before update on emp
-- 行级触发器
create or replace trigger tri_checksal
before
update
on emp
for each row
declare

begin
  -- 调整后的工资 <= 薪资调整前的工资 ,则中断更新操作
  -- :new.sal    <= :old.sal
  if :new.sal <= :old.sal then
     raise_application_error(-20002,'坑爹的,降薪啦!');
  end if;
end;

update emp set sal=sal-100;

/*
     使用触发器模拟类似auto_increment功能
     
     当用户插入的时候,若为sid为null,则给sid赋值一个编号
     
*/
create table stu(
     sid number primary key,
     name varchar2(20)
);

-- 创建一个序列
create sequence seq_stu;

-- 触发器: before insert on stu
-- 行级触发器
create or replace trigger tri_auto
before
insert 
on stu
for each row
declare

begin
   -- 从序列中查询一个数字出来,赋值给sid
   select seq_stu.nextval into :new.sid from dual;
end;

-- 同样一张表,有时候自己指定id, 有时候需要数据库自动生成id
insert into stu values(null,'zs');
insert into stu values(4,'zs');
select * from stu;