很不错的oracle帮助手册

开发中快速查找的好帮手，覆盖面全，查找方便，有实例：

Oracle函数
单行函数
字符函数
LOWER: 将字符转化成大写：对非字符无影响
UPER :   将字符转化成小写：对非字符无影响
CONCAT:  将字符串连接，相当于||
SUBSTR :  取得字串
LENGTH:  求长度
INITCAP :　将每个单词的第一个字母大写其它字母小写返回
INSTR :    求出现的位置

SELECT E.ENAME, LOWER(E.ENAME)
FROM EMP E
WHERE LOWER(E.ENAME)='smith'//转化成小写

SELECT MIN(SAL)//求最小值  （基于数值型的）
FROM EMP;

SELECT *
FROM EMP E
WHERE INITCAP(E.ENAME)='Ward'//首字母大写，其余小写

SELECT E.EMPNO,E.ENAME,E.JOB, CONCAT(E.ENAME,E.JOB) AS CON ,//连接（基于任
何类型的）

LENGTH(E.ENAME) AS LEN ,INSTR(E.JOB,'S') AS "IN" //求出现的位置
FROM EMP E
WHERE SUBSTR(E.JOB,1,5)='SALES';//取子串
使用数字函数
round//进行四舍五入
trunc:// 将值截断到指定的小数位
MOD//返回相除后的余数

SELECT  TRUNC(49.536 ,1) AS "小数点后一位" ,TRUNC(49.536 ,0)AS "个位",TRUNC(49.536 ,-1) "十位"
FROM SYS.DUAL
//trunc: 将值截断到指定的小数位
SELECT E.ENAME, E.SAL, MOD(E.SAL,300) AS "除以300后的余数"
FROM EMP E    
WHERE E.SAL IS NOT NULL;
MOD//返回相除后的余数

SELECT   ROUND(45.945,2) "小数点后两位",
         ROUND(45.945,0) "个位",
         ROUND(45.945,-1) "十位"
FROM SYS.DUAL  ;
round//进行四舍五入
使用日期函数
ADD_MONTHS(,＜i＞)
　返回日期d加上i个月后的结果。i可以使任意整数。如果i是一个小数，那么数据库将隐式的他转换成整数，
  将会截去小数点后面的部分。
LAST_DAY()
　函数返回包含日期d的月份的最后一天
缺省的日期格式是 DD-MON-YY
SYSDATE
　函数没有参数，返回当前日期和时间。

SELECT SYSDATE AS "时间"
FROM SYS.DUAL;

-- 日期-日期得到两个日期的差(是一个数值类型)
SELECT E.ENAME ,  (SYSDATE-E.HIREDATE)/7 AS "工作的周数"
FROM EMP E
WHERE E.ENAME  IS NOT NULL;
SYSDATE//返回当前日期和时间的函数

SELECT E.ENAME ,  ROUND ( (SYSDATE-E.HIREDATE)/7,0) AS "工作的周数"
FROM EMP E
WHERE E.ENAME  IS NOT NULL;

Round//取得按年或月四舍五入得到的新日期

日期+数值得到一个新的日期
SELECT E.ENAME,E.HIREDATE 雇用日期,(E.HIREDATE + 90) AS "转正日期"
FROM EMP E
WHERE E.ENAME IS NOT NULL;

 

SELECT E.ENAME ,MONTHS_BETWEEN(SYSDATE,E.HIREDATE) AS "工作的月数"
FROM EMP E;
MONTHS_BETWEEN//两日期相差多少月

转换函数和日期型
SELECT E.ENAME ,E.HIREDATE
FROM EMP E
WHERE E.HIREDATE > TO_DATE('23-9-1982','DD-MM-YYYY')

-- 日期类型转化为文本类型 ,TO_CHAR()函数的使用           
SELECT  E.ENAME ,e.hiredate, TO_CHAR(E.HIREDATE,'YYYY-MM-DD:DAY') AS "日期"
FROM EMP E
WHERE E.ENAME='SMITH'

SELECT TO_CHAR(SYSDATE,'YYYY-MM-DD HH24:MI:SS AM') 时间
FROM SYS.DUAL;

-- 使用9的时候,如果该位没有数字,则该位不显示
-- 使用0的时候,如果该位没有数字,则该位显示为0
SELECT  E.ENAME ,e.sal,TO_CHAR(E.SAL,'$99,999.99') AS "薪水"
FROM EMP E
WHERE E.ENAME IS NOT  NULL;

SELECT  E.ENAME ,e.sal,TO_CHAR(E.SAL,'L00,000.99') AS "薪水" ,TO_CHAR(E.SAL,'$99,999.99') "薪水2"
FROM EMP E
WHERE E.ENAME IS NOT  NULL;

SELECT  TO_DATE('1999-3-31','YYYY-MM-DD') AS 日期
FROM SYS.DUAL

SELECT *
FROM EMP E
WHERE E.HIREDATE <  TO_DATE('1981-12-17','YYYY-MM-DD')

SELECT *
FROM EMP E
WHERE E.HIREDATE <  '17-12月-1981'

 

SELECT  TO_NUMBER('$123,456.98','$999,999.99') AS "NUMBER"
FROM
SYS.DUAL

 

SELECT * FROM EMP for update

 

SELECT E.ENAME ,E.SAL , e.comm ,(E.SAL * 12 + E.COMM) AS "年收入"
FROM EMP E
WHERE E.ENAME IS NOT NULL;

-- 使用NVL函数,如果该字段为null,就用后面给的0替换该null值
SELECT E.ENAME ,E.SAL ,E.SAL * 12 ,E.COMM,(E.SAL * 12 + NVL(E.COMM,0)) AS "年收入"
FROM EMP E
WHERE E.ENAME IS NOT NULL;

 

空值的应用NVL NVL2 NULL
SELECT NVL(E.ENAME,'无名氏') as "姓名",E.SAL
FROM EMP E
NVL(COMM,0) //如果comm字段为null,就用0替换该null

SELECT * FROM EMP E FOR UPDATE;

 

-- 如果E.ENAME是null,就显示无名氏
-- 如果E.ENAME不是null,就显示E.ENAME
SELECT E.ENAME, NVL2(E.ENAME,E.ENAME,'无名氏') AS "NAME"
FROM EMP E
ORDER BY E.ENAME;
NVL2//如果expr不为Null,返回expr1, 为Null,返回expr2

SELECT * FROM EMP FOR UPDATE;

SELECT ENAME, LENGTH(ENAME) "expr1",
       ENAME,  LENGTH(ENAME)  "expr2",
       NULLIF(LENGTH(ENAME), LENGTH(JOB)) result
FROM   EMP;
NULLIF//比较两个表达式，如果相等返回空值，如果不等返回第一个表达式。

Case decode语句
SELECT E.ENAME ,E.JOB,E.SAL,
  CASE E.JOB
      WHEN 'CLERK'    THEN 1.10 * E.SAL
      WHEN 'MANAGER'  THEN 1.3 * E.SAL
      WHEN 'SALESMAN' THEN 1.45 * E.SAL
      ELSE  E.SAL
  END AS  "修订工资数"
FROM EMP E
WHERE E.ENAME='SMITH';

 

SELECT E.ENAME,E.JOB ,E.SAL ,
       DECODE(E.JOB, 'CLERK',E.SAL * 1.1,
                     'SALESMAN',E.SAL * 1.2,
                     'MANAGER' ,E.SAL * 1.4,
                     E.SAL)
         AS "工资修订数"                     
