oracle入门

Posted 2021-01-01 it~沃克尔

### 一，视图

```
1. 什么是视图
    视图是一张虚表, 可以把视图看成表使用（增删改查），视图中没有数据，所有的数据都在基本表中(tables)
    封装了一个复杂的DQL
    操作视图就是操作table
    视图一般不作为修改数据使用， 只用作查询
2. 语法
    create [or replace] view 视图名 as DQL；
3. 栗子
    create or replace view emp_view as select * from emp;

    select * from emp_view;
    select * from emp;

    insert into emp_view(empno ,ename) values(1000, ‘rose‘);
    -- 作用一 ： 可以屏蔽敏感列
    create or replace view employee
    as select empno ,ename ,job ,mgr, hiredate ,deptno from emp;  
    select * from emp_view;
    -- 作用二：可以定义只读的视图
    create or replace view employee
    as select empno ,ename ,job ,mgr, hiredate ,deptno from emp with read only;  
    -- 错误：virtual column not allowed here
    insert into employee(empno ,ename) values(1001, ‘rose‘);
    
    
```

### 二、索引

```
1. 索引的目的
    提高检索效率
    前提：百万条记录以上， 不经常的修改列 , 经常查询的列
2. 语法： create index 索引  on 表(列1,列2)
3. 测试效率
    准备表,数据
    create table a(
       b number primary key ,
       c varchar2(200)
    )

    create sequence a_seq;

    select sys_guid() from dual;

    declare

    begin
           for i in 1..1000000 loop
               insert into a values(a_seq.nextval ,sys_guid() );
           end loop;
    end;
    添加索引前查询
    select * from a where c = ‘1407AB1D7E26496797E63E2C7DA76DB9‘; -- 0.546
    添加索引
    create index a_index on a(c);
    添加索引后查询
    select * from a where c = ‘9C4CD7D2251348E4B02756BEE7558C46‘; -- 0.063
4. 复合索引的触发条件(了解)   address  age
   where address = ‘‘ and age = ‘‘   触发索引
   where address = ‘‘ or age = ‘‘    不能触发索引
   where address = ‘‘     触发索引
   where age = ‘‘    不能触发索引   
```

### 三、plsql的基本语句（过程化语言）

```
1. plsql  P: procedure 过程化
2. 过程化语言的基本结构
    declare
        -- 声明语句
    begin
        --- 过程化语言
    [exception]
    end;
3. 声明变量
    declare
        -- 声明普通变量
        i  number;
        -- 声明变量且赋值
        j number default 200;
        -- 引用类型：引用某表.某列的类型
        pname emp.ename%type;
        pjob emp.job%type;
        -- 记录类型：引用表的一行的列
        emp_row emp%rowtype;
    begin
        -- 赋值语句
        i := 100;
        -- 打印
        dbms_output.put_line(i);
        --  || 连接符
        dbms_output.put_line(‘j = ‘ || j);
        --赋值语句： select 查询的列 into 变量;
        select ename, job into pname,pjob from emp where empno = 7788;
        dbms_output.put_line(pname || ‘::‘ ||pjob);

        select * into emp_row from emp where empno = 7788;
        dbms_output.put_line(emp_row.ename || ‘::‘ ||emp_row.job || emp_row.hiredate);
    end;
4 . if语句
    格式
    if 条件 then
         SQL语句;
    end if;
    if 条件 then
         SQL语句;
    else
        sql语句;
    end if;
    if 条件 then
         SQL语句;
    elsif 条件 then
        sql语句;
    ....
    else
        sql语句;
    end if;
-- 输入一个整数，如果大于0，打印正数，如果小于，打印负数,否则打印零
declare
   i number;

begin
   i := &请输入;
   if i > 0 then
     dbms_output.put_line(‘正数‘);
   elsif i<0 then
     dbms_output.put_line(‘负数‘);
   else
     dbms_output.put_line(‘零‘);
   end if;
end;
5. 循环
 1） for 循环
     /*
         for 变量  in 集合|游标 loop
         
         end loop;
     */-- 打印1-10所有的整数
declare

begin
  for i in 1..10 loop
    dbms_output.put_line(i);
  end loop;
end;
2) 语法
    /*    
        loop
            循环体;
            退出条件； exit when 条件;
        end loop;
    */
    -- 打印1-10所有的整数
    declare
       i number default 1;
    begin
      loop
        dbms_output.put_line(i);
        exit when i = 10;
        i := i + 1;
      end loop;
    end;
  3) 语法
      /*
          while 条件 loop
              循环体;
          end loop;
      */
      -- 打印1-10所有的整数
declare
   i number default 1;
begin
  while i <= 10 loop
    dbms_output.put_line(i);
    i := i + 1;
  end loop;
end;
```

### 四、游标

