Oracle

Oracle

1、创建表空间

create tablespace spaceName"表空间名称"
datafile 'C:\文件名'"表空间所对应的文件保存路径,包括文件名"
size 100m '指定文件默认大小,如:100m'
autoextend on :"该值为自动扩展,如果说size值满了,则扩充容量,扩充多少容量有next决定"
next 10m "每次扩容10兆"

-- 新增数据文件
alter database datafile '[数据文件位置]' size [1024m] autoextend on next [100M] MAXSIZE/unlimited [20480M];

2、创建用户

create user username'用户名'
identified by pwd"用户名密码或者口令"
default tablespace spaceName"每个用户必须归属一个表空间,一个表空间可以建多个用户"
temporary tablespace 【临时表空间】

3、用户授权

grant dba to username"用户名"
grant connect,resource to username;
# 当用户无法插入数据,报错为 --> USERS
grant unlimited tablespace to username;

4、查询表空间

 -- 强制删除表空间
 drop tablespace CUX including contents and datafiles;
 -- 查询用户对应的表空间
 select default_tablespace from dba_users where username='Albert';
 -- 查询默认表空间所有用户
 select a.property_name, a.property_value from database_properties a where a.property_name like '%DEFAULT%';
 -- 查询所有用户临时表空间
 select username,temporary_tablespace from dba_users;

5、失效对象

# 查询失效对象
select OBJECT_NAME,OWNER FROM dba_objects WHERE status = 'INVALID';

SELECT * FROM dba_invalid_objects; 
--编译失效对象 
BEGIN 
    dbms_utility.compile_schema('schema_name', false); 
END; 
--查询编译报错信息 
SELECT * FROM dba_errors WHERE owner = 'schema_name';

6、用户表查询

# 查询当前用户下的所有表名
select table_name from user_tables
# 查询某个用户下存在的所有表的表名
select table_name from all_tables where owner = upper('[用户名]');

7、创建临时表空间

create temporary tablespace 【表空间名称】 
tempfile '表空间所对应的文件保存路径,包括文件名' 
size 50m  
autoextend on  
next 50m maxsize 20480m  
extent management local;  

8、修改表空间

 -- 修改默认系统表空间
 alter database default tablespace 【表空间名】;
 -- 修改用户默认表空间
 alter user 【用户名】default tablespace  【表空间名】;
 -- 修改用户临时表空间
 alter user 【用户名】TEMPORARY TABLESPACE 【临时表空间名】;

安装Oracle

1、在linux中安装一个windows操作系统

2、将oracle安装包直接拖入即可安装

Oracle_第1张图片

​ 1)安装完成之后,在Linux中安装的Windows操作系统使用终端连接sqlplus

sqlplus system/idcast #sqlplus:指的是操作软件 system:指的是操作用户 idcast:指的是口令

​ 2)将instantclient_12_1配置文件拷贝到某一个目录下,使用docs进入该目录然后远程连接

sqlplus system/idcast@192.168.60.135:1521/rocl
#192.168.60.135:IP指的是Oracle服务器存放的IP地址 1521指的是Oracle的端口号,rocl指的是全局数据库名称

​ 3)安装PLSQL操作界面

Oracle_第2张图片

注意:Oracle中不允许有中文或者空格在路径中

​ 4)进入到Oracle操作界面

Oracle_第3张图片

​ 5)在Linux中安装Oracle服务器的文件中找到tnsnames.ora拷贝到本地电脑的任意目录下,使用编辑器打开,修改其中的Oracle服务器地址即可

Oracle_第4张图片

​ 6)配置环境变量

Oracle_第5张图片

​ 7)修改Oracle图形界面的编码格式,同样需要配置环境变量,目的是:为了输入中文时,与Oracle服务器的编码格式不一致,导致乱码问题

select userenv('language') from dual #查询服务器的编码格式语句

Oracle_第6张图片

3、用户名和密码

username:orcl pwd:idcast

4、SQL语句

select * from tabs; #查询出数据库中的所有表
quit #退出Oracle终端操作界面

Oracle使用

1、表的增、删、改、查

--创建业主表
create table T_OWNERS(
ID NUMBER PRIMARY KEY,
NAME VARCHAR2(30),
ADDRESSID NUMBER,
HOUSENUMBER VARCHAR2(30),
WATERMETER VARCHAR2(30),
ADDDATE DATE,
OWNERTYPEID NUMBER
);
-- 增加表字段
alter table T_OWNERS ADD (
      NETWORKING varchar2(10),
      GRADE varchar2(10),
      AGE NUMBER
      
)
-- 修改表字段类型
alter table T_OWNERS modify(
      NETWORKING number
)
-- 修改字段名称
alter table T_OWNERS rename column NETWORKING to NETWORKINGs
-- 删除一个字段
alter table T_OWNERS drop column NETWORKINGs
-- 删除多个字段
alter table T_OWNERS drop(NETWORKING,GRADE,AGE)
-- 删除表
DROP TABLE T_OWNERS
-------------------------------------------------------------
-- 插入数据
insert into T_OWNERS values
(1,'张无忌',2,'武当山一号','太极',sysdate,1);
-- 通过commit直接提交,就不用再点击
commit;
-- 修改语句
update T_OWNERS set adddate=adddate-3 where id=1;
commit;
--------------------------------------------------------------
-- 删除表
delete from T_OWNERS where id = 1;
commit;
-- 删除表 truncate table 表名,使用truncate删除语句,直接将整个表删除,然后重建一个空的表空间
truncate table T_OWNERS

2、函数

1、字符控制函数
1、concat;拼串 substr:截取,从第几位开始,截取几个字符  length:判断字符串长度
 select concat('hello','world'),substr('helloworld',2,4),length('helloworld') from dual;
 
2、instr:判断某一个字母在字符串中首次出现的位置,如果没有则输出0,Java中输出-1
select instr('helloworld','l') from dual;

3、lpad:查询哪一个字段,查询多少个字符,不够则使用“*”补上,在左边(lpad),而rpad指右边,俩者都可以使用空格进行补全
select employee_id,last_name,lpad(salary,10,'*') ,rpad(salary,10,' ')from employees;

4、trim:截取字符,但仅限于首尾,位于中间的需要截取的字符不进行截取
select trim('h' from 'helloworlhdh') from dual;
 
5replace:替换字符,输入一串字符,输入需要替换的字符,再输入被替换的字符
select replace('abcfdfefg','f','k') from dual;

6、rtrim:去除最右侧空格,ltrim:去除最左侧空格,字符串中间存在空格,当前语法无法去除
select rtrim('dsada ')/ltrim(' dsasd') from dual;

7、LAPD和RAPD(左、右追加)

-- LAPD(String,length,[context]):在左边追加length-string的字符个数值,【context】参数为可选,不写context参数,可以充当截取字符串用
-- RPAD(String,length,[context]):在右边追加,方法和左边追加一样
   select lpad('',6,'#') from dual;
   select rpad('abcde',5) from dual;


8、initcap:只针对于字符串(字母类型的),用法单一。将一串字母中无论其中是否存在大小写形式,只把第一个字母大写,其余字母全部小写。
	select initcap('djiqASDds') from dual;
2、数字函数
# 1、round(1),代表着只保留一位小数,后面如果不写保留几位小数的话,默认是不保留小数,只取整,如果后面填写为负数,舍弃小数,负数为几,则整数位上的数从后往前由0代替,直到满足负数个数之后,剩下的值则为原来的值,如果整数位上的位数不够负数位数,直接取0
select round(123.123,1),round(123.12),round(123.12,-2) from dual;

#2、trunc:称为截取,和round的功能一样
select trunc(123.123,1),trunc(123.12),trunc(126.12,-2) from dual;

#3、mod:称为取余,前一位除以后一位,得到的余数进行输出
select mod(1100,300) from dual;

3、转换函数
############# DATE型==>CHARACTER型 #############
1、to_char:转换成字符型格式,第一个位置输入所需要的日期列名,第二个位置输入想要的格式,然后等于某一个格式
select employee_id,last_name,hire_date from employees where to_char(hire_date,'yyyy-mm-dd')='1994-06-07';
# 注意:to_char函数中的IW、WW区别
1.1 ww的算法为每年11日第一周开始,date+6为每一周结尾
# 其中date只是声明单引号中的时间为日期型时间,后转换方式为年+ww的算法
select to_char(date'2022-8-22'+6,'yyyyww')from dual;
1.2、iw的算法为自然周,即星期一到星期五,且每年的第一个星期天为第一周,同样如果去年剩下的几天达不到一周的时间,那么将再今年的日期上添加几天到去年的周期上,然后再开启今年的新的周期年
# 如2022-1-3才是2022年新的一周的开始
select to_char(date'2022-1-3','yyyyiw') from dual;
# 而2022-1-2任然是2021年的第52周的结束
select to_char(date'2022-1-2','yyyyiw') from dual;
############# CHARACTER型==>DATE型 #############
2、to_date:字符型转换成日期型,将第一个位置和等于号后边的位置进行调换即可
select employee_id,last_name,hire_date from employees where to_date('1994-06-07','yyyy-mm-dd')=hire_date;