FROM EMP E

SELECT E.ENAME,E.JOB,NVL(TO_CHAR(E.JOB), '还没有工作') AS "结果"
FROM EMP E
WHERE E.JOB IS NULL;

多行函数
-- AVG,SUM只能针对数值类型
SELECT MIN(E.SAL) "最低工资",
       MAX(E.SAL) "最高工资",
       AVG(E.SAL) "平均工资" ,
       SUM(E.SAL) "工资总和"
FROM EMP E;

MIN,MAX可以用于任何数据类型
SELECT MAX(E.HIREDATE) ,MIN(E.HIREDATE)
FROM EMP E

SELECT MAX(E.HIREDATE),MIN(E.HIREDATE)
FROM EMP E;

SELECT * FROM EMP FOR UPDATE;
WHERE COMM IS NOT NULL;

SELECT * FROM EMP;

Count 统计数目
SELECT COUNT(*) FROM EMP;
COUNT(*)求出所有符 合条件的记录条数，包含有重复的

SELECT COUNT(COMM) FROM EMP;
COUNT(字段)这是求出所有符合条件并且字段值是
   非空的记录数，包含有重复的

SELECT COUNT(DISTINCT E.JOB) FROM EMP E;

SELECT COUNT(COMM)
FROM EMP;

SELECT JOB FROM EMP;

 

-- 查询job字段非空的数据的总数
SELECT COUNT(JOB)
FROM EMP;

-- 查询job字段非空的并且数据不重复的总数
SELECT COUNT(DISTINCT (JOB))
FROM EMP;

SELECT * FROM EMP FOR UPDATE;

SELECT SUM(E.COMM) "佣金总和" ,count(E.COMM) "总条数", AVG(E.COMM) "平均佣金" FROM EMP E

SELECT AVG(E.COMM), SUM(E.COMM) ,COUNT(E.COMM)
FROM EMP E

SELECT AVG(E.COMM)
FROM EMP E

SELECT sum(E.COMM)
FROM EMP E ;

SELECT AVG(NVL(E.COMM,0))
FROM EMP E ;

SELECT * FROM EMP FOR UPDATE;
分组函数GROUP BY
使用GROUP BY子句将表中的数据分成多个小组。分组后的数据执行组函数计算，结果返回给客户。最终的结果自动按照分组字段进行升序排列

-- 出现在查询列表中的字段,要么出现在组函数中,要么出现在GROUP BY字句中
-- (另一种情况,可以只出现在GROUP BY字句中)
SELECT  E.DEPTNO,AVG(E.SAL) AS "AVG"
FROM EMP E
GROUP BY E.DEPTNO
ORDER BY "AVG" ASC;

SELECT * FROM EMP;

SELECT AVG(E.SAL) AS "AVG"
FROM EMP E
GROUP BY E.DEPTNO
ORDER BY "AVG"

SELECT E.DEPTNO,E.JOB,SUM(E.SAL)
FROM EMP E
GROUP BY E.DEPTNO,E.JOB
order BY E.DEPTNO “AVG”/“DESC”;

-- 出现查询列表中的字段,要末出现在组函数中,要末出现在GROUP BY 子句中(必需要出现一次,不能都不出现)
SELECT E.DEPTNO,COUNT(E.ENAME)
FROM EMP E
GROUP BY E.DEPTNO

-- 原意是给分组函数加上限制条件,但是不能使用Where子句
SELECT E.DEPTNO,AVG(E.SAL)
FROM EMP E
WHERE AVG(E.SAL) > 3000
GROUP BY E.DEPTNO

 

SELECT E.DEPTNO,COUNT(E.ENAME)
FROM EMP E
GROUP BY E.DEPTNO;

SELECT E.DEPTNO,AVG(E.SAL)
FROM EMP E
WHERE AVG(E.SAL) > 3000
GROUP BY E.DEPTNO;

SELECT E.DEPTNO,MAX(E.SAL)
FROM EMP E
GROUP BY E.DEPTNO
HAVING MAX(E.SAL) >=3000;

SELECT E.JOB,SUM(E.SAL) AS "工资总和"
FROM EMP E
WHERE E.JOB IN('SALESMAN','MANAGER','CLERK')
GROUP BY E.JOB
HAVING SUM(E.SAL) > 3000
ORDER BY SUM(E.SAL);
对组的过滤不能出现在WHERE子句中，而是要使用查询语句的另一个子句：HAVING

SELECT AVG(E.SAL)
FROM EMP E
GROUP BY DEPTNO;

SELECT MAX(AVG(E.SAL))
FROM EMP E
GROUP BY E.DEPTNO

 

SELECT E.ENAME, E.JOB ,NVL(TO_CHAR(E.JOB),'还没有工作') AS "工作"
FROM EMP E
组函数忽略空值,可以使用NVL,NVL2,COALESCE 函数处理空值
SELECT MAX(E.SAL) AS "MAXSAL",MIN(E.SAL) AS "MINSAL",AVG(E.SAL) AS "AVGSQL" ,SUM(E.SAL) AS "SUMSAY"
FROM EMP E

SELECT MAX(E.ENAME) AS "MAXNAME" ,MIN(E.ENAME) AS "MINNAME"
FROM EMP E

SELECT COUNT(*)
FROM EMP E

SELECT COUNT(DISTINCT (E.JOB))
FROM EMP E

SELECT AVG(E.COMM) ,COUNT(E.COMM),SUM(E.COMM)
FROM EMP E

SELECT  AVG(NVL(E.COMM,0))
FROM EMP E
完整的SELECT查询语句的语法及执行顺序
SELECT column, group_function
FROM table
[WHERE condition]
[GROUP BY group_by_expression]
[HAVING group_condition]
[ORDER BY column];
在整个语句执行的过程中，首先执行的是WHERE语句，
   对表中的数据进行过滤；符合条件的数据通过GROUP BY
   进行分组；分组的数据通过HAVING子句进行组函数过滤；
   最终的结果通过ORDER BY 进行排序，排序后的结果返
   回给客户

SELECT AVG(E.SAL) AS "AVG"
FROM EMP E
GROUP BY E.DEPTNO
--ORDER BY "AVG"/“DESC”

SELECT E.DEPTNO,E.JOB ,SUM(E.SAL)
FROM EMP E
GROUP BY E.DEPTNO,E.JOB

SELECT E.DEPTNO, COUNT(E.ENAME)
FROM EMP E
GROUP BY E.DEPTNO

SELECT E.DEPTNO,AVG(E.SAL)
FROM EMP E
WHERE AVG(E.SAL) > 3000
GROUP BY E.DEPTNO

SELECT E.DEPTNO, MAX(E.SAL)
FROM EMP E
GROUP BY E.DEPTNO
HAVING MAX(E.SAL) > 3000

SELECT E.JOB,SUM(E.SAL)
FROM EMP E
WHERE E.JOB IN ('CLERK','SALESMAN','MANAGER')
GROUP BY E.JOB
HAVING SUM(E.SAL) > 3000
ORDER BY SUM(E.SAL);

函数的嵌套
SELECT  MAX(AVG(E.SAL))
FROM EMP E
GROUP BY E.DEPTNO ;

-- 查询所有的数据
SELECT * FROM EMP

QUERY查询语句
Oracle 8i以前的老标准的多表连接
 等值连接
 非等值连接
 外连接
 自连接