```
1. 什么是游标(主要使用在存储过程中)
    就是一个集合
    主要作用处理返回多行记录的问题
2. 声明游标
    cursor 游标名 is DQL；
3. 遍历游标
    1） 打开游标
        open 游标名
    2) 提取单行的记录
        fetch 游标名 into 变量中;
    3) 使用循环
        结束语句： exit when 游标名%notfound;
    4) 关闭游标
        close 游标名;
4. 栗子
    -- 使用游标在控制台打印20号部门的员工信息
    declare
       cursor cur is select * from emp where deptno = 20;
       erow emp%rowtype;
    begin
        open cur;
         loop
          fetch cur into erow;
          exit when cur%notfound;  -- 判断是否提取到了记录
          dbms_output.put_line(erow.empno || erow.ename ||erow.job);   
        end loop;
        close cur;
    end;
    select * from emp where deptno = 20;
-- 给20号部门的所有员工涨工资
declare
   cursor cur is select empno from emp where deptno = 20;
begin
   -- for 特点：自动打开和关闭游标
   -- a 是一个记录变量， 存放游标一行的记录
   for a in  cur loop
     update emp set sal = sal +1 where empno = a.empno;
   end loop;
   commit;
end;
```

### 五、存储过程(重点)

```
1. 什么是存储过程
    封装了一组sql语句， 提前编译，存储在服务端,
    一般是由dba定义
2. 存储过程的使用场景
    网上买了一件商品：商品表(update),订单表（insert）, 余额表(update),销量表(update),物流表(insert)
                   日志表（insert）
3. 语法
    create or replace procedure 过程名(参数1 in | out 数据类型, 参数2  in | out 数据类型,...)
    as|is
        -- 声明语句
    begin
        -- plsql
    end;
4 .栗子  -- 只有输入参数
给某员工涨工资， 在控制台上打印涨前的工资和涨后的工资
create or replace procedure updateSal(eno in number, psal  in number)
is
        oldsal emp.sal%type;
      newsal emp.sal%type;
begin
        
      select sal into oldsal from emp where empno = eno;
      dbms_output.put_line(‘涨前的工资：‘||oldsal );
      
      update emp set sal = sal + psal where empno = eno;
      commit;
      select sal into newsal from emp where empno = eno;
      dbms_output.put_line(‘涨后的工资：‘||newsal );
end;

-- 访问存储过程
call updateSal(7788,5);
5. 栗子   有输入有输出参数的存储过程
-- 获取某员工的年薪
create or replace procedure getYearSalByEno(eno in number, yearsal  out number)
as

begin
    select sal * 12 + nvl(comm , 0) into yearsal from emp where empno = eno;

end;

-- 访问存储过程
declare
   yearsal number;
begin
  getYearSalByEno(7902, yearsal);
  dbms_output.put_line(‘年薪：‘ || yearsal);
end;
6. 栗子： 输出参数为游标类型
-- 获取某部门的所有员工信息
-- cursor :静态的游标
-- sys_refcursor:动态的游标，动态的指定sql语句
create or replace procedure getEmpsByDeptno(dno in number ,emps out sys_refcursor)
as

begin
       -- 动态游标赋值sql语句
    open emps for
         select * from emp where deptno = dno;
end;
-- 访问带有输出参数为游标的存储过程
declare
   emps sys_refcursor;
   erow emp%rowtype;
begin
   getEmpsByDeptno(20 ,emps);
   -- 遍历游标
   loop
      fetch emps into erow;
      exit when emps%notfound;
      dbms_output.put_line(erow.empno ||erow.ename);
   end loop;
   close emps;
end;
```

### 六、存储函数(重点)

```
1. 什么是存储过程
    封装了一组sql语句， 提前编译，存储在服务端
    一般是由dba定义
    一般在存储函数中没有输出参数
2. 与存储过程的区别
    存储函数必须有一个返回值
    存储函数可以使用select语句访问
3. 语法
    create or replace function 函数名(参数1 in | out 数据类型, 参数2  in | out 数据类型,...)
    retrun 类型
    as|is
    
    begin
        return 值;
    end;
4. 栗子: 获取某员工的年薪
create or replace function getYearSalByEnoFun(eno in number) return number
as
    yearsal number;
begin
    select sal * 12 + nvl(comm , 0) into yearsal from emp where empno = eno;
    return yearsal;
end;
-- 访问存储函数
declare
  yearsal number;
begin
  yearsal := getYearSalByEnoFun(7902);
  dbms_output.put_line(yearsal);
end;
5. 可以用在select语句中    
select getYearSalByEnoFun(7902) from dual;
select length(‘abc‘) from dual;    
    
```

### 七，触发器