3、想要输出中文格式的日期,必须在查询列名出声明
select employee_id,last_name,to_char(hire_date,'yyyy"年"mm"月"dd"日"') from employees where to_char(hire_date,'yyyy"年"mm"月"dd"日"')='1994年06月07日';

############# NUMBER型==>CHARACTER型 ###########

4、to_char:number型进行转换,第一个位置输入number型数据,第二个位置输入需要转换成字符型的格式,9:代表一个数字,‘,’:代表分隔符,‘.’:代表小数点,0:代表着零,如果第一位上面不够三位数,则在前面补全,L:代表本地货币符号,$:代表美元符号
select to_char(1213454.43,'999,999,999.99') from dual;
select to_char(1213454.43,'L000,000,000.99') from dual;

5、to_number:char型转换成NUMBER型,首先输入char型字符串,然后输入格式进行转换,还可以进行‘加、减、乘、除’操作
select to_number('$001,213,454.43','L000,000,000.99') from dual;
select to_number('$001,213,454.43','L000,000,000.99')*2 from dual;

日期相关格式:
Oracle_第7张图片
Oracle_第8张图片
Oracle_第9张图片
Oracle_第10张图片

4、通用函数
# 1、通用函数nvl(expert1,expert2):代表着当expert1不为空时,则使用expert1,为空时使用expert2代替,也就是当部门ID为空时,使用后面的‘没有部门代替’,如果不为空时,则使用它自己的部门ID即可
select last_name,nvl(to_char(department_id,'99999'),'没有部门') from employees;

#2、nvl2(expr1,expr2,expr3):代表着当expr1不为空时,返回expr2,为空时,返回expr3。相当于commission_pct不为空时,则使用commission_pct+0.015,为空时,则使用,0.015
select last_name,commission_pct,nvl2(commission_pct,commission_pct+0.015,0.015) from employees;

# 3、nullif(expr1,expr2):如果俩个表达式相等(无论表达式中是何种形式,就算是计算、中文还是字母,只要相等就返回 null),返回 null 值。否则返回第一个表达式。
重点:俩个表达式的数据类型要保持一致,不能混着使用,否则报错
注意:expr2 可以放 null 值,expr1 不可以放,否则报错
select nullif(100,100) from dual;  -- null
select nullif('sad','sad') from dual;  -- null
select nullif('我怕','我怕') from dual;  -- null
select nullif('我','我怕') from dual;  -- 我
select nullif('我',null) from dual;  -- 我
select nullif(12/12,12/12) from dual; -- null
SELECT NULLIF (100, 'A') FROM DUAL;  -- 不可以这样

# 4、COALESCE(expr1,expr2.....exprn):当前表达式中只要存在非 null 值,那么就会返回该值,否则就会返回 null 值
重点:数据类型不能混用,但是可以和 null 一起用
SELECT COALESCE('我', NULL, 100) FROM DUAL;  -- 错误
SELECT COALESCE('我', NULL, '我') FROM DUAL;  -- 我
SELECT COALESCE( NULL,12, NULL,18) FROM DUAL;  -- 12
SELECT COALESCE( NULL,NULL) FROM DUAL;  -- null
5、条件表达式
# 1、case when then else,当部门为10时,则薪资乘以1.1,当部门为20时,则薪资乘以1.2,接下来即可使用else来代替whe then,因为其剩下最后一个
select employee_id,last_name,department_id,case department_id when 10 then salary * 1.1 when 20 then salary * 1.2 else salary * 1.3 end new_sal from employees where department_id in (10,20,30);

#2、decode:使用其,则可以将整个部门作为条件进行查询,中间使用逗号隔开
select employee_id,last_name,department_id,decode(department_id,10,salary * 1.1,20,salary *1.2,salary) new_sal from employees where department_id in (10,20,30);
6、字符、字节截取、计算函数
-- length查询的是字符长度
select length('广东省珠海市唐家湾镇') as test_length from dual;
-- lengthb查询的是字节长度
select lengthb('广东省珠海市唐家湾镇') as test_length from dual;
-- substrb(string,a,b):其中a、b俩值都是通过字节来计算范围,并不会通过字符来决定范围
select substrb('刘德华abc',-6,3) from dual;
-- substr(string,a,b)
-- 截取字符:当|a| <= b时,取a的个数
-- 当 |a| ≥ b时,才取b的个数,负数:代表着从后往前取
select substr('HelloWorld',-1,3) value from dual;
-- 截取三个字符,从前往后
select substr('HelloWorld',3) value from dual;
7、translate函数
 1、整体替换:将第二个参数中的值整体替换为O?
select replace('i love you','oi','O') from dual;
 2、一一对应替换,如果替换的目标位置不够,默认替换为空(截断该替换的字符)
select replace('i love you','oeu','*2') from dual;
 3、能否做数字格式验证
translate
8、内置函数(least or greatest)

注意:当进行多个值比较时,其中第一个值被确定当前函数优先返回值的类型,然后再进行隐式转换进行比较

# 1、获取列表数据的最小值
select least(17,23,44,56,7) from dual; -->7
# 2、获取列表最大值
select greatest(1,2,8)from dual;
9、日期计算
  1. add_months(date,n)–date:指代需要的时间节点,n:指代几个月前或者几个月后(需要数字前面加负号,才能指代月前)

    # 函数:计算某一个时间节点距离几个月前或者之后的时间
        select * from emp where creation_date>to_date('20190101','yyyymmdd') and creation_date < add_months(to_date('20221011','yyyymmdd'),2)
    
    select sysdate,add_months(sysdate,-1*8) from dual;
    
  2. last_day函数:计算当前时间的月份最后一天是多少号,并且还可以用于计算当前时间距离最后一天的时间间隔多少天

    select last_day(to_date('20220927','yyyyMMdd')),(last_day(sysdate) - sysdate) shen from dual;
    
  3. months_between:返回俩日期之间日期差。
    重点:计算方式

  • 如果俩日期一样

    • 先比较年份,年份大的在expr1,就以正数形式返回俩日期之间的差值
    • 且年份一样,就比较月份,月份大的在expr1,就以正数形式返回俩日期之间的差值
    • 年份一样,且月份也一样,号数大的在expr1,就以正数形式返回俩日期之间的差值
  • 如果俩日期不一样

    • 先比较年份,年份小的在expr1,就以负数形式返回俩日期之间的差值
  • 如果俩日期一摸一样,就返回 0

    select months_between(to_date('20190802','yyyyMMdd'),to_date('20190421','yyyyMMdd')) from dual;
    select months_between(to_date('20190321','yyyyMMdd'),to_date('20190301','yyyyMMdd')) from dual;
    select months_between(to_date('20190321','yyyyMMdd'),to_date('20190321','yyyyMMdd')) from dual;
    # 以负数形式返回   <== 过去的时间排在前面
    select months_between(to_date('20190201','yyyyMMdd'),to_date('20190301','yyyyMMdd')) from dual;
    
  1. count(*) and count(1);根据分组统计出 group by 中都相同的和不相同的数据分别有多少条

    select count(*),emp_name,emp_salary from emp group by emp_name,emp_salary;
    
  2. 函数幂次方

    select power(2,4) from dual; <-- 2的4次方
    

3、组函数

1、组函数类型:组函数会自动忽略空值,如想要其不忽略空值,使用单行函数中的NVL函数即可

AVG、COUNT、MAX、MIN、STDDEV(样本标准差,可用于聚集和分析函数)、SUM、DISTINCT
-----------------------------------------------
# 1、max\min任何数据类型都可以使用
select max(last_name),min(last_name),max(hire_date),min(hire_date) from employees;
# 2、avg\sum只能针对数值型数据
select avg(last_name),sum(hire_date) from employees
ORA-00932: inconsistent datatypes: expected NUMBER got DATE
# 3、count支持任何数据类型,但是其只支持计算非空的数据,会自动忽略掉空的数据,同样avg和sum一样
select count(employee_id),count(last_name),count(hire_date) from employees;
# 4、avg()函数等于sum()/count函数之和
select avg(salary),sum(salary)/count(salary) from employees;
AVG(SALARY) SUM(SALARY)/COUNT(SALARY)
----------- -------------------------
6461.682242          6461.68224299065
1 row selected
# 5、distinct去重函数,返回非空且不重复的记录总数
SELECT COUNT(DISTINCT(DEPARTMENT_ID)) FROM EMPLOYEES;