为了连接n个表，至少需要n-1个连接条件
当多个表中有重名列时，必须在列的名字前加上表名作为前缀，以便能够清晰的表明字段来自那个表

等值连接(＝)
SELECT E.ENAME,E.DEPTNO,D.DNAME
FROM EMP E, DEPT D
WHERE E.DEPTNO=D.DEPTNO AND E.ENAME='ALLEN';

SELECT E.ENAME,E.DEPTNO,D.DNAME,D.LOCATION_ID,L.LOCNAME
FROM EMP E,DEPT D,LOCATIONS L
WHERE E.DEPTNO=D.DEPTNO AND D.LOCATION_ID=L.LOCID AND E.ENAME='FORD';
非等值练级（<,>,<>,<=,>=,between/and,in,like）
SELECT E.EMPNO,E.SAL,S.GRADE,S.LOSAL,S.HISAL
FROM EMP E,SALGRADE S
WHERE E.SAL BETWEEN S.LOSAL AND S.HISAL

外连接（+）
--右连接，显示左边的表
SELECT E.ENAME,E.DEPTNO,D.DNAME
FROM EMP E, DEPT D
WHERE E.DEPTNO  = D.DEPTNO (+);

--左连接，显示右边的表
SELECT E.ENAME,E.DEPTNO,D.DNAME
FROM EMP E, DEPT D
WHERE E.DEPTNO (+) = D.DEPTNO ;
自连接
SELECT E.EMPNO,E.ENAME,M.EMPNO "经理编号",M.ENAME "经理名称"

FROM EMP E,EMP M

WHERE E.MGR = M.EMPNO  ;

Oracle 9i以后的新标准多表连接
 CROSS　JOIN——它在两个表格中创建了一个笛卡尔积，就象是在Oracle8i中没写WHERE时一样
 NATURAL JOIN——这是一个很有用的Oracle9i的句法，它通过从WHERE子句中自动连接标准来改善SQL的稳定性。表示作自然连接
 USING子句——它可以通过名字来具体指定连接
 ON子句——这个句法允许在两个表中为连接具体指定列名
 LEFT OUTER JOIN——它返回表格中左边的行和右边的数值，如果没有搭配的行的话，则返回空
 RIGHT OUTER JOIN——它返回表格中右边的行和左边的数值，如果没有搭配的行的话，则返回空
 FULL OUTER JOIN——它返回的是两个表格中所有的行，用空填满每一个空格。这在Oracle8i中则没有相应的此种句法

交叉连接（cross join）
SELECT E.ENAME,E.DEPTNO,D.DNAME
FROM EMP E
CROSS JOIN DEPT D;

自然连接（natural join）
SELECT E.ENAME,DEPTNO,D.DNAME
FROM EMP E
NATURAL  JOIN DEPT D;

SELECT D.DEPTNO,D.DNAME,L.LOCNAME
FROM DEPT D
NATURAL JOIN LOCATIONS L ;

INNER内链接(inner join..on…)即等值连接
SELECT E.EMPNO,E.ENAME, D.DEPTNO,D.DNAME,D.LOCATION_ID,L.LOCNAME
FROM DEPT D
INNER JOIN LOCATIONS  L ON(D.LOCATION_ID=L.LOCID)
INNER JOIN EMP        E ON(E.DEPTNO=D.DEPTNO) ;   

Join..using
SELECT E.EMPNO,E.ENAME,DEPTNO,D.DNAME
FROM EMP E
JOIN DEPT D USING(DEPTNO);
左外连接（left outer join...on..）

SELECT E.ENAME,E.DEPTNO,D.DNAME
FROM EMP E
LEFT OUTER JOIN DEPT D ON(E.DEPTNO = D.DEPTNO);

右外连接（right outer join ..on..）
SELECT E.ENAME,E.DEPTNO,D.DNAME
FROM EMP E
right OUTER JOIN DEPT D ON(E.DEPTNO = D.DEPTNO);

全外连接(full outer join)

SELECT E.ENAME,E.DEPTNO,D.DNAME
FROM EMP E
FULL OUTER JOIN DEPT D ON(E.DEPTNO = D.DEPTNO);

联合查询（Union）
--去掉重复的记录

SELECT D.DEPTNO, D.DNAME,D.LOCATION_ID FROM DEPT D
UNION
SELECT BK.DEPTNO , BK.DNAME,BK.LOCATION_ID FROM DEPT_BK BK;

--UNION 不去掉重复的记录

SELECT D.DEPTNO, D.DNAME,D.LOCATION_ID FROM DEPT D
UNION ALL
SELECT BK.DEPTNO , BK.DNAME,BK.LOCATION_ID FROM DEPT_BK BK;

子查询
 为了给主查询（外部查询）提供数据而首先执行的查询（内部查询）称为子查询
 可以给自查询起个别名：
单行子查询（<,>,<>,<=,>=,between/and,in,like）

SELECT E.*
FROM EMP  E
WHERE E.SAL < (SELECT SAL FROM EMP WHERE ENAME='ALLEN');

SELECT E.EMPNO,E.ENAME,E.JOB
FROM EMP E
WHERE  E.JOB = ( SELECT E.JOB
                 FROM EMP E
                 WHERE E.EMPNO=7566
                                   )  ;

SELECT E.ENAME,E.SAL
    FROM EMP E
    WHERE E.SAL > (SELECT  MIN(E.SAL)
                   FROM EMP E
                   GROUP BY DEPTNO
                   );

SELECT E.EMPNO,E.ENAME,E.JOB
FROM EMP E
WHERE  E.JOB = (SELECT E.JOB
                FROM EMP E
                WHERE E.EMPNO=8566
)  ;
多行子查询（in,all,any）              
--in              
SELECT E.*
FROM EMP E
WHERE E.JOB IN (SELECT SAL FROM EMP WHERE SAL >2000 )

 

< ALL 是小于子查询的最小值
-- > ALL 大于子查询的最大值
SELECT E.SAL
FROM EMP E
WHERE E.SAL > ALL (SELECT SAL FROM EMP WHERE DEPTNO=30)

 

< ANY 是小于子查询的最大值
-- > ANY 大于子查询的最小值
SELECT E.SAL
FROM EMP E
WHERE E.SAL < ANY (SELECT SAL FROM EMP WHERE DEPTNO=30)

SELECT E.DEPTNO,MIN(E.SAL)
    FROM EMP E
    GROUP BY E.DEPTNO
    HAVING   MIN(E.SAL) > (SELECT MIN(E.SAL)
                         FROM EMP E
                         WHERE E.DEPTNO='20' );
                  

SELECT * FROM DEPT
FOR UPDATE

 

 

 

 

DML记录操作语句(insert,delete,update,merge)
INSERT（插入记录）
INSERT INTO DEPT (DEPTNO,DNAME,LOCATION_ID) VALUES(41,'技术部',1000);

INSERT INTO DEPT (DEPTNO,DNAME,LOCATION_ID) VALUES(42,'软件部',null);

INSERT INTO DEPT (DEPTNO,DNAME) VALUES(43,'软件一部');

INSERT INTO DEPT_BK VALUES (44,'人事一部',1000);
DELETE（删除记录）
DELETE [FROM] DEPT_BK WHERE DEPTNO > 40;

DELETE EMP;//删除所有的记录

INSERT INTO DEPT_BK SELECT * FROM DEPT;

UPDATE（修改记录）
UPDATE DEPT SET DNAME='人事部',LOCATION_ID = 1000 WHERE DEPTNO=30;