```
1. 什么是触发器
    监听器: 监听表的数据是否发生改变（insert ,update ,delete）
2. 语法
    create or replace trigger 触发器名称
    before | after
    insert |update |delete
    on 表
    触发器的级别
        表级触发器：默认的
        行级触发器：更新一条记录，执行一次，
            如果使用old,new ，必须使用行级触发器
            for each row
    declare
    
    begin
    
    end;
3. 栗子1
    添加一条记录，在控制台打印 ’添加了一条记录‘
create or replace trigger insertEmp
after
insert
on emp

declare
    
begin
    dbms_output.put_line(‘添加了一条记录‘);
end;


insert into emp(empno ,ename) values(1002 ,‘mike‘);
4. 栗子2:不能给员工降薪
create or replace trigger notUpdateEmpLowerSal
before
update
on emp
for each row
declare

begin
  if :old.sal > :new.sal  then
       -- 提示：不能降薪
    --dbms_output.put_line(‘不能降薪‘);
    -- raise_application_error(p1,p2)
       -- p1 : 错误的编号（-20001 ~~~ -20999）
       -- p2: 错误的提示信息
       raise_application_error(-20001, ‘不能降薪‘);
  end if;
end;

update emp set sal = sal + 1 where empno = 7788;
    
```

    

### 八，JDBC调用存储过程和存储函数

```
package com.jjy;


import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import oracle.jdbc.driver.OracleCallableStatement;
import oracle.jdbc.driver.OracleTypes;

public class JDBCTest {
    
    String driver = "oracle.jdbc.driver.OracleDriver";
    String url = "jdbc:oracle:thin:@192.168.***.***:1521:orcl";
    String username = "scott";
    String password = "tiger";
    Connection conn;
    PreparedStatement pst;
    CallableStatement cst;
    ResultSet rs;
    /**
     * 在执行test方法之前执行before
     */
    /**
     * 初始化信息
     * @throws Exception
     */
    @Before
    public void init() throws Exception{
        Class.forName(driver);
        conn = DriverManager.getConnection(url, username, password);
    }
    
    /**
     * 访问存储过程
     * create or replace procedure getYearSalByEno(eno in number, yearsal  out number)
     * {call <procedure-name>[(<arg1>,<arg2>, ...)]}
     */
    @Test
    public void testProcedure()throws Exception{
        //声明sql语句
        String sql = "{call getYearSalByEno(?,?)}";
        //创建statement对象
        cst = conn.prepareCall(sql);
        //设置占位符
        cst.setInt(1, 7902);
        //设置输出参数的类型
        cst.registerOutParameter(2, OracleTypes.NUMBER);
        //执行sql语句
        cst.executeUpdate();
        //获取结果
        int yearsal = cst.getInt(2);
        System.out.println("年薪：" + yearsal);
    }
    /**
     * 访问存储过程
     * create or replace procedure getEmpsByDeptno(dno in number ,emps out sys_refcursor)
     * {call <procedure-name>[(<arg1>,<arg2>, ...)]}
     */
    @Test
    public void testProcedureOutCursor() throws Exception{
        //声明sql语句
        String sql = "{call getEmpsByDeptno(?,?)}";
        //创建statement对象
        cst = conn.prepareCall(sql);
        //设置占位符
        cst.setInt(1, 20);
        //设置输出参数的类型
        cst.registerOutParameter(2, OracleTypes.CURSOR);
        //执行sql语句
        cst.executeUpdate();
//        //获取结果
        //OracleCallableStatement ocst = (OracleCallableStatement) cst;
        
//        rs = (ResultSet) cst.getObject(2);
//        while(rs.next()){
//            System.out.println(rs.getInt("empno")   + rs.getString("ename"));
//        }
    }
    
    /**
     * 访问存储函数
     * {?= call <procedure-name>[(<arg1>,<arg2>, ...)]}
     * create or replace function getYearSalByEnoFun(eno in number) return number
     */
    @Test
    public void testFunction()throws Exception{
        //声明sql语句
        String sql = "{?= call getYearSalByEnoFun(?)}";
        //创建statement对象
        cst = conn.prepareCall(sql);
        //设置占位符
        cst.registerOutParameter(1, OracleTypes.NUMBER);
        cst.setInt(2, 7902);
        //执行sql语句
        cst.executeUpdate();
        //获取结果
        int yearsal = cst.getInt(1);
        System.out.println("年薪：" + yearsal);
    }
    
    /**
     * 查询员工中的记录
     * @throws Exception
     */
    @Test
    public void test()throws Exception {
        String sql = "select * from emp";
        pst = conn.prepareStatement(sql);
        rs = pst.executeQuery();
        while(rs.next()){
            System.out.println(rs.getInt("empno")   + rs.getString("ename"));
        }
    }
    /**
     * 关闭资源
     */
    @After
    public void close()throws Exception{
        if(rs != null){
            rs.close();
        }
        if(pst != null){
            pst.close();
        }
        if(cst != null){
            cst.close();
        }
        if(conn != null){
            conn.close();
        }
    }

}

```