2、使用Group By进行分组查询:在使用分组函数查询时,除了包含在组函数的列,其余列都应该包含在GROUP BY 子句中

# 1、求出员工表中各个工种、各个部门的平均工资
select department_id,job_id,avg(salary) from employees group by department_id,job_id
# 2、不能在where子句只用组函数,可以在HAVING子句中使用组函数--->如:求出各个部门平均工资大于6000的部门,及其平均工资
select department_id,avg(salary)
from employees
where avg(salary)>6000
# having avg(salary)>6000
group by department_id
order by avg(salary) asc
ORA-00934: group function is not allowed here
3、分析函数
-- rank():基于排序字段,如出现相同值,其排序值一样(1 1 3),当出现另一个不同值时,就会出现跳跃(不连续)排序
select e.emp_id,e.dept_id,e.emp_name,e.emp_salary,rank() over(order by emp_salary) as ones  from emp e 
-- dense_rank():基于排序字段,如出现相同值,其排序值是相同的,当出现不同值时,其排序值会顺位而下进行排序,不会出现跳跃式排序
select e.emp_id,e.dept_id,e.emp_name,e.emp_salary,dense_rank() over(order by emp_salary) as ones  from emp e
-- row_number():不管排序的值是否存在一样的数据,按顺序一直排(1 2 3 4...)
select e.emp_id,e.dept_id,e.emp_name,e.emp_salary,row_number() over(order by emp_salary) as ones  from emp e
-- partition by(排名分区):若选择的排名中存在相同值,那么相同的值进行顺位排序,不同的值则用 1 表示,
-- 注意:partition by的排名分区是基于某一个字段进行排序,把相同的字段值汇总到一起,相同的字段值按照顺位排序,不同的值则用 1 表示
-- rank()
select e.emp_id,e.dept_id,e.emp_name,e.emp_salary,rank() over(partition by dept_id order by emp_salary) as ones  from emp e 
-- dense_rank()
select e.emp_id,e.dept_id,e.emp_name,e.emp_salary,dense_rank() over(partition by dept_id order by emp_salary) as ones  from emp e 
-- row_number
select e.emp_id,e.dept_id,e.emp_name,e.emp_salary,row_number() over(partition by dept_id order by emp_salary) as ones  from emp e 

3.1 计算偏移量

  • LAG、LEAD(expression,,):LAG函数可以访问当前行的上一行,而LEAD函数可以访问当前行的下一行
  • experssion:表达式,:为正整数,其可以选择从哪里开始输出当前行和上一行,输出的当前行和上一行都必须从第一行开始,依次往后推,:表示可以选择用什么值代替默认的null
  • 注意:俩函数必须使用order by排序
SELECT emp_name, dept_id, emp_salary asl, LAG (emp_salary) OVER (ORDER BY emp_salary) LAG,
       LEAD (emp_salary) OVER (ORDER BY emp_salary) LEAD
  FROM emp

3.2 报表分析函数(RATIO_TO_REPORT)

  • RATIO_TO_REPORT 报表分析函数,其中RATIO_TO_REPORT (emp_salary)中的参数表示,当前emp_salary占总emp_salary的百分比并且,再当前开窗函数中禁止使用order by 排序查询,可以在from或者where子句后使用,不能循环使用
SELECT emp_name, emp_salary, dept_id, RATIO_TO_REPORT (emp_salary) OVER () AS RR
 FROM EMP
 -- WHERE dept_id = 10149
 order by emp_name, emp_salary desc, dept_id;
 -------------------------------------------------------------------------------
 SELECT emp_name, dept_id, emp_salary,
       MIN (emp_salary)KEEP (DENSE_RANK FIRST ORDER BY dept_id) OVER (PARTITION BY dept_id)  "Worst"/*,
       MAX (emp_salary)KEEP (DENSE_RANK LAST ORDER BY dept_id) OVER (PARTITION BY dept_id) "Best"*/
  FROM EMP
  --group by emp_name, dept_id, emp_salary;
4、UNION和UNION ALL和intersect
-- 寻找交集 关键字-->intersect 可查询出删除或者更新的数据,前提是具有备份
select emp_id,dept_id,emp_name,emp_salary from emp 
intersect
select emp_id,dept_id,emp_name,emp_salary from emp order by emp_salary

select emp_id from emp order by emp_id
-- minus:求第一个结果集中的数据不存在第二个结果集中的数据,且第二个结果集中的数据不在总结果集中显示
select emp_id from emp where emp_id < 10 minus select emp_id from emp where emp_id between 4 and 10;
-- union all:求俩个结果集中的所有数据,并且都显示出来
-- union:求俩个结果集中的数据,并且合并起来还带有去重效果
5、查看表空间文件所在位置
select file_name from dba_data_files where tablespace_name = 'CUX';

4、子查询

特点:‘< >’为不等于,any:比较子查询中的返回的某一个值进行比较,all:和子查询中返回的所有值进行比较,in:等于列表(查询列)中的任意一个
having关键字:针对查询的结果进行操作

-- 查询:返回其它部门中比job_id为‘IT_PROG’部门所有工资都低
-- 的员工的员工号、姓名、job_id以及salary
select employee_id,last_name,job_id,salary
from employees
where job_id <> 'IT_PROG' 
and salary < all (	any
                  select salary 
                  from employees 
                  where job_id = 'IT_PROG'
                  )
-- 查询:最低工资大于50号部门最低工资的部门id和最低薪资
select department_id,min(salary)
from employees
group by department_id
having min(salary) > (
                      select min(salary) 
                      from employees
                      where department_id = 50
                      )

5、高级子查询(未完2)

# 1、多列子查询
-- 查询与141号或174号员工的manager_id和department_id
-- 相同的其他员工的employee_id,manager_id,department_id
select employee_id,manager_id,department_id
from employees
where (manager_id,department_id) in(
    # in:代表着manager_id,department_id在该子查询的范围内
select manager_id,department_id
from employees
where employee_id in (141,174)
                    )
   # 并且查询出来的employee_id不包含141和174号员工
and employee_id not in(141,174)

# 2、from子句子查询,select可创建临时表进行比较,group by 代表着以哪个列为分组条件,然后该列相同的值放一起
-- 在from子句中使用子查询
-- 返回比本部门平均工资高的员工的last_name,department_id,salary
-- 及平均工资
select last_name,e1.department_id,salary,e2.avg_salary
from employees e1,
(select department_id,avg(salary) avg_salary from employees
group by department_id) e2
where e1.department_id = e2.department_id

# 3、order by子句中使用单列子查询
-- 查询员工的employee_id,last_name
-- 要求按照员工的department_name排序,默认为ASC
select employee_id,last_name
from employees e1
order by (select department_name from departments d 
          where  e1.department_id = d.department_id) asc

# 4、条件表达式中使用子查询
-- 显示员工的employee_id,last_name和location
-- 其中,若员工department_id与location_id为1800的department_id相等
-- 则location为‘Canda’,否则为‘USA’
select employee_id,last_name,
(case department_id when 
(select department_id from departments where location_id = 1800)
then 'Canda' else 'USA' end
) location
from employees

# 5、相关子查询
-- 若employees表中employee_id与job_history表中employee_id相同的数目
-- 不小于2,则输出相同employee_id,last_name,job_id
select employee_id,last_name,job_id
from employees e1
where 2 <= (select count(*) from job_history 
            where e1.employee_id  = employee_id)
            
# 6、

6、视图

1、简单视图
# 1、创建视图
# one 是视图名称,对于视图的修改可以影响到整个基表,视图的创建有利于权限控制,不让所有得人都能够看到整张表的数据,而是看到某些特定的数据
create view one as 
select employee_id,last_name,salary
from employees 
where department_id = 80

# 2、修改视图
-- 对视图进行修改关键字: or replace,如果在原来的基础上进行修改,不改变视图名称
-- 那么修改后的视图将对原来的视图进行覆盖
-- 任何人对表都没有增、删、改操作,只有查询,可以在视图最后加上with read only(仅读)
create or replace view one as 
select employee_id,last_name,salary,department_id
from employees 
where department_id = 80

# 3、-- 对视图中的数据进行删除
delete from one where employee_id = 166
2、复杂视图

何为复杂:是否存在函数、分组

# 1、创建复杂视图
-- 视图中包含组函数和分组
create or replace view two as
select last_name,avg(salary) avg_salary,department_name
from employees e,departments d
where e.department_id = d.department_id
group by department_name,last_name

# 2、不能对复杂函数进行DML操作
-- 修改复杂视图中的内容
update two set department_name = 'tan' where last_name = 'Dilly'
ORA-01732: data manipulation operation not legal on this view
3、删除视图
drop view '视图名称';
4、(Top-N)分析伪列

注意:对 ROWNUM 只能使用 < 或 <=, 而用 =, >, >= 都将不能返回任何数据。如果需要让它可以使用 =, >, >= ,那么需要将ROWNUM 变成真实存在的数据