SELECT * FROM DEPT_BK;

INSERT INTO EMP (EMPNO,HIREDATE) VALUES (8899,'12-6月-1984');
INSERT INTO EMP (EMPNO,HIREDATE) VALUES (8890, TO_DATE('1980-12-23','YYYY-MM-DD'));

MERGE
根据条件在表中执行修改或插入数据的功能，如果插入的数据行在目的表中存在就执行UPDATE，如果是不存在则执行INSERT:

MERGE INTO DEPT_BK  D
USING DEPT  S ON(D.DEPTNO=S.DEPTNO)
WHEN MATCHED THEN
   UPDATE  SET D.DNAME = S.DNAME,D.LOCATION_ID = S.LOCATION_ID
WHEN NOT MATCHED THEN
    INSERT  VALUES (S.DEPTNO,S.DNAME,S.LOCATION_ID);
事物控制语句（commit/rollback）

INSERT INTO DEPT VALUES (50,'开发',NULL);

SAVEPOINT A;

DELETE FROM DEPT D WHERE  D.DEPTNO > 30;

SAVEPOINT B;

UPDATE DEPT D SET D.DNAME='人事部' where d.deptno=10;

SAVEPOINT C;

ROLLBACK TO B;

COMMIT;

ROLLBACK TO A;

DDL语句  （create/drop/alter）

drop（表）

DROP TABLE TEST;

create （表）

CREATE TABLE TEST( 
   N1    NUMBER(4),
   N2    NUMBER(4,2),
   DATE1 DATE
);
子查询建表（AS）

CREATE TABLE EMP_BK
AS
SELECT * FROM EMP;

CREATE TABLE DEPT_BK
(D_ID,D_NAME)
AS
SELECT DEPTNO,DNAME FROM DEPT;

alter（表字段）
增加字段（add）
ALTER TABLE TEST ADD SEX CHAR(1);

修改字段(modify)
ALTER TABLE TEST MODIFY SEX char(10) default '男' ;

删除字段（drop）

ALTER TABLE emp DROP COLUMN AGE;

truncate(清除表中所有的记录)
--是DDL语句，效率高，不可以回滚，而DELETE语句可以ROLLBACK

TRUNCATE TABLE TEST;

rename(改变对象名称)
--对象的所有者才能修改对象的名字

RENAME TEST_1 TO TEST;

完整性约束和数据对象
对象名称 描述
表 基本的数据存储对象，以行和列的形式存在
约束 执行数据校验，保证数据完整性的对象
视图 一个或多个表数据的显示
索引 用于提高查询的速度
同义词 对象的别名

Oracle 支持下面五类完整性约束:
NOT NULL              非空
UNIQUE Key             唯一键
PRIMARY KEY             主键
FOREIGN KEY             外键
CHECK                  检察
非空、惟一性约束（not null / unique）
CREATE TABLE STUDENT(
   ID   NUMBER(4) PRIMARY KEY,
   NAME   VARCHAR2(20) CONSTRAINTS NAME_NN NOT NULL,
   EMAIL_1  VARCHAR2(50) ,
   EMAIL_2  VARCHAR2(50) ,
   CONSTRAINTS EMAIL_UNIQUE UNIQUE (EMAIL_1,EMAIL_2)
);

联合主键约束(primary key)
CREATE TABLE STU(
   FIRST_NAME VARCHAR2(20),
   LAST_NAME  VARCHAR2(20),
   CONSTRAINTS STU_PK PRIMARY KEY (FIRST_NAME,LAST_NAME)
)

外键约束(foreign key)

--在外键约束下,在建表的时候,先建主表,然后建立字表
CREATE TABLE DEPT_1(
   DEPT_ID   NUMBER(4) PRIMARY KEY,
   DEPT_NAME VARCHAR2(20)
);

CREATE TABLE EMP_1(
    E_ID    NUMBER(4) PRIMARY KEY,
    E_NAME  VARCHAR2(20),
    D_ID    NUMBER(4),
    CONSTRAINTS DEPT_1_EMP_1_FK FOREIGN KEY (D_ID) REFERENCES DEPT_1 (DEPT_ID)
);

--在外键约束下,在删除表的时候,先删除子表,然后删词主表
DROP TABLE EMP_1;
DROP TABLE DEPT_1;

--在外键约束下,在添加数据的时候,先添加主表的数据,在添加字表的数据
INSERT INTO EMP_1 VALUES (4000,'张三',1000);
INSERT INTO EMP_1 VALUES (4001,'张四',1000);
INSERT INTO EMP_1 VALUES (4002,'张五',null);
INSERT INTO DEPT_1 VALUES (1000,'人事部');

SELECT * FROM EMP_1;
SELECT * FROM DEPT_1;

--在外键约束下,在删除数据的时候,先删除字表的数据,在删除主表的数据
DELETE FROM EMP_1 ;
DELETE FROM DEPT_1;

check约束
CREATE TABLE EMPL(
      E_ID NUMBER PRIMARY KEY,
      E_NAME VARCHAR2(20) NOT NULL,
      E_SEX  VARCHAR2(4) ,
      E_SAL   NUMBER(8,2),
      E_GRADE VARCHAR2(30) NOT NULL,
      CONSTRAINT EMPL_MIN_SAL CHECK (E_SAL >0),
      CONSTRAINT AVAL_SEX CHECK (E_SEX IN ('男','女'))
      --CHECK (E_SEX IN ('男','女'))
);

INSERT INTO EMPL VALUES (1,'张三','男',2000);
INSERT INTO EMPL VALUES (2,'张四','女',-22000);
INSERT INTO EMPL VALUES (3,'张五','女',-100);

--可增加或删除约束，但不能直接修改
--增加约束
Alter Table emp_s
Add Constraint email_uk Unique (email);

--删除约束
ALTER TABLE DEPT_1  DROP PRIMARY KEY CASCADE;

索引（Index）
1. 当在表上定义一个PRIMARY KEY 或者UNIQUE 约束条件时,Oracle数据库自动创建一个对应的唯一索引.

CREATE INDEX EMP_INDEX_ENAME
   ON EMP (ENAME);
  
视图（view）
--在CREATE VIEW 语句中字段与子查询中的字段必须匹配.

CREATE OR REPLACE VIEW V_EMP_SAL
AS
SELECT E.EMPNO,E.ENAME,E.SAL
FROM EMP E  
WHERE E.ENAME IS NOT NULL
WITH READ ONLY;

--通过设置WITH READ ONLY选项可以禁止对视图执行DML操作.
CREATE OR REPLACE VIEW V_EMP_INFO
AS
SELECT E.EMPNO,E.ENAME,E.JOB,E.MGR,E.HIREDATE
FROM EMP E
WHERE E.ENAME IS NOT NULL

--删除视图(drop)
DROP VIEW V_EMP_SAL;

INSERT INTO V_EMP_SAL VALUES (9003,'AAA','2000.00');

TOP-N ( rownum / rowid )和行内视图
--rownum来说它是oracle系统顺序分配为从查询返回的行的编号
--rowid是物理地址，用于定位oracle中具体数据的物理存储位置

SELECT ROWNUM  ,ENAME,SAL
FROM (SELECT E.ENAME,E.SAL
             FROM EMP E        
             WHERE E.ENAME IS NOT NULL AND E.SAL IS NOT NULL
             ORDER BY E.SAL ASC)
WHERE ROWNUM <=3 ;

SELECT ROWNUM  ,ENAME, HIREDATE
FROM (SELECT E.ENAME,E.HIREDATE
             FROM EMP E        
             WHERE E.ENAME IS NOT NULL AND E.SAL IS NOT NULL
             ORDER BY E.HIREDATE ASC)
WHERE ROWNUM <=3 ;
--给rownum起个别名可以对其进行大于（>）操作
SELECT aa  ,ENAME, HIREDATE
FROM (SELECT rownum aa,E.ENAME,E.HIREDATE
             FROM EMP E        
             WHERE E.ENAME IS NOT NULL AND E.SAL IS NOT NULL
             ORDER BY E.HIREDATE ASC)
WHERE aa>3and aa<5;

PL/SQL程序块
主要有四类：
过程 执行特定操作
函数 进行复杂计算,返回计算的结果
包 将逻辑上相关的过程和函数组织在一起
触发器 事件触发，执行相应操作

PL/SQL子程序
PL/SQL子程序主要有两种类型
    1. 存储过程(PROCEDUER):用来完成某些操作的任务
    2. 函数(FUNCTION):用来作复杂的计算
PL/SQL子程序,是基于PL/SQL块的结构的,只是比PL/SQL块多了子程序头部的定义.使用PL/SQL子程序,使的PL/SQL程序易于维护,而且可以重复的使用
声明部分不再以DECLARE作为开头,而是以IS开始，不需要再使用DECLARE开始声明部分,IS就表示了声明部分的开始

匿名块
语法：
DECLARE
变量、常量声明;
BEGIN
pl/sql_block;
EXCEPTIONS
异常捕捉;
END;

1.使用SELECT 命令，可以从数据库中取出单行数据,语法略有变化select..into
2.使用DML(insert/delete/update)命令，修改数据库中的行,没有变化
3.通过EXECUTE IMMEDIATE，执行DDL和DCL语句

declare
  v_1 varchar2(20) ;
begin
  --v_1 := USER||': '||TO_CHAR(SYSDATE);
 
   v_1 := USER||': '||SYSDATE;
   dbms_output.put_line(v_1);
end;
%type/%rowtype

declare
  v_id            employees.empl_id%type := 1005;
  v_hiredate      employees.hire_date%type  := '23-4月-1978';
  v_sal           employees.salary%type := 3000;
  v_deptid        employees.department_id%type   := 2000;
BEGIN
  insert into employees values(v_id,v_hiredate,v_sal,v_deptid);
  commit;
END;

declare
  v_emp employees%rowtype;
begin
  select * into v_emp from employees where empl_id = 1003;
  dbms_output.put_line(v_emp.empl_id || '----' || v_emp.hire_date ||
                       '----' || v_emp.salary || '----' ||
                       v_emp.department_id);
end;

嵌套块
declare
   v_weight number(3) := 100;
begin
   -----------------嵌套块---------------------
   declare
        v_weight number(3) := 1;
   begin
        v_weight := v_weight +1;
        dbms_output.put_line('在嵌套块中v_weight的值是:'|| v_weight);               
   end;
   --------------------------------------------
   v_weight := v_weight +1;
   dbms_output.put_line('在嵌套块外v_weight的值是:' ||  v_weight);
end;
select..into
declare
    v_hire_date     employees.hire_date%type;
    v_department_id employees.department_id%type;
begin  
    select hire_date,department_id    into v_hire_date,v_department_id   
    from employees    where empl_id =1000;  
    dbms_output.put_line (v_hire_date ||'----' || v_department_id );
end;

declare
  v_avg_salary employees.salary%type;
begin
  select avg(salary) into v_avg_salary from employees;
  dbms_output.put_line('平均工资是' || ':' || v_avg_salary);
end;

使用EXECUTE IMMEDIATE执行DDL语句
begin

   execute immediate 'create table temp(
        id number(4) primary key,
        name varchar2(20)
   )';
   execute immediate 'drop table temp'; 
end;

流程控制语句
条件控制结构(IF语句)
循环控制语句
       基本循环
       FOR循环
       WHILE循环
       EXIT语句
      
if-then..elsif-then..else..
declare
    v1 number(4) := 100;
    v2 number(4) := 101;
    v3 boolean  := (v1=v2);
begin
    if(v3) then
       dbms_output.put_line('true');
    else
       dbms_output.put_line('false');  
    end if;
end;

declare
  V_SAL EMP.SAL%TYPE;
begin
  SELECT SAL INTO V_SAL FROM EMP WHERE EMPNO = 7698;
  IF (V_SAL < 1000) THEN
    UPDATE EMP SET COMM = V_SAL * 0.8 WHERE EMPNO = 7698;
  ELSIF (V_SAL < 2000) THEN
     UPDATE EMP SET COMM = V_SAL * 1.0 WHERE EMPNO = 7698; 
  ELSE
    UPDATE EMP SET COMM = V_SAL * 1.2 WHERE EMPNO = 7698;
  END IF;
  COMMIT;
end;

循环语句
简单循环(loop..exit when..end loop;)
FOR 循环(for index in lower_bound..upper_bound LOOP....end loop; )
WHILE 循环(while..loop..end loop;)

loop简单循环

BEGIN
  DELETE FROM TEST;
  FOR V_COUNT IN REVERSE 1 .. 10 LOOP
    INSERT INTO TEST VALUES (V_COUNT, 'aaaa');
  END LOOP;
  COMMIT;
END;

DROP TABLE TEST;
CREATE TABLE TEST(
  ID NUMBER(4) PRIMARY KEY,
  NAME VARCHAR2(10)
);

DECLARE
  V_COUNT NUMBER(2) := 0;
BEGIN
  DELETE FROM TEST;
  LOOP
    INSERT INTO TEST VALUES (V_COUNT, 'AAAA');
    V_COUNT := V_COUNT + 1; 
    EXIT WHEN V_COUNT >= 10;
  END LOOP;
  COMMIT;
END;

 

DECLARE
  V_COUNT NUMBER(3) := 0;
BEGIN
  DELETE FROM TEST;
  LOOP
    INSERT INTO TEST VALUES (V_COUNT, 'bbb');
    V_COUNT := V_COUNT + 1;
    exit when v_count<10;
  END LOOP;
  COMMIT;
END;
for循环

BEGIN
  DELETE FROM TEST;
  FOR V_COUNT IN REVERSE 1 .. 10 LOOP
    INSERT INTO TEST VALUES (V_COUNT, 'aaaa');
  END LOOP;
  COMMIT;
END;

WHILE循环
DECLARE
  V_COUNT NUMBER(3) := 0;
BEGIN
  DELETE FROM TEST;
  WHILE V_COUNT < 10 LOOP
    INSERT INTO TEST VALUES (V_COUNT, 'bbb');
    V_COUNT := V_COUNT + 1;
  END LOOP;
  COMMIT;
END;

 

SQL 游标
隐式游标(SQL%ROWCOUNT /SQL%FOUND/SQL%NOTFOUND/SQL%ISOPEN)

显式游标(%ROWCOUNT /%FOUND/%NOTFOUND/%ISOPEN)

隐式SQL 游标
DECLARE
  V_COUNT NUMBER(3);
BEGIN
  DELETE FROM EMP E WHERE E.DEPTNO = 30;
  V_COUNT := SQL%ROWCOUNT;
  DBMS_OUTPUT.put_line('总共删除数据：' || v_count || ' 条');
  COMMIT;