select rownum,employee_id,last_name,salary
     from (
          select employee_id,last_name,salary
          from employees
          order by salary desc
          )
   
     where rownum > 40 and rownum <=50

将rownum变成真实列,将rownum作为子查询的结果,然后再使用其别名作为开始查询的条件,这样即可在Rownum原有基础符号(< 或 <=)上使用其它的 =, >, >= 符号

select a.*,a.rn from (select emp_name,emp_salary,rownum rn from emp) a where rn >= 20 

7、数据处理

0、拷贝表
# 复制一个表,可以选择复制几列,同样也可全部复制,并且复制其约束
create table emp1
as
select employee_id,last_name,hire_date,salary from employees
where 1=2
# 全部复制一个表中的任何数据
create table employees1
as
select * from employees
1、insert
# 1、插入值,当插入的日期需要转换时
insert into emp1 values
(1002,'BB',to_date('1991_09_01','yyyy-mm-dd'),20000)

# 2、复制表中的数据到新的空表中
insert into emp1
select employee_id,last_name,hire_date,salary
from employees
where department_id = 80

2、update、delete
# 1、更新144号员工的工作和薪资使其与205号员工相同
update employees1 
set job_id = (select job_id from employees1 where employee_id = 205)
,
salary = (select salary from employees1 where employee_id = 205)
where employee_id = 144
###############################################
select job_id,salary <--查询144和205号员工
from employees1
where employee_id in (144,205)
###############################################
# 2、从employees1表中删除department名称中含有Public字符的部门id
delete from employees1
where department_id = (select department_id from departments
where department_name like '%Public%')
3、事务

commit、rollback、savepoint(保存点),如果对表中的数据操作过后,通过commit提交之后,使用rollback也不能回滚到最初的数据,同理设置savepoint(保存点)也一样,设置savepoint(保存点)之后,不能提交操作过后的语句,这样savepoint(保存点)就失去意义

4、行转列

某个表中存在一个部门号对应多个员工,现将每个部门所对应的员工进行分组,并且分俩列查询出来 -->listagg() within group

listagg() :就是将有员工名称汇集起来,通过逗号隔开,然后再order by,最后用id进行分组即可

select department_id, listagg(employee_name, ',') within group (order by employee_name) as name
from cux_oaf_test_employee group by department_id;

8、序列

重点:序列的初始值只有在初次使用时,才会存在,后续使用的值都是上一个表使用序列插入值的下一位值。如果想重新使用序列的初始值,只有通过删除序列进行重建才能使用初始值

1、创建、修改序列

注意:
当使用循环后:
① 如果插入数据的值到达了序列的 maxvalue 或者 序列默认的最大值时,只要序列中开启了循环模式,就代表着序列可以重新开始取值插入到表中,就意味着会存在重复值
② 如果序列中没有开启使用重复值,那么当序列插入的数据到达 maxvalue 或者 序列默认最大值时,如果还想继续插入数据,就会报错

cache 参数使用规则:
开启 cache:
① cache 参数默认是预存20个序列值到内存中,当数据开始插入时,每增加一个数,cache 往内存中追加一位数,保证内存中存在 20 序列值。 <=== 在大量数据插入时,有利于提高性能,
关闭 cache:
在大量数据插入时不可取,会降低 CPU 性能,许多数据处于等待状态。如下:

大量语句发生请求,申请序列时,为了避免序列在运用层实现序列而引起的性能瓶颈。Oracle序列允许将序列提前生成 cache x个先存入内存,在发生大量申请序列语句时,可直接到运行最快的内存中去得到序列。但cache个数也不能设置太大,因为在数据库重启时,会清空内存信息,预存在内存中的序列会丢失,当数据库再次启动后,序列从上次内存中最大的序列号+1 开始存入cache x个。这种情况也能会在数据库关闭时也会导致序号不连续。
-- 1、创建序列
create sequence empseq
-- 每次增长10间隔数是10
increment by 10 
-- 从第10个数开始,进来每增长一次就加上increment by定义的值
start with 10 
-- 提供的最大值:也就是序列增长到哪停止增长
默认最大值是
maxvalue 100
-- 最小值:序列最小值从哪位数开始
minvalue 0
-- 是否需要循环 no cycle代表不循环
cycle -- 循环
-- 不需要缓存 cache需要缓存
-- cache值会被提前缓存到内存中,默认是 20 个值
nocache / cache []
################################################
-- 2、修改序列,将需要修改的列列出来修改值即可
alter sequence empseq
increment by 1
nocycle

-- 3、查看当前用户下的序列
select * from user_sequences
select * from USER_OBJECTS

-- 4、解析表
min_value:默认初始值 1
max_value:默认是 10^28 次方
NOMAX_VALUE:并不代表着可以无限制的使用,默认是10^27次方
cache:默认是预存 20 个值到内存中。
nocycle:序列默认不循环

在这里插入图片描述

2、注意
  • 对序列的任何操作,都会影响到序列的自增,如:
    • (删、改序列值)
    • 系统异常
    • 多个表同时使用同一序列
  • 以上的所有操作都会是序列在一定程度上产生间隙
3、查询、删除序列
# 1、查询序列
select sequence_name,min_value,max_value,increment_by,last_number from user_sequences
# 2、删除序列
drop sequence empseq

9、索引

重点:索引字段上如果存在空值,经过默认排序时,NULL值的行都会被排在最后

1、创建索引
# 1、索引名称一般为:表_列
create index emp2_id_ix
on emp2(employee_id)

# 2、删除索引
drop index '索引名称'
2、什么时候创建索引
  • 以下情况创建索引
    • 列中数据分布范围广
    • 经常在where子句或连接条件中出现
    • 表经常被访问且数据量较大
  • 以下情况不创建索引
    • 表小
    • 列不经常作为连接条件或者出现在where子句中
    • 数据较少
    • 经常更新
九、锁

单表–引用表(主外键)—未解决

原则:

  • 只有被修改时,行才会被锁定
  • 当一条语句修改了一条记录,只有这条记录上被锁定
  • 当某行被修改时,它将阻塞其它用户对它的修改
  • 当一个事务修改一行时,将该行上加上行锁(TX),用于阻止其它事务对该行的修改
  • 读永远不会阻止写,写也永远不会阻止读,唯一读会阻塞:select … for update
  • 当一行被修改后,Oracle通过回滚段提供给数据的一致性读
  1. 锁阻塞:当多个会话竞争同一资源时,那么先执行的会话如不提交或回滚事务,那么后续的会话一直处于阻塞或等待状态 ----执行需要提交事务语句

insert和update锁机制区别

引用表:对主表进行DML操作时

TM锁(表锁)

  • 排它锁(lock table emp in exclusive mode;):任何事务都不能进行DML语句操作。何时会触发该锁:Alter table、drop table、drop index、truncate table。释放锁只需要—>commit;

  • 共享锁(lock table BOOS in share mode;): 若同时有多个会话对某一条语句做dml操作,session都加上S锁,那么各个session之间都必须等待对方释放锁 -->commit;释放

  • 行级共享锁(lock table BOOS in row share mode; ): 当操作某一条数据时,使用RS锁,该条数据只能再当前事务中操作,别的事务不能对当前数据进行操作,如果对当前数据进行update操作,默认会自动加上行级排它锁

  • 行级排它锁(lock table BOOS in row exclusive mode; ):只要事务不对同一行数据进行操作,那么不同的事务之间均可做不同的操作

  • 行级共享排它锁(lock table BOOS in share row exclusive mode; ): 只能有一个事务能够获得该锁,其它事务只能对当前表做查询操作(除select … for update nowait)除非释放锁–commit;

  • DML语句获得表锁的目的:首先保证自身对表的访问不受其他事务DML语句干扰,其次阻止其他事务中和自身有冲突的DDL操作执行

  • 当某一记录被锁定后,其它需要访问被锁定对象的会话会按先进先出的方式等待锁的释放,而对于select操作而言,不受锁的控制

  • S锁:

# 当前会话加上S锁,
lock table BOOS in share mode;
insert into boos(boos_id,boos_manager_id,boos_name,creation_date,last_update_date) values(3,1003,'Albert',sysdate,sysdate);
update boos set boos_name = 'Amoss' where boos_id = 3;
delete from boos where boos_id = 3;
  • 系统表查看锁

    -- 查询出有哪些表阻塞了--->v$lock
    SELECT sid, TYPE, lmode, id1, id2, request, BLOCK
      FROM v$lock
     WHERE TYPE IN ('TM', 'TX');
    -- 根据 ID1 对应数字,查出对应的表--->dba_objects
    SELECT object_name 
    FROM dba_objects 
    WHERE object_id = 73557;
    -- 会话层面优化必看该表-->v$session_wait
    SELECT sid, event 
    FROM v$session_wait
    WHERE sid = 160;
    commit;
    -- 查询存在等待资源的表
    select object_name,machine,s.sid,s.serial#
    from v$locked_object l,dba_objects o ,v$session s
    where l.object_id = o.object_id and l.session_id=s.sid;
    -- 释放等待资源中的表 alter system kill session 'sid,serial$'
    alter system kill session '160,10714'; 
    ---------------------------------------------------------
    ---------------------查看锁-------------------------------
    ---------------------------------------------------------
    select * from DBA_LOCKs;
    select * from DBA_LOCK;
    select * from V$FIXED_VIEW_DEFINITION; -- 动态性能视图查看
    select * from V$LOCK;
    select * from V$LOCKED_OBJECT; --记录DML锁
    select * from GV$CR_BLOCK_SERVER;
    select * from DBA_DDL_LOCKS; -- 查出所有的DDL锁
    select * from DBA_DML_LOCKS; -- 查出所有的DML锁
    select*from V$lock_Type;-- 查询Oracle中的锁
    
-- 释放等待资源中的表 alter system kill session 'sid,serial$'
alter system kill session '160,10714'; 
select name from v$latchname;
-- 查看表空间文件所在位置
select file_name from dba_data_files where tablespace_name = 'CUX';

Latch的获取

  • wait方式–如果无法获取请求的latch,则
    • spin
      • 当一个会话无法获得需要的latch时,会继续使用CPU(CPU空转),达到一个间隔后再次尝试申请latch,直到达到最大的重试次数
    • sleep
      • 当一个会话无法获得需要的latch时,会等待一段时间(sleep),达到一个间隔后再次尝试申请latch,循环往复,直到达到最大的重试次数
  • No wait方式–如果无法获取请求的latch,则
    • 不会发生sleep或者spin,转而去获取其它可用的Latch

Oracle_第11张图片

PL-SQL

1、PL-SQL块

​ PL-SQL程序由三块组成:即声明部分、执行部分、异常处理部分

2、如何使用

使用PL-SQL前,需要输入set serveroutput on该命令,如不输入,则不会有运行结果
3、记录类型和简单类型

  • 一个PL/SQL RECORD必须包含一个或多个字段:这些字段的数据类型可以是标量类型、RECORD类型或PL/SQL表类型
  • 在PL/SQL块中从表中取出一行进行处理时用PL/SQL RECORD
  • SELECT语句查询的列值的数量与顺序,必须与创建记录类型变量中定义的字段数量和顺序相匹配
  • 一个记录类型的变量仅仅能保存从数据库中查询出的一行记录,若查询出了多行记录。就会出现错误
################################################
-- 简单类型
declare
  -- 声明变量、类型
  -- 注意:声明变量的范围不能小于原本的范围,否则会造成数据插入失败
   -- employees.salary%type:代表着可以动态的获取数据表的变量类型以及范围
  v_sal employees.salary%type;
  v_email varchar2(20);
  v_hrie_date date;
begin
  -- 程序执行部分(类似于Java中的main()方法)
  select salary,email,hire_date into v_sal,v_email,v_hrie_date
  from employees where employee_id = 100;
  
  -- 打印
  dbms_output.put_line(v_sal||','||v_email||','||v_hrie_date);
--exception
  -- 针对begin块中出现的异常,提供处理机制
  -- 使用 when ....then....
  --      when ....then....
end;
###############################################
-- 记录类型
declare
  -- 声明一个类型、
  -- 注意:声明变量的范围不能小于原本的范围,否则会造成数据插入失败
  -- employees.salary%type:代表着可以动态的获取数据表的变量类型以及范围
  -- 记录类型
  type fire is record(
  v_sal employees.salary%type,
  v_email varchar2(20),
  v_hrie_date date
  );
  -- 定义一个记录类型的成员变量,名称可以随意取
  v_fire fire;
begin
  -- 程序执行部分(类似于Java中的main()方法)
  select salary,email,hire_date into v_fire
  from employees where employee_id = 100;
  
  -- 打印,根据变量名称进行取值
dbms_output.put_line(v_fire.v_sal||','||v_fire.v_email||','||v_fire.v_hrie_date);
--exception
  -- 针对begin块中出现的异常,提供处理机制
  -- 使用 when ....then....
  --      when ....then....
end;

4、游标

概念:用来处理多条数据

创建游标的四步骤:一、声明游标 二、打开游标 三、提取游标数据 四、关闭游标

1、使用游标查询单条数据

-- 游标
-- 打印出80号部门的所有的员工的工资:salary:xxx

declare
    -- 定义变量
    v_sal employees.salary%type;
    -- 声明游标
    cursor emp_sal_cursor is select salary from employees where department_id = 80;
begin
    -- 打开游标
    open emp_sal_cursor;
    -- 提取游标
    fetch emp_sal_cursor into v_sal;
    -- 循环提取员工,while emp_sal_cursor%found:%found用来判断游标中是否
    -- 还存在相关的行,然后 loop 开始循环
    while emp_sal_cursor%found loop
          dbms_output.put_line('salary'||v_sal);
          -- 打印行之后,提取剩下的行在游标中
          fetch emp_sal_cursor into v_sal;
    end loop;
    -- 关闭游标
    close emp_sal_cursor;
end;

2、使用游标查询多条数据,通过定义记录类型

-- 游标
-- 打印出80号部门的所有的员工的工资:salary:xxx
-- 当需要输出多个属性时,这个时候声明一个记录类型,记录类型中的变量通过逗号隔开

declare
    -- 声明一个记录类型
    type emp_record is record(
    v_sal employees.salary%type,
    v_empid employees.employee_id%type,
    v_hiredate employees.hire_date%type
    );
    -- 声明一个记录类型的变量
    v_emp_record emp_record;
    -- 定义游标
    cursor emp_sal_cursor is select salary,employee_id,hire_date from employees where department_id = 80;
begin
    -- 打开游标
    open emp_sal_cursor;
    -- 提取游标
    fetch emp_sal_cursor into v_emp_record;
    -- 循环提取员工,while emp_sal_cursor%found:%found用来判断游标中是否
    -- 还存在相关的行,然后 loop 开始循环
    while emp_sal_cursor%found loop
          dbms_output.put_line('salary:'|| v_emp_record.v_sal
                               ||',id:'|| v_emp_record.v_empid
                               ||',hire_date:'|| v_emp_record.v_hiredate);
          -- 打印行之后,提取剩下的行在游标中
          fetch emp_sal_cursor into v_emp_record;
    end loop;
    -- 关闭游标
    close emp_sal_cursor;
end;

3、通过使用For循环来使用游标,简化开发

-- 游标
-- 打印出80号部门的所有的员工的工资:salary:xxx

declare

   -- 定义一个游标
   cursor emp_sal_cursor is select salary,employee_id,hire_date 
   from employees where department_id = 80;
begin
  for c in emp_sal_cursor loop
    dbms_output.put_line('salary:' || c.salary || 'employee_id:'|| 
    c.employee_id || 'hire_date:'||c.hire_date);
    end loop;
end;

5、存储函数

注意:函数具有返回值

1、创建存储函数
-- 1、创建存储函数
-- 函数的helloword:返回一个"helloworld"的字符串
-- hello_world(v_log varchar2):函数名括号内是形参,根据形参的类型进行返回
-- 注意:如果函数不需要参数,那么函数名后就不需要带参数,如果需要参数,则需要指明参数类型,不需要指明大小
create or replace function hello_world(v_log varchar2)
-- 返回的形参类型
return varchar2
-- is:相当于declare,里面声明变量
is
# 声明变量、记录类型、cursor
begin
  # 函数执行体
       return v_log;
exception
  # 处理函数执行过程的异常
end; 
2、调用函数
-- PLSQL型
begin
  dbms_output.put_line(hello_world('atguigu'));
end;
-- SQL型
select hello_world('atguigu') from dual
3、创建带参函数及out使用

1、注意:out:是可以被改变的,所以不定义为变量

-- 获取给定部门的工资总和,要求部门号定义为参数,工资总额定义为返回值
-- 并且将公司总人数返回
create or replace function get_sal1(dept_id number,total_peo out number)
return number
is
--  定义一个变量来接收工资总和,并且初始化为零
    v_sumsal number(10) := 0;
    -- 通过游标来获取某一个部门的id
    cursor salary_cursor is select salary 
    from employees 
    where department_id = dept_id;
begin
-- 声明初始值为空
	v_total_peo number(4) := 0;
  -- 利用for循环,拿到某一个部门的id号的每一员工工资
    for c in salary_cursor loop
      -- 将每一笔工资加上上一笔,得到所有工资总和
      v_sumsal := v_sumsal + c.salary;
      v_total_peo := v_total_peo + 1;
      -- 退出循环
      end loop;
      -- 返回总工资
      return v_sumsal;