END;
/

显式游标
--取一条
DECLARE
  V_EMP_RECORD    EMP%ROWTYPE;
  CURSOR EMP_CUR IS
    SELECT * FROM EMP;
BEGIN
  OPEN EMP_CUR;
  FETCH EMP_CUR
    INTO V_EMP_RECORD;
  DBMS_OUTPUT.put_line(V_EMP_RECORD.EMPNO || V_EMP_RECORD.ENAME);
  CLOSE EMP_CUR;
END;
/

--loop
DECLARE
   V_EMP_RECORD EMP%ROWTYPE;
   CURSOR EMP_CUR IS SELECT * FROM EMP;
BEGIN
   OPEN EMP_CUR;
   LOOP
       FETCH EMP_CUR INTO V_EMP_RECORD;
          EXIT WHEN EMP_CUR%NOTFOUND;
       DBMS_OUTPUT.put_line('----'||V_EMP_RECORD.EMPNO ||V_EMP_RECORD.ENAME);
    END LOOP;
   
  
    CLOSE EMP_CUR;
     DBMS_OUTPUT.put_line('总共有数据:' ||EMP_CUR%rowcount );
END;
/
--while
DECLARE
  V_EMP_RECORD EMP%ROWTYPE;
  CURSOR EMP_CUR IS
    SELECT * FROM EMP;
BEGIN
  OPEN EMP_CUR;
  FETCH EMP_CUR
    INTO V_EMP_RECORD;
  WHILE EMP_CUR%FOUND LOOP
    DBMS_OUTPUT.put_line(V_EMP_RECORD.EMPNO || V_EMP_RECORD.ENAME);
    FETCH EMP_CUR
      INTO V_EMP_RECORD;
  END LOOP;
  DBMS_OUTPUT.put_line('共有数据：' || EMP_CUR%ROWCOUNT);
  CLOSE EMP_CUR;
END;
/

 

--for循环
DECLARE
   CURSOR EMP_CUR IS SELECT * FROM EMP ;
BEGIN
    FOR V_EMP IN EMP_CUR LOOP  //不用声明V_EMP  
        DBMS_OUTPUT.put_line(V_EMP.EMPNO|| V_EMP.ENAME);  
    END LOOP;
END;

--带参数的游标
 在调用时，通过给定不同的参数得到不同的结果集

DECLARE
    V_EMP_RECORD     EMP%ROWTYPE;
    CURSOR EMP_CUR( V_DEPTNO NUMBER ) IS SELECT * FROM EMP
              WHERE DEPTNO=V_DEPTNO;   
BEGIN
   OPEN EMP_CUR(30);
   LOOP
      FETCH EMP_CUR INTO V_EMP_RECORD;
      EXIT WHEN EMP_CUR%NOTFOUND;
      DBMS_OUTPUT.put_line(V_EMP_RECORD.EMPNO ||
                                                V_EMP_RECORD.ENAME);
   END LOOP; 
   CLOSE EMP_CUR;
END;

-- WHERE CURRENT OF
DECLARE
  CURSOR EMP_CUR IS
    SELECT EMPNO, SAL FROM EMP WHERE COMM IS NULL FOR UPDATE;
  V_COMM NUMBER(8, 2);
BEGIN
  FOR V_EMP_RECORD IN EMP_CUR LOOP
    IF V_EMP_RECORD.SAL < 1000 THEN
      V_COMM := V_EMP_RECORD.SAL * 0.15;
    ELSIF V_EMP_RECORD.SAL < 2000 THEN
      V_COMM := V_EMP_RECORD.SAL * 0.25;
    ELSIF V_EMP_RECORD.SAL < 3000 THEN
      V_COMM := V_EMP_RECORD.SAL * 0.30;
    ELSE
      V_COMM := V_EMP_RECORD.SAL * 0.35;
    END IF;
    UPDATE EMP SET COMM = V_COMM WHERE CURRENT OF EMP_CUR;
  END LOOP;
  COMMIT;
END;

存储过程（procedure..is..begin..end;）
-- 准备数据
drop table empl;
create table empl(e_id number(5), e_name varchar2(20), e_salary number(8,2) );

创建存储过程
--
drop procedure insert_empl;
CREATE OR REPLACE PROCEDURE insert_empl(V_ID [in] NUMBER,
                                        V_NAME VARCHAR2,
                                        V_SAL IN NUMBER) IS
  v_1 number(4);--声明的变量
BEGIN
  v_1 := 1000;
  INSERT INTO EMPL VALUES (V_ID, V_NAME, V_SAL);
  COMMIT;
  DBMS_OUTPUT.put_line('数据插入成功！' || v_1);
EXCEPTION
  WHEN OTHERS THEN
    DBMS_OUTPUT.put_line('发生异常');
END;

-- 执行存储过程
INSERT_EMPL(1,'AAA',3300); -- 在command窗口指向

BEGIN
   INSERT_EMPL(2,'BBB',4000);
END;

不同参数模式的存储过程

IN                    OUT                   IN-OUT
默认                必须指定                必须指定
值被：
传递给子程序    返回到调用环境         传递给子程序，返回到调用环境
参数形式：
常量             未初始化的变量            初始化的变量.
可以是表达式， 必须是一个变量           必须是一个变量
常量，或者是
初始化的变量

   create or replace procedure pararm_test(v_in     in varchar2,
                                           v_out    out varchar2,
                                           v_in_out in out varchar2) is
     v_localtion varchar2(20);
   begin
     v_localtion := v_in;
     dbms_output.put_line(v_in_out);
     v_out := '从存储过程中返回的'; ----out类型的--- 参数’;
              v_in_out := '从存储过程中返回的' ;----int_out类型的--- 参数’;
              dbms_output.put_line(v_in);
   end;
  
  
   / --调用存储过程
set serveroutput on; --在command windows 执行dbms_output.put_line语句中可以打印出来数据
  
   declare
     v_in_par     varchar2(20) := 'in类型参数';
     v_in_out_par varchar2(255);
     v_out_par    varchar2(255) := 'in_out类型参数';-- 也可以不初始化
   begin
     pararm_test(v_in_par, v_out_par, v_in_out_par);
     dbms_output.put_line(v_in_out_par);
     dbms_output.put_line(v_out_par);
   end;

2.

CREATE OR REPLACE PROCEDURE insert_out(v_name varchar2,
                                       v_age  integer,
                                       v_sex  char,
                                       mes    in out varchar2,flag out varchar2) IS
  in_out varchar2(20);
BEGIN
  INSERT INTO STUDENT VALUES (STU_PK.NEXTVAL, v_name, v_age, v_sex);
  in_out := mes;
  mes    := '已经插入成功';
  dbms_output.put_line(in_out);
flag := '已经返回';
  COMMIT;
END;

declare
in_out_mes varchar2(20) := '已经传值进去了';
out_flag  varchar2(10);
begin
insert_out('rrr',13,'女',in_out_mes,out_flag);
dbms_output.put_line(in_out_mes);
dbms_output.put_line(out_flag);
end;

银行转账业务的存储过程：
Create or replace procedure change_count(id1     in number,
                                         id2     in number,
                                         money   in number,
                                         out_ret out varchar2) is
  id1_exist      number;
  id2_exist      number;
  id1_price_temp counts.price%type;
  id2_price_temp counts.price%type;