end;
2、调用
declare
  --v_sum_sal number(10) := 80;
  v_num number(4) := 0;
begin
  dbms_output.put_line(get_sal1(80,v_num));
  dbms_output.put_line(v_num);
end;

3、注意

# 1、在没有时用NOCOPY时,主函数定义的值,在调用时,都会创建一个新的变量用来接收主函数的值,其中发生的操作是-->主函数:变量值一为:a,变量值二为:b -->当调用主函数的值时,外部declare会创建一个新的变量用来接收主函数的值,其中会产生的操作 —-> 调用时,主函数变量值a := c赋值给c,完成值传递之后,c := 将值传递给a,完成输出 

6、存储过程

注意:存储函数没有返回值,如果需要添加,在形参中添加,声明在begin中

1、创建存储过程
create or replace procedure add_sal(dept_id number,temp_sal out number)
is
       cursor sal_cursor is select employee_id,salary,hire_date from employees
       where department_id = dept_id;
       v_i number(4,2) := 0;
begin
       temp_sal := 0;
       for c in sal_cursor loop
         if to_char(c.hire_date,'yyyy') < '1995' then v_i := 0.05;
           elsif to_char(c.hire_date,'yyyy') < '1998' then v_i := 0.03;
             else v_i := 0.01;
         end if;
         
         -- 更新工资
         update employees set salary = salary * (1 + v_i)
         where employee_id = c.employee_id;
         -- 付出成本
         temp_sal := temp_sal + c.salary * v_i;
        end loop;
        dbms_output.put_line(temp_sal);
end;

2、调用存储过程
declare
  v_temp number(10) := 0;
begin
  add_sal(80,v_temp);
end;
3、查询存储过程及终止
-- 1、搜索是否存在某一个存储过程(浅查询)
SELECT a.sid, a.object, a.type
  FROM sys.v_$access a
 WHERE (a.object LIKE upper('%print_reciprocal') OR
       a.object LIKE lower('%print_reciprocal'))
-- 2、查询出某一存储过程的状态(俩表关联的新查询)           
  SELECT a.sid, a.object, a.type, b.serial#, b.status
    FROM sys.v_$access a, sys.v_$session b
   WHERE a.type = 'PROCEDURE'
   -- 括号中-->存储名,使用模糊查询
     AND (a.object LIKE upper('%print_reciprocal') OR
         a.object LIKE lower('%print_reciprocal'))
     AND a.sid = b.sid
        -- 其状态不是唯一的,可以更改为Inactive
     AND b.status = 'ACTIVE';
-- 3、终止命令中填写对应的SID,serial#俩个编号
ALTER system kill session '33,4185';

7、触发器

create or replace trigger delete_emp2
before
delete on emp2
for each row
begin
    insert into my_emp_bak
    values(:old.employee_id,:old.last_name,:old.salary);
end;

8、内置程序包

1、查看数据字典保留字
-- 查看Oracle的保留字
SELECT * FROM v$reserved_words m WHERE m.RESERVED='Y' order by keyword 

2、内置程序包的使用

-- 内置程序包
-- 1、生成随机数
select abs(mod(dbms_random.random,100)) from dual;
-- 生成10-20之间的任意数
select dbms_random.value(10,20) from dual;
-- 生成10-20之间的任意数,但不包括小数
select floor(dbms_random.value(10,20)) from dual;
/*
 dbms_random.string(类型,长度) 生成随机文本字符串,可以指定字符串长度和类型
 类型:U:代表大写字母  L:代表小写字母  A:代表大小写混写  P:代表任意字符  X:代表大写字符和数字组成
 注意:不包含汉字
*/
select dbms_random.string('P',10) from dual;
-- 日期转换
/*
   1、to_char
   2、to_date
   J:代表日期对应的内部的整数
*/
select to_char(sysdate,'yyyy-mm-dd hh:mm:ss')from dual;
-- 随机2022年的某一天
select to_char(to_date('2022-01-01','yyyy-MM-dd'),'J') from dual;
select to_date(trunc(dbms_random.value(2459581,2459800)),'J')from dual;

-- 定时任务
-- 创建一个表
create table test1001(times date);
-- 创建一个存储过程
create or replace procedure AlbertTest is
begin
  insert into test1001 values(sysdate);
end;

declare
v binary_integer; -- 记录定时任务的序号
begin
  AlbertTest();
  dbms_job.submit(v,'AlbertTest;',sysdate,'sysdate + 1/1440');
  dbms_output.put_line(v);
end;
     select * from test1001;
     Select * From user_jobs; -- 查看定时任务
     begin
       dbms_job.run(283); -- 必须运行相对应的序号
     end;
     begin
       dbms_job.remove(283); -- 删除定时任务对应的序号,定时任务即被删除
     end;
  
-- 读取文件
create or replace directory FILEPATH as 'd:\test'; -- 创建文件路径
drop directory FILEPATH
/*
注意:写文件  write 也可以用 w 表示
      读文件  read 也可以用 r 表示
      追加文件 append  也可以用 a 表示
*/
declare
 v_f utl_file.file_type;
 begin
   v_f :=utl_file.fopen('FILEPATH','file.txt','w'); -- 打开文件
   utl_file.put_line(v_f,'sdasdasda'); -- 写入文件
   utl_file.fclose(v_f); -- 关闭文件
end;
2、dbms_random包
  1. random:生成一个随机数,range: -power**(**231~231] 区间范围为左开右闭且为整数值

  2. normal:生成一个符合正态分布的随机数,标准差为1,期望值为0

  3. string:生成一个指定模式指定位数的随机字符串,其中

    • u 和 U 代表大写字母
    • l 和 L 代表小写字母
    • a 和 A 代表大小写字母混合输出
    • x 和 X 代表大写字母和数字混合输出
    • p 和 P 代表任意字符输出
  4. initialize :默认情况下,DBMS_RANDOM包是根据用户、时间、会话来进行初始化,INITIALIZE函数,通过设置相同的种子值,则每次生成的随机序列都将是一样的,即便是在不同的会话中,不同的用户下,随机生成的10个值都是一样的

    注意:initialize只支持数值,不支持其它类型

  5. seed:功能和initialize相似,但seed不仅支持数值型,同样也支持字符型,注意:字符型最大不能超过varchar2的最大范围

    DECLARE
      a NUMBER(12) := 0;
    BEGIN
      FOR i IN 1 .. 100 LOOP
        --select dbms_random.random into A from dual;
        SELECT floor(dbms_random.value(10, 20)) INTO a FROM dual;
        --select dbms_random.normal numbers INTO A from dual;
        dbms_output.put_line('第' || i || '次:' || a);
      END LOOP;
    END;
    
    -- initialize 
    begin
      dbms_random.initialize(-1.2);
      for i in 1 .. 20 loop
    dbms_output.put_line('第'||i||'次:'||dbms_random.random);
      end loop;
      end;
    -- seed
    BEGIN
      --dbms_random.seed(123);
      dbms_random.seed('hello');
      FOR i IN 1 .. 10 LOOP
        dbms_output.put_line(round(dbms_random.value * 100));
      END LOOP;
    END;
    
select * from (select * from dept order by dbms_random.random) where rownum < 4
select dbms_random.random from dual;
select dbms_random.normal from dual;
select dbms_random.string('P',10) from dual; 
select floor(dbms_random.value(10,20)) from dual;
3、dbms_job包
  1. dbms_job.submit:提交任务请求,其语法格式为

    # dbms_job.submit(序号,'存储过程',什么时间提交,'隔多久执行一次');
    dbms_job.submit(s,'Albert.test_emp;',sysdate,'sysdate + 1/1440');
    
  2. dbms_job.run(jobno):运行定时任务,括号中填写需要运行定时任务序号

  3. dbms_job.remove(jobno):删除定时任务,括号中填写需要删除的定时任务序号

  4. dbms.broken(jobno, broken, nextdate):停止定时任务,填写序号以及停止时间,默认为当前时间,注意其中broken返回布尔值

  5. dbms_job.interval(jobno, interval):修改间隔时间

  6. dbms_job.next_date(jobno, next_date):修改下次执行时间

  7. job:dbms_job.what(jobno, what):修改要执行的操作

# 1、创建存储过程
create or replace procedure test_boos3 is
begin
  # 输入操作语句
end test_boos3;
# 2、调用存储过程,并且声明变量,得到定时任务的序号,提交定时任务
declare
s binary_integer; -- 记录定时任务的序号
begin
  Albert.test_emp();
  dbms_job.submit(s,'Albert.test_emp;',sysdate,'sysdate + 1/1440');
  dbms_output.put_line(s);
end;
# 3、开始执行定时任务
begin
  dbms_job.run(26);