begin
  select count(*) into id1_exist from counts where id = id1;
  select count(*) into id2_exist from counts where id = id2;
  if (id1_exist = 1 and id2_exist = 1) then
    select price into id1_price_temp from counts where id = id1;
    select price into id2_price_temp from counts where id = id2;
    if (id1_price_temp >= money) then
      update counts set price = id1_price_temp - money where id = id1;
      update counts set price = id2_price_temp + money where id = id2;
      commit;
    else
      --转出帐号余额不足
      out_ret := '400';
    end if;
  else
    --id1 或者id2帐号不存在
    out_ret := '300';
  end if;
end change_count;

 

函数（function）
--创建
CREATE OR REPLACE FUNCTION tax
(v_value IN NUMBER)
RETURN NUMBER
IS
BEGIN
IF v_value < 1000 THEN
RETURN (v_value * .10);
  ELSE
RETURN (v_value * .15);
END IF
END tax;

--调用
DECLARE
  V_VALUES_OUT NUMBER(10);
BEGIN
   V_VALUES_OUT := tax(10000);
   dbms_output.put_line(V_VALUES_OUT);
END;
/

  SELECT sal, tax(SAL) as "税金" FROM EMP;

 

包（package）

-----------包的声明和使用1-------------------------
DROP TABLE employees;
CREATE TABLE employees(
   id number(5) primary key,
   name varchar2(30),
   commission_pct number(3,2 )
);

insert into employees values (1,'张一',0.13);
insert into employees values (2,'张二',0.23);
insert into employees values (3,'张三',0.33);
insert into employees values (4,'张四',0.43);
commit;

select * from employees;

--创建包头
CREATE OR REPLACE PACKAGE comm_package IS
  g_comm NUMBER := 0.10; 
  PROCEDURE reset_comm (p_comm  IN  NUMBER);
END comm_package;
/

--创建包体
CREATE OR REPLACE PACKAGE BODY comm_package
IS
  
  
   -------------在包体中定义的局部函数--------------
   /*
   如果输入的参数p_comm大于employees表中最大的commission_pct
   字段,则函数返回FALSE,否则函数返回TRUE
   */
   FUNCTION  validate_comm (p_comm IN NUMBER)
      RETURN BOOLEAN
   IS
     v_max_comm    NUMBER;
   BEGIN
     SELECT    MAX(commission_pct)
      INTO     v_max_comm
      FROM     employees;
     IF   p_comm > v_max_comm THEN
        RETURN FALSE ;
     ELSE  
        RETURN TRUE ;
     END IF;
   END validate_comm;
   ---------在包体中定义的局部函数:结束------------

   ------------完成在包体中声明的过程--------------
   PROCEDURE  reset_comm (p_comm   IN  NUMBER)
   IS
   BEGIN
    IF  validate_comm(p_comm)     THEN  
      g_comm:=p_comm; 
    ELSE
      RAISE_APPLICATION_ERROR(-20210, '不合理的表达式');
    END IF;
   END reset_comm;
   ----------完成在包体中声明的过程:结束------------

END comm_package;

--测试包
EXECUTE comm_package.reset_comm(1);
EXECUTE comm_package.reset_comm(.33);

-- 测试包里定义的公共变量
begin
   comm_package.reset_comm(0.15);
   dbms_output.put_line('g_comm = ' || comm_package.g_comm );
end;
/

--以scott登陆,测试包
EXECUTE test.comm_package.reset_comm(0.15);
begin
   test.comm_package.reset_comm(0.15);
   dbms_output.put_line('g_comm = ' || test.comm_package.g_comm );
end;
/

-----------包的声明和使用2-------------------------
drop table employee;
create table employee(
   id number (5),
   name varchar2(30),
   salary number(8,2)
);

insert into employee values(1,'张一',3000);
insert into employee values(2,'张二',3400);
insert into employee values(3,'张三',5600);
commit;

create or replace package tax_pkg as
  function tax(v_value in number) return number;
end tax_pkg;
/

create or replace package body tax_pkg
as
   -------------包体中的函数执行部分---------------
   function tax(v_value in number) return number
   is
   begin
if v_value < 1000 then
   return (v_value * 0);
elsif v_value < 5000 then
   return (v_value * 0.10);
elsif v_value <10000 then
   return (v_value * 0.15);
else
   return (v_value * 0.20);
end if;
    end tax;
    -------------包体中的函数:结束-----------------
end tax_pkg;
/

-- 测试包中定义的函数
select salary,tax_pkg.tax(salary) from employee;
--删除包
包头和包体是两种数据库对象，可以独立的存在
在删除时，可以分别删除；在删除包体时，包头不会受到影响。但是在删除包头时，相关的包体也会被删除
    DROP PACKAGE packae_name;
    DROP PACKAGE  BODY packae_name;

触发器（trigger）
在Oracle数据库中主要有二种触发器类型：
DML触发器(INSERT，UPDATE，DELETE三种触发器)
触发的时机包括：对表来说有before或aftet触发，对视图来说有INSTEAD OF

系统触发器

对表操作时间限制的触发器

CREATE OR REPLACE TRIGGER secure_emp_1 --这里不能有IS
  BEFORE INSERT ON employees  -- 这里没有分号
BEGIN
   IF (TO_CHAR (SYSDATE,'DY') IN ('STA','SUN') OR (TO_CHAR(SYSDATE,'HH24:MI') NOT BETWEEN '08:00' AND '18:00' )) THEN
     RAISE_APPLICATION_ERROR(-20500,'你只能在工作时间对表进行操作');
   END IF; 
END;

语句级DML触发器
CREATE OR REPLACE TRIGGER secure_emp_2
  BEFORE INSERT OR UPDATE OR DELETE ON employees
BEGIN
  --如果当前时间是周六或周日 或者时间不在8:00-18:00之间
  IF (TO_CHAR(SYSDATE, 'DY') IN ('SAT', 'SUN')) OR
     (TO_CHAR(SYSDATE, 'HH24') NOT BETWEEN '08' AND '18') THEN
    IF DELETING THEN
      RAISE_APPLICATION_ERROR(-20501, '你只能在工作时间删除员工表的数据');
    ELSIF INSERTING THEN
      RAISE_APPLICATION_ERROR(-20500, '你只能在工作时间插入员工表的数据.');
    ELSIF UPDATING('SALARY') THEN
      RAISE_APPLICATION_ERROR(-20503, '你只能在工作时间更新员工表的数据');
    ELSE
      RAISE_APPLICATION_ERROR(-20504, '你只能在工作事件操作员工表的数据.');
    END IF;
  END IF;
END;
行级DML触发器（for each row）
FOR  EACH  ROW：表明对表中的每行数据操作时都会处分这个触
发器REFERENCING子句是说明触发器替换值的前缀名，默认替换
前的前缀名为old，替换后的前缀名为NeW。也可以自己声明替换前
后变量的的前缀规则
2.
 在行级触发器中，可以通过old和new这两种前缀来引用DML操作前后的两种值。
 在插入事件中可以使用new，但是不能使用old
 在更新时间中可以使用old来引用老的书籍，使用new来引用新的数据
 在删除时间中，只能使用old前缀

--1、编写一个数据库触发器以显示当任何时候雇员加薪时的加薪情况--

CREATE OR REPLACE TRIGGER EMP_SAL
AFTER UPDATE OF SAL ON EMP FOR EACH ROW--语句级触发器
BEGIN
DBMS_OUTPUT.put_line(:OLD.ENAME||'更新前的工资为：'||:OLD.SAL||'更新后的工资情况为：'||:NEW.SAL);
END;