end;
# 4、删除 or 暂停定时任务
begin
  #dbms_job.remove(26); 
  dbms_job.broken(27,true,sysdate);
  #dbms_job.next_date(27,sysdate); 下次执行任务时间
end;

9、索引表(联合数组)and嵌套表

/*
  集合中的属性
  1、first取集合中第一个元素的下标
  2、last取集合中最后一个元素的下标
  3、count取集合元素的总长度
  4、limit取集合元素的最大值(注:索引表和嵌套表不限制元素个数,所以返回的是空行,可变长度数组使用才会返回最大值)
  5、delete([n])删除集合中的元素,n表示下标,即删除对应下标的值
  6、extend(n,[ind])扩展集合元素,n代表扩展元素个数,ind表示集合中元素的下标
  7、next(ind)取当前元素的下一个元素的下标
  8、prior(ind)取当前元素的上一个元素的下标
  
  下标同样是整数且必须是正数,同样可以使用字符串,下标不一定是连续的,元素个受index范围限制(-214483647 ~~ +214483647),语法后面接表索引类型
  语法:type  名称  is   table    of   数据类型   索引类型(pls_integer 或者 varchar2)
           变量   变量类型
  
  问题:如何取到当前元素的下一个元素的下标
*/
declare
-- 创建一个索引表
   type indexTableOne is table of varchar2(10) index by pls_integer;
   -- 声明变量
   s indexTableOne;
   v_index pls_integer;
begin
  -- 存储数据
  s(1) := 'Tom';
  s(-1) := 'Albert';
  dbms_output.put_line(s.first||' '||s(-1));
  dbms_output.put_line(s.limit||'<----最大值');
  --s.delete(1);
  dbms_output.put_line(s.count);
  dbms_output.put_line(v_index.next);
end;

declare
-- 声明一个索引表
   type AlbertTwo is table of number(10) index by pls_integer;
   -- 声明一个变量
   v_Two AlbertTwo;
   -- 声明一个第三方的下标,用来记录当前索引表的索引值
   -- 注:索引表声明为什么类型,当前索引值也要同为什么类型
   v_index pls_integer;
begin
   v_Two(-1) := 123;
   v_Two(-5) := 1233;
   v_Two(9) := 1234;
   v_Two(4) := 1235;
   v_Two(22) := 1236;
   v_Two(0) := 1237;
   -- 赋值为索引表中的第一个元素的索引
   v_index := v_Two.first;
   loop
     dbms_output.put_line(v_index||' '||v_Two(v_index));
     --dbms_output.put_line(v_Two(v_index).next);
     -- 当表中的最后一个元素索引等于第一个元素的索引时,退出循环
     exit when v_Two.last = v_index;
     -- 将元素的下一个索引赋值给v_index继续循环
     v_index := v_Two.next(v_index);
     end loop;
     --dbms_output.put_line(v_Two(v_index).next);
end;

declare
-- 创建索引表
   type t is table of trainee%rowtype index by pls_integer;
   -- 创建一个变量用来存储数据
   s t;
   i number :=1;
begin
  for a in(select * from trainee) loop
    s(i) := a;
    dbms_output.put_line(s(i).traineename||' ' ||s(i).sex);
    i := i+1;
    end loop;
end;

declare
   -- 声明记录类型
   type Albert is record(
   Sname varchar2(10),
   Sage  number(10)
   );
   -- 声明索引表
   type indexTable is table of Albert index by varchar2(4);
   -- 声明下标变量
   A indexTable;
   -- 声明变量类型,用来存储记录类型的数据
   firsts Albert;
begin
  firsts.Sname := '房东';
  firsts.Sage  := 50;
  A('1') := firsts;
  dbms_output.put_line(A('1').Sname||' '||A('1').Sage);
end;

/*
  嵌套表属性:
  1、下标同样是整数且必须是正数,同样可以使用字符串,下标必须是连续的,语法后面不接嵌套表索引类型
  2、语法:type  名称  is   table    of   数据类型
           变量   变量类型
  3、可在PLSQL中写,也同样可以存储到数据库中         
问题:嵌套表中-- 初始化的括号中是做什么的
      1、当嵌套表类型为varchar2时,初始化中可以写字符串,但是写单个数字?
      2、当嵌套表类型为number时,初始化中可以写多个数字,但是写单个数字?
*/

--声明嵌套表
declare
  type t_q is table of varchar2(10);
  v_q t_q;
begin
  -- 初始化嵌套表
  v_q := t_q('dsa','fqww','rqw');
  dbms_output.put_line(v_q(1));
end;

declare
  type t_q is table of number(10);
  v_q t_q;
begin
  -- 初始化嵌套表
  v_q := t_q(1,2);
  --v_q := t_q('天上人','蓝蓝天');
  -- 扩展表
  --v_q.extend(3);
  --v_q(1) := 12354;
  --v_q(2) := 456789;
  --v_q(3) := '人';
  dbms_output.put_line(v_q(1));
  --dbms_output.put_line(v_q(2));
  --dbms_output.put_line(v_q(1)||' ' ||v_q(2));
  dbms_output.put_line(v_q.count);
end;

-- 把嵌套表存储到数据库中
-- 在声明嵌套表前面添加 create
create type t_q is table of vachar2(190);
drop type t_q; -- 删除嵌套表
declare
   -- 声明变量接收数据
   v_q t_q;
begin
  -- 初始化嵌套表
  v_q := t_q('fasfas','weq','rqw');
  dbms_output.put_line(v_q(1));
end;

-- 在创建表的同时创建嵌套表
create type t_q is table of vachar2(190);
create table seven(
  ids varchar2(12),
  myname t_q
)nested table myname store as v_name;
-- 往嵌套表中添加数据
insert into seven values(1,t_q('Jack','杰克','克'));
select * from table(select myname from seven where ids = 1); --这样就可以查出嵌套表中以集合形式存在的数据

declare
  type t_q is table of trainee%rowtype;
  v_q t_q;
begin
  -- 初始化嵌套表
  v_q := t_q(trainee%rowtype);
  dbms_output.put_line(v_q(1));
end;

10、变长数组之bulk collect和批量绑定

/*
  1、特点:下标连续且只能为正的整数,元素个数有限制(初始化大小),可用于
  PLSQL中,同样也可存储到数据库中
  2、语法: 
    type 名称 is array(length) of 元素类型
  3、注意:声明边长数组时,该变长指的是:使用extend进行扩展时,不得超出
  定义时的长度,否则就溢出
  问题:
*/

-- 可变长度数组
declare
   -- 声明可变数组
   type a is array(103) of varchar2(10);
   -- 声明变量接收数据
   v_a a;
   --v_b a;
begin
  -- 初始化数组
  --v_a := a();
 -- v_a := a('sad','weq','csa');
  --v_a.extend(4);
   v_a := a('sad','dq');
   --v_b := a('sad','weq','csa');
   v_a.extend(3);
   v_a(3) := 'fga';
   v_a(4) := 'fga2';
   v_a(5) := 'fgaf';
  -- v_a(7) := 'fgaf';
   --v_a := a('sad','ddq','fg','u','ui','j','8ui','o');
   --v_a(8) := 'f';
  -- 打印出数组中元素个数,不给初始值,那么该数组
  dbms_output.put_line(v_a(1));
  dbms_output.put_line(v_a(2));
  dbms_output.put_line(v_a.last);
  dbms_output.put_line(v_a.count);
  dbms_output.put_line(v_a(3));
  dbms_output.put_line(v_a(4));
  dbms_output.put_line(v_a(5));
  --dbms_output.put_line(v_a(7));
end;

------------------------------------------------------
-- 在创建表的同时创建变长数组  <----明天完成
-- 先创建变长数组
create type a is array(190) of varchar2(10); 
create table mytab(id number(10),name a);
select * from mytab;
insert into mytab values(1,a('b','d','c','a'));
drop type a;
drop table mytab;


-------------------------------------------------------

/*
     bulk collect 
     :将查询出来的数据放入到一个集合变量中
     语法:
     select (需要查询的列)  bulk collect into (集合变量)
*/
declare
     -- 声明变量
     --v_name trainee.traineename%type;
     -- 定义集合类型嵌套
     type t_q is table of trainee.traineename%type;
     -- 定义变量接收
     v_q t_q;
begin
     -- 查询数据,将数据存放到集合中
     select traineename bulk collect into v_q from trainee;
     for i in v_q.first .. v_q.last loop
       dbms_output.put_line(v_q(i));
     end loop;
end;

-- 在游标中使用 bulk collect
declare
     cursor t_q is select * from trainee;
     -- 定义集合类型嵌套
     type s_q is table of trainee%rowtype;
     -- 定义变量接收
     v_q s_q;
begin
     -- 打开游标
     open t_q;
     -- 查询数据,将数据存放到集合中
     fetch t_q bulk collect into v_q;
     for i in v_q.first .. v_q.last loop
       dbms_output.put_line(v_q(i).traineename);
     end loop;
     close t_q;
end;
select * from dept;
delete from dept where deptno = 10;

/*
   批量绑定:做批量绑定时,对表中的列所做的操作都是对整张表的数据进行操作
   问题:是否对表进行增、改、查操作
*/
-- 批量绑定
declare
   -- 声明一个嵌套表
   type a is table of dept%rowtype;
   -- 声明变量接收数据
   v_a a;
begin
  --update dept set dname = Albert  where deptno = 10;
  --select deptno bulk collect into v_a from dept;
  -- 批量绑定
  forall i in v_a.first .. v_a.last
         delete from dept where deptno = v_a(i);
end;

11、Oracle中XML语法

1、XML文本编写需注意:

  • XML中的所有标签名和文档结构都是可以自定义的
  • XML标签名称可包含字母、数字及其他字符。标签名称可以字符 'XML、Xml、xml’开始,但不能以数字、标点符号开始,不包含空格
  • XML语法区分大小写,必须保持大小写一致
  • XML必须正确嵌套开始结尾标签名
  • XML文档中允许空元素的存在,所谓空元素就是标签中没有实际内容,表示方法有: 或
  • XML文本内容中的所有空格都会被保留
  • XML中特殊符号的引用:
    • 注意:实体中的引用字符隐藏卡里,需点击实体
    • > ; , < ; , & ; &apos ; " ; <–代表着下列符号的表示符,使用时需要将冒号和标识符之间的空格删除
名称 符号 实体引用
大于号 > >
小于号 < <
连接符 & &
单引号 ‘(英文单引号) '
双引号 ‘’ "

2、Oracle中操作XML数据

注意:函数中的属性值:xmlvalue,XQuery,new_value–>xmlvalue 为XMLType类型列名或变量,XQuery为字符串,用于指定查询XML实例中的XML节点的XQuery表达式,new_value:为修改的新节点树

  • existsNode(xmlvalue,XQuery)函数:检查某一个节点是否存在,如果存在返回 1 ,否则返回 2 ,xmlvalue 为XMLType类型列名或变量,XQuery为字符串,用于指定查询XML实例中的XML节点的XQuery表达式
select count(*) from Xmltable where existsNode(LXFS,'/联系方式/地址/邮政编码')=1;
  • FLOWER表达式

    • 包含模式匹配、过滤选择和结构构造

      • FLOWER是’For、Let、Where、Order by、Return’的缩写
    • 说明:

      for $x in doc("note.xml")/book/note
      let $y := /book/note/to
      where $x/number<20
      order by $x/brand
      return $x/brand
      
      • For:将note.xml文件中book元素下所有的note元素提取出来赋给变量$x,其中doc()是内置函数,作用是用于打开xml文档
      • let:可选,用于在XQuery表达式中为变量赋值
      • where:可选,用于选取note元素下number元素小于20的note元素,且number可改变
      • order by:可选,用于指定查询结果,并且按照brand升序排序
      • return:用于构造FLWOR中执行查询
12、补充

1、set unused目的:如果一张表中的某个字段存在数万条数据,使用直接删除可能会报错,除非添加足够的RSG空间,并且速度较慢,使用 set unused标记需要删除的列,然后该列会被隐藏,避开高峰期时,然后再删除

注意:

  • set unused 是不可逆的,除非对底层的基表进行修改,否则该列将永久被隐藏,因为set unused列后,会清除掉数据字典中的信息
  • 如果set unused的某列上存在索引,约束,同义词都会被自动删除,视图则会报错,如果重新添加原来的一列表中,那么视图即可重新使用
# 设置set unused
# ALTER TABLE [NAME] SET UNUSED CLOUNM [CLOUMN NAME];
alter table trainee set unused column tel; -- 单列
alter table trainee set un used (tel,deptid);-- 多列
# 删除被设置为set unused列
alter table trainee drop unused column;

2、分组 And 分组Rollup And cube分组

  1. Rollup:表示的意思是:除了分组的功能外,还进行累加的的,多了一个汇总。重点:后汇总
  2. cube:先汇总,然后再查询每个分组的值
       SELECT emp_name, dept_id, SUM(emp_salary)
       FROM emp
       GROUP BY CUBE(dept_id, emp_name);
        -----------------------------------------------------
       SELECT  GROUPING (emp_name), GROUPING (dept_id), emp_name, dept_id,SUM (emp_salary)
       FROM emp
       GROUP BY ROLLUP (emp_name, dept_id)
       ORDER BY 1, 2;
    

grouping groupset group

12、树形结构查询

  1. 俩个方向

    • 自上而下 top–>dwon,一个boos可能有多个manager,一个manager可能有多个emp,自上而下遍历一个不丢,顺序从左至右

    • 自下而上 down–>top,一个manager只能有一个boos,自下向上的顺序也是从左开始

  2. 格式

    • ​ 在select语句中使用connect by 和 start with 子句可以用来查询树形结构关系

      # 注意:prior在做左边就自上而下查询,在右边就自下而上查询
      selectcolumnfromtableconnect by prior 父节点
       = 子节点 【start with:表示从哪个节点开始】
      # eg: select empno,ename.mgr from emp connect by prior empno = mgr start with empno = 7566 -- 自上而下开始查,并且指定从empno = 7566编号上开始往下查
      
  3. 分层—>Level

    • 查询中,额可以使用伪列LEVEL显示每行数据的有关层次,LEVEL将返回树形结构中当前节点的层次
    # 首先得使用 column level format A20
    Level(level,level*3,'')
    # 层数字:有多少层级关系就有多少层
    # 分层使用level隔开,计算是:当分层数字为多少,那么就乘以3,然后再将前面用空格填补
    
  4. prior放的左右位置决定了检索是自底向上还是自顶向下. 左边是自上而下(找子节点),右边是自下而上(找父节点)

    • 找父节点:从当前节点开始,向上搜索,直到找到最高节点

    • 注意:只有当前分支的所有数据会被查询出来,若某个节点下伴随有多个分支节点,但是这些分支节点不在当前查询的分支节点上,就不会查询出来

    • select * from menu start with ids='132000' connect by  ids = prior parent_id;
      
    • 找子节点:从当前节点开始,向下搜索,直到找到最底节点

    • 注意:自上而下查询时,若当前分支节点下存在多个子分支节点,那么所有的子分支节点都会被查询出来,若某一个子分支节点下还存在子节点,那么优先将当前子分支节点下的数据查询出来,然后再继续查询当前分支节点下的其它子节点

    • select * from menu start with ids='130000' connect by prior ids =  parent_id;
      select * from menu start with ids='132100' connect by prior parent_id = ids;
      
13、RESTRICT_REFERENCES

程序辅助检验码,减产子程序的纯度,是否存在违规的地方。一般用在函数上,调用函数过程时,也需要做相应的设置检查,这是为了避免在DML语句上调用函数时不会产生错误

PRAGMA RESTRICT_REFERENCES(function_name | default , )RNDS, WNDS, RNPS, WNPS) | , TRUST)  <---语法

RNDS,WNDS,RNPS,WNPS可以同时指定。但当TRUST指定是,其它的被忽略。

DEFAUT是指作用在该程序包上的所有子程序,函数。

RNDS(Read No Database State),规定子程序不能读取任何的数据库状态信息。(即不会查询数据库的任何表,包括DUAL虚表)

RNPS(Read No Package State),规定子程序不能读取任何程序包的状态信息,如变量等。限制:如果子程序调用了SQLCODE和SQLERRM函数,就不能指定该变量

WNDS(Write No Database State),规定子程序不能向数据库写入任何信息。(即不能修改数据库表)

WNPS(Write No Package State),规定子程序不能向程序包写入任何信息。(即不能修改程序包变量的值),限制:如果子程序调用了SQLCODE和SQLERRM函数,就不能指定该变量

TRUST,指出子程序是可以相信的不会违反一个或多个规则。这个选项是需要的当用C或JAVA写的函数通过PL/SQL调用时,因为PL/SQL在运行是对它们不能检查。

这个编译指令只能在程序包及对象类型说明部分指定。

2、查询所有视图

select * from user_views  <--- 当前DB的所有视图

13、权限管理

1、当数据库用户进行DDL操作时,如果没有commit,之后继续执行DCL操作,那么DCL操作会隐式提交事务,其次,不管DCL操作是否成功执行,前面的DDL语句都会被提交

update sp set shop_price = -1 where names='徐福记';
grant select on Albert.Sp to public;     <====successfully
update sp set shop_price = 2 where names='徐福记';   <====当前记录被改变
grant a    to b;     <====successfully

你可能感兴趣的:(Oracle,oracle,数据库,dba,1024程序员节)