UPDATE EMP E SET E.SAL=2200 WHERE E.JOB='MANAGER' ;--只有在update sal的时候才会触动触发器

UPDATE EMP E SET E.EMPNO=11 WHERE E.ENAME='CLACK' ;--不会触动触发器

SELECT * FROM EMP;

--2、编写一个数据库触发器，它允许用户只在上午9:00到下午5:00之间执行dml任务-----
CREATE OR REPLACE TRIGGER EMP_DML
  BEFORE INSERT OR DELETE OR UPDATE ON EMP
  FOR EACH ROW
DECLARE—-可以出现declare 语句
  V_TIME VARCHAR2(10);
BEGIN
  V_TIME := TO_CHAR(SYSDATE, 'HH24');
  IF (TO_NUMBER(V_TIME) < 9 OR TO_NUMBER(V_TIME) > 17) THEN
    raise_application_error(-20008, '现在不允许执行DML任务');--编码可变
  END IF;
END;

DELETE FROM EMP;

--3、编写一个数据库触发器，当任何时候某个部门从"dept"中删除时，
-----该触发器将从"emp"表中删除该部门的所有雇员

create or replace trigger dept_emp_delete
before delete on dept
for each row
declare
d_depno dept.deptno%type;
begin
d_depno :=:old.deptno;
delete from emp where emp.deptno=d_depno;
end;

delete from dept where dept.deptno=20;
instead of 对视图操作
create or replace trigger new_view_emp_dept
   instead of insert on v_empl for each row—视图
begin
    if inserting then
       insert into departments values(:new.department_id,:new.dept_name);
       insert into employees –转换成对表的操作               
values(:new.employee_id,:new.employee_name,:new.department_id);
    end if;
end;
管理触发器

 启用或者禁用某个触发器
 ALTER TRIGGER trigger_name  DISABLE | ENABLE

 启用或者禁用某个对象上的所有触发器
 ALTER TABLE table_name   DISABLE | ENABLE  ALL TRIGGERS

 重编译触发器
 ALTER TRIGGER trigger_name COMPILE

数据库系统级触发器（登录/退出触发器）
CREATE OR REPLACE TRIGGER logon_trig
AFTER LOGON  ON  SCHEMA
BEGIN
INSERT INTO log_trig_table(user_id, log_date, action)
VALUES (USER, SYSDATE, 'Logging on');
END;

CREATE OR REPLACE TRIGGER logoff_trig
BEFORE LOGOFF  ON  SCHEMA
BEGIN
INSERT INTO log_trig_table(user_id, log_date, action)
VALUES (USER, SYSDATE, 'Logging off');
END;

PL/SQL 中的异常处理
捕获异常：语法
1.预定义的oracle 数据库错误
2.非预定义的oracle 数据库错误
3.用户定义的错误

EXCEPTION
  WHEN exception1 THEN..WHEN OTHERS THEN..
 
预定义异常
 预定义异常就是Oracle中已经预先定义好名称的异常

DECLARE
    V_EMP_RECORD    EMP%ROWTYPE;
    V_1             NUMBER(4,2);

BEGIN
   V_1 := 12;  --这里会发生一个异常
   SELECT * INTO V_EMP_RECORD FROM EMP WHERE DEPTNO=10; --这里会发生一个数据过多的异常 ，但不被执行
   DBMS_OUTPUT.put_line('---------------------');
EXCEPTION
  WHEN NO_DATA_FOUND THEN
      DBMS_OUTPUT.put_line('没有合适的数据异常');
  WHEN TOO_MANY_ROWS THEN
       DBMS_OUTPUT.put_line('数据过多的异常'); 
  WHEN VALUE_ERROR THEN
       DBMS_OUTPUT.put_line('赋值异常'); 
  WHEN OTHERS THEN
       DBMS_OUTPUT.put_line('遇到其他的异常');   
END;
非预定义异常
 为了捕获非预定义的异常,必须先创建一个异常名称,然后将错误编号和刚创建的异常关联起来

DECLARE
   V_EMP_REMAINING EXCEPTION;
   PRAGMA EXCEPTION_INIT(V_EMP_REMAINING, -02292);
BEGIN
   DELETE FROM DEPT WHERE DEPTNO =20;
EXCEPTION
   WHEN V_EMP_REMAINING THEN
     DBMS_OUTPUT.put_line('违反完整性约束');
   WHEN OTHERS THEN
     DBMS_OUTPUT.put_line('其他错误');
END;

用户定义异常(raise exception)
 而用户定义异常是对数据库的操作不符合用户的业务时,人为定义的异常.这类异常不是数据库的错误,所以没有对应的错误代码.而且数据库在执行时不会主动的认为是异常.

drop table sm_emp;
CREATE TABLE sm_emp(
   no char(4),
   name char(10),
   salary number(6,2),
   phone char(8)
);

--insert TOM
INSERT INTO sm_emp VALUES ('001','TOM',999.99,'62543678');
INSERT INTO sm_emp VALUES ('002','TOM2',999.99,'62543678');
INSERT INTO sm_emp VALUES ('003','TOM3',999.99,NULL);

commit;

--如果用户的电话为null,则认为发生一个异常

DECLARE
  CURSOR C_SM IS
    SELECT * FROM SM_EMP;
  PHONE_EXCEPTION EXCEPTION;
  V_NAME SM_EMP.NAME%TYPE;
BEGIN
  FOR V_EMP IN C_SM LOOP
    IF (V_EMP.PHONE IS NULL) THEN
      V_NAME := V_EMP.NAME;
      RAISE PHONE_EXCEPTION;
    END IF;
  END LOOP;
EXCEPTION
  WHEN PHONE_EXCEPTION THEN
    DBMS_OUTPUT.PUT_LINE(V_NAME || '的电话不能为空');
END;

--为了能够记录发生的异常信息，Oracle提供了两个函数
     1.SQLCODE
返回错误代码，NUMBER类型
    2. SQLERRM
返回与错误代码关联的消息；VARCHAR2类型

建立一个错误日志表(SQLERRM/ SQLCODE)

DROP TABLE ERR_LOG;

CREATE TABLE ERR_LOG (
    CODE NUMBER(10),
    MESSAGE VARCHAR2(255),
    ERRDATE  DATE
);

drop table test;
create table test (
   id number(5) primary key ,
   name varchar2(20),
   salary number(8,2)
);

DECLARE
  V_CODE    ERR_LOG.CODE%TYPE;
  V_MESSAGE ERR_LOG.MESSAGE%TYPE;
  V_DATE    ERR_LOG.ERRDATE%TYPE;
BEGIN
  INSERT INTO TEST VALUES (1, 'AAA', 3000);
  INSERT INTO TEST VALUES (1, 'BBB', 2000); --这里将会出现主键重复异常
EXCEPTION
  WHEN OTHERS THEN
    V_CODE    := SQLCODE;
    V_MESSAGE := SQLERRM;
    V_DATE    := SYSDATE;
    INSERT INTO ERR_LOG VALUES (V_CODE, V_MESSAGE, V_DATE);
    COMMIT;
    DBMS_OUTPUT.PUT_LINE('发生错误');
     DBMS_OUTPUT.PUT_LINE(SQLCODE);
     DBMS_OUTPUT.PUT_LINE(SQLERRM);
END;

SELECT * FROM DEPT;
SELECT * FROM ERR_LOG;