oracle数据库（四）

Lesson 7  Specifying Variables at Runtime(指定运行时变量)
1定义：运行时变量可以让我们和sql语句之间有个交互，允许我们执行sql语句时动态传递参数
    2.语法：
&varName
    3.运行时变量可以出现在任意位置
例如：
  select &colName1,&colName2
  from &tbName
  where &colname = &colValue;


  例如：
select id,last_name
from s_emp
where id = &id;


运行时，服务器会提示：
输入 id 的值:
当输入完成按下回车：
原值    3: where id = &id
新值    3: where id = 2


  例如：
   select id,last_name
from s_emp
where last_name = '&name';




note:  1.&代表取值。&varName，代表取varName这个变量的值，如果这个变量值，之前不存在，那么系统会提示输入这个变量的值。如果存在，直接取值。
2.set verify on ，打开交互提示，如果打开，会显示old和new value。现在默认都是打开的。
 使用set verify off，关闭。


    4.定义变量：
 define[def] varName = value;
 查看定义的变量：
define[def] [varName];
 取消定义：
undefine/undef  varName;
例如：
1. define name=zhangsan
定义一个变量名字为name,值为zhangsan
运行select语句时，如果语句中遇到&name会自动替换为zhangsan
例如：
  select id,last_name
  from s_emp
  where last_name='&name';
2.def/define  : 查看当前环境中定义的所有变量
3.def/define name : 查看变量name的值。
如果不想在select语句中&name的外边使用''，则可以在定义变量name时写成define name='''zhangsan''';'可以用来转义'
   5.使用accept用来定义带数据类型和提示符的变量
accept varName : 代表定义一个变量名字为varName,当按下回车时需要用户输入值。
accept varName dataType : 代表定义一个带数据类型的变量
例如：accept varNum number :代表定义一个变量名字为varNum，类型为Number，当输入类型不是数字类型是报错，提示继续输入。
prompt：当输入变量时，给用户的提示信息。
accept myNum number prompt 区域id：
定义一个Number类型的变量myNum，当按下回车时提示区域id：
accept nyName char prompt 名字:


如果希望插入的值是隐藏的，可以在后边写上HIDE：
accept num number prompt 密码： HIDE
   6.取消变量的定义
undefine varName;
   7.向脚本文件传递参数
在文件中参数使用&n(n代表数字)来表示取第几个参数值，然后再调用文件执行的时候使用
@file val....(多个参数值使用空格分开。)
------------------------------------------------------------------------------


Lesson 8  Overview of Data Modeling and Database Design


软件开发的步骤可大致分为:
1.需求分析
2.系统设计
3.编码实现---
4.系统测试
5.运行维护




系统设计中一个重要的环节就是数据库设计


数据库设计的时候需要先进行数据建模(实体关系图 E-R图)


数据建模的依据就是前期所做的需求分析


数据建模


1.Model of system in client's mind
2.Entity model of client's model
3.Table model of entity model
4.Tables on disk


实体-关系图
实体-关系图(Entity Relationship Diagram),也称为E-R图,提供了表示实体类型、属性和关系的方法，用来描述现实世界的概念模型。


构成E-R图的基本要素是实体、属性和关系


实体(Entity)：实体用来表示具有相同特征和性质的事物(类似于java的类(域对象))，实体由实体名和实体属性来表示。
s_dept:id,name,region_id


dept{


int id;
String name;
Region region;
}
Region{
id
name
}
属性(Attribute)：实体所具有的某一特性，一个实体可以有若干个属性


关系(Relationship)：实体彼此之间相互连接的方式称为关系。一般可分为以下 3 种类型:
一对一关系 (1 ∶ 1)


这种关系比较少见
维护关系：随意选择一方构建外键
例如：Wife and Husband
wife:
id  name h_id
1 zs    1
2   ww    3
husband:
id  name w_id
1   ls    1
3   zl    2
一对多关系 (1 ∶ N)
比较常见：
维护关系：在多的一方维护一方的唯一值列作为外键
s_emp(n)
id  last_name ... dept_id
1 zs          1
2   ls   1
....
s_dept(1)
id  name r_id   se_id
1    1    1       1
1    1    1       2
1    1    1       3
比如：student   classroom


多对多关系 (M ∶ N)
学生   课程
student:
id  name  c_id
1 zs     1
1   zs     2
1   zs     3
2   ls     1


course
id name s_id
1  网球  1
1  网球  2


建立一张中间表，桥表
学生选课表
student              course
id     name         id     name
1       zs           1      网球
2       ls           2  体育舞蹈
student_course
s_id  c_id
1 1
1 2
1 3
2 2
2 10
3 7
把一个多对多(m:n)转化为两个一对多(1:n,1:m)


may-be 和 must-be
在实体与实体之间的关系中,都会存在着may-be和must-be这俩种情况,例如:
系统中有订单和顾客俩个实体(N:1关系),一个顾客对应多个订单,一个订单对应一个顾客,而且一个顾客可以(may be)没有订单和他对应,一个订单一定(must be)会有顾客和它对应.




ER图中符号的表示
1) #：主要标识
 (#):次要标识
2) * : 非空
  #*:表示主键。
3) o : 可有可无
4) 虚线: may be  顾客这边虚线，顾客可能没有订单
5) 实线: must be 订单这边实线，订单一定是属于某个客户。
6) 竖杠(|): UID Bar代表要强制在(|)一方建立一个联合主键，将对方ID(主键)拿过来做联合主键
简单点说就是外键同时做了当前表的主键
7) 伞状图标代表多的一方,不是伞状图标则代表一的一方




数据库设计
数据建模完成之后,可以把ER图转换成数据中的表
1.实体的名字转换为表的名字
2.实体的属性转换为表中的列
3.具有唯一特点的属性设置为表中的主键
4.根据实体之间的关系设置为表中某列为外键列(主外键关联)


设计关系数据库时，遵从不同的规范要求，才能设计出合理的关系型数据库，这些不同的规范要求被称为不同的范式，各种范式呈递次规范，越高的范式数据库冗余越小。


目前关系数据库有六种范式：
第一范式(1NF)
第二范式(2NF)
第三范式(3NF)
巴斯-科德范式(BCNF)
第四范式(4NF)
第五范式(5NF，又称完美范式)


注:满足最低要求的范式是第一范式(1NF)。在第一范式的基础上进一步满足更多规范要求的称为第二范式(2NF)，其余范式以次类推。一般说来，数据库只需满足第三范式(3NF)就行了


第一范式:
   一个表中,每个列里面的值是不能再分割的.
   例如:我们设计的表中有一个列是:爱好
   这个列的值可能会是这样:足球篮球乒乓球
   但是这值是可以再分割的:足球、篮球、乒乓球
   所以这种设计是不满足第一范式


第二范式:
第二范式是在满足第一范式的基础上
   表中的非主键列都必须依赖于主键列
   例如:
   订单表: 订单编号 是主键
   订单编号  订单名称   订单日期  订单中产品的生产地
   这几个非主键列中,产品生产地是不依赖于订单编号的,所以这种设计是不满足第二范式


第三范式:
第三范式是在满足第二范式的基础上


表中的非主键列都必须直接依赖于主键列,而不能间接的依赖.
(不能产生依赖传递)
   例如:
   订单表:   订单编号 是主键
   订单编号  订单名称  顾客编号  顾客姓名
   顾客编号依赖于订单编号,顾客姓名依赖于顾客编号,从而顾客姓名间接的依赖于订单编号,那么这里产生了依赖传递,所以这个设计是不满足第三范式的
customer  order      orderLine




主键和外键
主键:
1.能做主键的列必要满足非空唯一的特点
2.只要满足非空唯一的列都可以做主键
3.可以让表中一个有意义的列做主键,比如说学号,它既表示学生学号又作为表中的主键,因为这个列满足非空唯一的条件
4.也可以找一个没有意义的列做主键,就是用来唯一标识一行记录的
5.我们可以让多个列联合在一起做表中的主键,那么它就是联合主键,要求这几个列的值联合在一起是非空唯一的，
任意一列都非空
教室
教学楼  教室号
1 101
1 102
2 101
2 102
3 102
教室
层 教室
1 01
1 02
1 03
2 01
3 01
(学生选课)
s_id  c_id
1 1
1 2
2 1


外键:
1.表中的某一个列声明为外键列,一般这个外键列的值都会引用于另外一张表的主键列的值(有唯一约束的列就可以,不一定非要引用主键列)
s_emp--dept_id :外键列(1,2,3,4)   依赖于
_briup外键列值可以为空
s_dept--id(1,2,3)(有唯一约束的列就可以,不一定非要引用主键列)
2.另外一张表的主键列中出现过的值都可以在外键列中使用
3.外键列值也可以为空的,提前是这个外键列在表中不做主键,因为我们也可以把表中的外键列当做主键来使用(只有满足非空唯一的要求就可以)
4.如果把B表中的联合主键的值引用到A表中做外键,因为是俩个列在B表中做联合主键,那么A表引用过来的时候也要把俩个列的值都引用过来,那么它们在A表中就会作为一个联合外键出现(联合外键)


完整性约束：
实体完整性：
引用完整性
列级完整性
用户自定义
建表：
1.映射实体----表
2.映射属性----列
3.添加约束
4.描述关系信息(外键)




------------------------------------------------------------------------------
Lesson 9  Create Table


1.oracle数据库中的多种数据结构：
1.表结构            存储数据
2.视图 一张表或多张表中数据的字节
3.sequence 主要用来生成主键值
4.index 提高检索性能
  我们需要学会创建数据结构
2.表结构：
1.表结构可以随意创建
2.表结构不需要预先申请空间
3.可以在线修改。
3.创建语法：
创建表的方式有两种：基本操作  子查询
DDL
  3.1基本操作
3.1.1 语法：
create table [schema.]tb_name(
col_name datatype [default value] [colum_constraints],
...,
[table_constraint],
...
   );
create table tbl1(
id number
);
 note :
1.create table 关键字，固定写法，
 schema，在oracle数据库中代表用户名
2.tb_name代表表名，可以自定义：但是需要遵循命名规则(详见3.1.2命名规则)：
3.列名一般也要求遵循明明规则(详见3.1.2命名规则)
4.dataType，列所属的数据类型，详见(3.1.3 oracle支持的数据类型)
3.1.2 命名规则
1.字母开头
2.长度为1-30
a-z A-Z 0-9
3.只能有大小写英文,数字和_ $ #
4.同一个用户下的对象名不能重复
5.不能使用关键词作为表名（如：select group等等）
3.1.3 oracle支持的数据类型：
类型名 描述
VARCHAR2(size) 可变长字符串(4000)
CHAR(size) 定长字符串(2000)
NUMBER 数字类型
NUMBER(p,s) 数字类型
DATE 日期类型
CLOB 字符大数据对象(4G)
BLOB 二进制大数据对象(4G)
note：
1.char，varchar2，varchar
 用法:
char(size),varchar2(size) varchar(size)
size用来指明所能保存字符值的上限。
 区别：
 name char(100)
char：定长字符
即一旦确定了()中的字符个数，在保存数据的时候，不论你保存的字符个数为多少个，所占空间大小为固定的()中的字符个数。
如char(2)  ： 保存 a  ab都占用2个字符空间


varchar , varchar2:不定长字符
即在保存数据的时候，会先判断字符个数，然后再分配对应的空间进行保存。
如varchar2(2)
保存a 占用1字符空间
保存ab 占用两2字符空间


在oracle数据库中，指定变长字符串首选varchar2(兼容性).
2.number(p,s):
p确定数字的有效位数(有效数字是指从左边第一个不是0的数字开始到精确的数字截止)
s确定数字的小数点位数
number(5,2)表示整数部分最大3位，小数部分为2位；
number(4,2)最大值和最小值为多少？


number(1,3)
0.003
在s<0时,比如number(4,-2)是小数点对左边两位进行四舍五入，总共的最大位数是p+|s|=6位，这是必须的，只能比6位小，否则报错，也就是允许的最大值是999949，如果再多一个999950左边两位就会进位 变成七位数  这是不允许的。比如number(5,-2) 如果插入值12345678.9是错误的  因为小数点左边已经有8位 超过5+2=7位。
  正确实例：
 NUMBER(5,-2) 表示数的整数部分最大为7其中对整数的倒数2位为0,前面的取整
   number(4,-2) 插入值899949 ，对49进行四舍五为00，为899900.。
 1234567    NUMBER(5,-2)   1234600   即使对67五入了也要随后置零
3.date： 日期类型
系统默认日期类型：'DD-MON-YY'
操作字符类型和日期类型数据的时候，一定要放到''中间
3.1.4 default：设置默认值
1.作用：设置在往表中插入数据时，如果没有指定该列的值，默认插入的值。
2.默认值可以是合法的字面值（根据定义的列的数据类型来赋值），表达式，或者是sysdate和user等合法的sql函数。
create table test_def(
id number(7),
start_date date default sysdate);
3.默认值不能使用其他表的列或者不存在的列/伪列
3.1.5 约束
定义：所谓约束就是强制表中的数据列必须遵循的一些规则。
 而且如果表中存在依赖约束，可以阻止一些不合理的删除操作。
分类：
列级约束：直接跟在列完整性定义后边的约束
column dataType unique,
col number(7) [unique],
col2 varchar2(10) not null,
unique(col)
表级约束：定义在表级别的约束(即在列的完整定义完成后，才定义的约束)
column dataType ,
unique(column)


语法:
create table table_name(....);
create table table_name(
  列名 类型 列级约束,
  列名 类型 列级约束,
  列名 类型 列级约束,
  列名 类型 列级约束
);


create table table_name(
  列名 类型,
  列名 类型 列级约束,
  列名 类型,
  列名 类型,
  表级约束,
  表级约束,
  表级约束
);


种类：
  约束名  描述 分类
NOT NULL    ：非空     列级
UNIQUE ：唯一 列级/表级
PRIMARY KEY ：主键 列级/表级
FOREIGN KEY ：外键 列级/表级
CHECK ：自定义 列级/表级
创建时间：
1.创建表的同时定义约束
2.表创建完成之后，通过修改表结构(后期章节描述)
创建语法：
列级：
column dataType [CONSTRAINT constraint_name] constraint_type,
id number(7) constraint test_id_pk primary key
表级：
column,...(列完整定义结束)
   [CONSTRAINT constraint_name] constraint_type ( column, ...),....
   id number not null,
   name varchar2,
   primary key(id),
   unique(name)


详细介绍：
1.not Null：值不允许为null，阻止null值输入
note:只能是列级约束
例如：
create table test_nn1(
id number constraint test_nn1_id_nn not null,
name varchar2(10)
);
insert into test_nn1(id) values(1);
insert into test_nn1(name) values('aa');
//添加默认值
create table test_nn2(
id number default 007 constraint test_nn2_id not null,
name varchar2(10)
);
insert into test_nn2(name) values('aa');
create table test_nn2(
id number(7) constraint testnn2_id_nn not null,
name varchar2(10) default 'zs' not null
);
insert into test_nn2(id,name) values(1,'ls');
insert into test_nn2(id) values(1);
2.unique：唯一值约束，要求值必须唯一，不能重复。
note：
1.可以设置单列唯一，或者组合列唯一
2.如果unique约束单列，此列可以为null
3.可以是列级，也可以是表级约束，联合唯一为表级
4.对于unique列，oracle会自动创建唯一值索引。
例如：
列级：
create table test_un1(
id number constraint test_un1_id unique
);
insert into test_un1(id) values(1);
insert into test_un1(id) values(1);
表级：
create table test_un2(
id number,
constraint test_un2_id unique(id)
);
联合唯一：
create table test_un3(
id number,
name varchar2(10),
constraint test_un3_id_name unique(id,name)
);
create table test_un4(
id number,
name varchar2(10),
unique(id,name)
);
3.Primary key:主键
note:
1.主键用来给表中的每一行数据设置唯一标识符。主键只能有一个。
2.主键可以是单列，也可以是组合列。
3.强制非空且唯一，如果由多列组成，组合唯一且列的每一部分都不能为null。
4.可以表级，可以列级。联合主键为表级
5.自动创建唯一值索引。
例如：
列级：
create table test_pk1(
id number constraint test_pk1_id primary key
);
insert into test_pk1(id) values(1);
insert into test_pk1(id) values(2);
insert into test_pk1(id) values(1);
表级：
create table test_pk2(
id number,
constraint test_pk2_id primary key(id)
);
create table test_pk(id number primary key);


create table test_pk2(
id number(7),
name varchar2(10),
primary key(id),
unique(name)
);


联合主键
create table test_pk3(
id number,
name varchar2(10),
constraint test_pk3_id_name primary key(id,name)
);
insert into test_pk3(id,name) values(1,'zs');
insert into test_pk3(id) values(2);
insert into test_pk3(id,name) values(1,'zs');
insert into test_pk3(id,name) values(1,'ls');
create table test_pk4(
id number,
name varchar2(10),
primary key(id,name)
);
4.foreign key：外键
一般在设计表与表之间的关系时，为了减少数据冗余，一般做的操作是在其中一张表中设置一列(组合列)，这一列(组合列)的值可以唯一的确定另外一张表中和当前表相关联的一行数据。那么这个列称为外键。
note：
1.可以是单列，也可以是组合列
2.引用当前表或者其他表中(只要想和当前表建立关系的表) 的主键列或者unique列
3.可以是表级别/列级别，联合外键为表级
4.值必须是引用的列的值或者为null
5.有外键约束时，如果想要删除的父表(被引用的表)中的某一条数据时，必须保证在子表(引用表)中没有和这条数据相关联的数据存在。
6.ON DELETE CASCADE ,指明在删除父表中数据时可以级联删除子表中数据
例如：
create table test_fko(
id number primary key
);
insert into test_fko(id) values(1);
列级：
create table test_fkm1(
id number constraint test_fkm1_emp_id references test_fko(id)
);
insert into test_fkm1(id) values(1);
insert into test_fkm1(id) values(2);
表级：
create table test_fkm2(
id number,
constraint test_fkm2_emp_id foreign key(id) references test_fkf(id)
);
create table test_fkm2(
id number,
name varchar2(10) not null,
age number(3),
gender varchar2(2),
unique(name,age),
foreign key(id) references test_fko(id));


联合主键(表级)：
create table test_fko2(
id number,
name varchar2(10),
primary key(id,name)
);
insert into test_fko2(id,name) values(1,'zs');
联合外键(表级)：
create table test_fkm3(
id number,
name varchar2(10),
constraint test_fkm3_emp_id_name foreign key(id,name)
references test_fko2(id,name)
);
insert into test_fkm3(id,name) values(1,'zs');
delete from test_fko2 where id = 1;
//删除记录时,当删除的记录中有某些列作为其他表或列的外键时，无法直接删除：
create table test_fkm4(
id number,
name varchar2(10),
foreign key(id,name) references test_fko2(id,name) on delete cascade
);
insert into test_fkm4(id,name) values(1,'zs');
delete from test_fko2 where id = 1;
//
create table test_fkm5(
id number,
name varchar2(10),
foreign key(id,name) references test_fko2(id,name) on delete set null
);
insert into test_fkm5(id,name) values(1,'zs');
delete from test_fko2 where id = 1;
5.check ： 定义每一行必须遵循的规则
note：
1.可以是表级/列级约束
例如：
列级：
create table test_ch1(
gender varchar2(2) check(gender in ('F','M')),
age number check (age>=15 and age<=20)
);
insert into test_ch1(gender,age) values('F',17);
insert into test_ch1(gender,age) values('F',12);
表级：
create table test_ch2(
gender varchar2(2),
constraint test_check_gender check(gender in ('F','M'))
);
create table test_ch3(
gender varchar2(2) default 'F',
check(gender in ('F','M')),
name varchar2(7)
);
insert into test_ch3(name) values('zs');
创建test_c1表，要求字段有id(主键),name(唯一)，age(非空)，gender('F','M')
create table test_c1(
id number(7) primary key,
name varchar2(10) unique,
age number(3) not null,
gender varchar2(1) check(gender in('F','M'))
);
//表级,约束加名字
创建test_s1表，要求字段有bnum,rnum(联合主键)，c1_id(外键)
create table test_s1(
bnum number(7),
rnum number(7),
c1_id number(7) references test_c1(id),
primary key(bnum,rnum)
);
foreign key(c1_id) references test_c1(id)


创建test_t1表，要求字段有start_date,s1_bnum,s1_rnum(三列做联合主键),dede(not null)
create table test_t1(
start_date date,
s1_bnum number(7),
s1_rnum number(7),
dede varchar2(200) not null,
foreign key(s1_bnum,s1_rnum) references test_s1(bnum,rnum),
primary key(start_date,s1_bnum,s1_rnum)
);


查询约束名字:
select constraint_name,table_name
from user_constraints;


   3.2. 子查询
一般使用子查询建表，要将另外一张表中的某些数据存放到一张新的表格中。(相当于将原来打印在控制台上的信息，现在直接定义成一张新的表格。)
  语法：
create table tb_name[(column,...)]
as
select ...
  note：1.在用子查询建表时，只有not Null约束会被复制。
2.创建表时可以指定列名，也可以不指定，但是一定不指定列的数据类型
3.创建表的列跟子查询表的列数要保持一 致。
create table test_s2
as
select id
from s_emp;


create table test2_s2(id,name)
as
select id,last_name
from s_emp
where salary >1300
;
创建表
----------------------------------------------------------------------
model 10  数据字典


1.字典，就是用来帮助人们查看一些信息，查看一些内容
2.数据字典描述：
1.数据字典在数据库被创建时创建。
2.被数据库服务器自动更新和维护


  oracle的数据字典就是oracle存放有关数据库信息的地方。用途就是用来描述数据的。


   比如一个表的创建者信息，创建时间信息，所属表空间信息，用户访问权限信息等。


　　数据库数据字典是一组表和视图结构。它们存放在SYSTEM表空间中


　　当用户在对数据库中的数据进行操作时遇到困难就可以访问数据字典来查看详细的信息。


　　用户可以用SQL语句访问数据库数据字典。
例如：
1.查看当前用户可以访问的所有数据字典
select table_name from dictionary;
注意:自己建的表在dictionary这个表是查询不到的
根据查询的结果(按照前缀不同可以分为四类)：
静态数据字典:主要是在用户访问数据字典时不会发生改变的,按前缀不同，作用范围的分为三类:
   1、以user开头的数据字典： 包含当前用户所拥有的相关对象信息。--能够查到对象的所有者是当前用户的所有对象


2、以all开头的数据字典：  包含当前用户有权限访问的所有对象的信息。--能够查到所有当前用户有权限访问的对象
（与user_*相比，all_* 并不需要拥有该对象，只需要具有访问该对象的权限即可）


3、以dba开头的数据字典：  包含数据库所有相关对象的信息。--只能是有dba权限的用户查询,能查到数据库中所有对象
（前提是当前用户具有访问这些数据库的权限，一般来说必须具有管理员权限）


  动态数据字典:是依赖数据库运行的性能的，反映数据库运行的一些内在信息,数据库运行的时候
它们会不断进行更新，所以在访问这类数据字典时往往不是一成不变的Oracle中这些动态性能
视图都是以v$开头的视图.
oracle包含了一些潜在的由系统管理员如SYS维护的表和视图，由于当数据库运行的时候
它们会不断进行更新，所以称它们为动态数据字典
（或者是动态性能视图）。这些视图提供了关于内存和磁盘的运行情况，
所以我们只能对其进行只读访问而不能修改它们。




　　数据字典内容包括：


　　1,数据库中所有模式对象的信息，如表、视图、簇、及索引等。
当前用户的对象信息存放在user_objects
　　2,分配多少空间，当前使用了多少空间等。


　　3,列的缺省值。


　　4,约束信息的完整性。


　　5,Oracle用户的名字。


　　6,用户及角色被授予的权限。


　　7,用户访问或使用的审计信息。


　　8,其它产生的数据库信息。




例如：
查询数据字典中和赋权相关的表或视图
select *
from dictionary
where lower(comments) like '%grant%';
1.查看当前用户的拥有的对象名和对象类型：
select object_name,object_type
from user_objects;
2.查看当前用户下的所有的表
select table_name from user_tables;
user_tables就是一个数据字典。
3.查询当前用户下面所创建的所有约束的名字
select constraint_name
from user_constraints;


4.查看当前用户所定义的所有的约束的名字和类型
select constraint_name, constraint_type
from user_constraints
where table_name = 'S_EMP';
5.查找约束名字和关联的列的名字
select constraint_name, column_name
   from user_cons_columns
where table_name = 'S_EMP';
-------------------------------------------------------------------------
Lesson 11  Manipulating Data （DML）


数据操作语言：
insert update delete
事务控制语言：
commit rollback savepoint


1.insert语句
两种格式：
直接插入
子查询插入
    1. 直接插入基本语法：
insert into tb_name[(col_name,...)]
values(val1,....);
        note：
  1.如果给每个列都插入数据，可以省略table后边的列，并且插入值的顺序和定义表的顺序一致
  2.如果插入的顺序和表定义的顺序不同，或者只插入某几列的值table_name后边必须跟上列名
  3.字符串和日期类型的值必须使用‘’引起来
  4.insert语句一次只插入一条数据
  5.插入的值可以使用系统函数，例如---sysdate
  6.插入的值可以使用运行时参数。
例如：
create table test_dml1(
id number primary key,
name varchar2(10),
gender varchar2(2) check (gender in ('F','M')),
birthday date);
  插入：
1.insert into test_dml1(id,name) values (3,'zs');
   2.insert into test_dml1(id,name,birthday) values (1,'lisi','09-9月-10');
3.insert into test_dml1(id,name,birthday) values (2,user,sysdate);
4.insert into test_dml1(id,name,birthday) values (&id,'ss',sysdate);
2.使用子查询插入
insert into table_name[(col_name,....)]
select .......
note：
1.不出现values关键字
2.插入的列的名字和子查询返回结果的列相匹配。
例如：


 1.create table test_dml2(
id number primary key,
name varchar2(10),
gender varchar2(2) check (gender in ('F','M')),
birthday date);
insert into test_dml2
   select * from test_dml1;


 2.
 create table test_dml3(
id number primary key,
name varchar2(10),
gender varchar2(2) check (gender in ('F','M')),
birthday date
);
insert into test_dml3(id,gender,name,birthday)
  select id,gender,name,birthday from test_dml1 where id<3;
2.delete语句：
语法：delete [from] tbl_name [where option...]
note:在加外键约束的时候，如果想在删除主表的记录的同时对外键表中已经存在的关联关系记录进行操作可以使用下面两个关键词：
on delete cascade:级联删除,删除主表记录，外键表的关联记录一块儿删除
on delete set null：删除主表记录，外键表的关联记录该列的值变成null


例如：
1.从test_dml3表中删除id = 1
delete from test_dml3 where id = 1;
2.create table test_del1(
id number references test_dml1(id));
insert into test_del1 values(1);
delete from test_dml1 where id = 1;
 create table test_del2(
id number references test_dml1(id) on delete cascade);
insert into test_del2 values(2);
delete from test_dml1 where id = 2;
 create table test_del3(
id number references test_dml1(id) on delete set null);
insert into test_del3 values(3);
delete from test_dml1 where id = 3;


3.update 语句：
语法：update table_name set column=value,[column=value]
     [where condition...];
note：
1.如果不加条件，默认修改表中所有的行。


例如：
1. update test_dml1 set name = 'wangwu',gender='M'
where id = 3; 只更改id=3的行。
2.update test_dml1 set gender = 'F';所有行都改。


4.事务控制：
　　 事务是指作为单个逻辑工作单元执行的一组相关操作。　　
　　 这些操作要求全部完成或者全部不完成。
使用事务的原因：保证数据的安全有效。
事务控制使用:commit,savepoint,rollback;
note：
    commit：提交事务，提交事务是指让这个事务里面的所有操作都生效到数据库中
rollback：回滚事务，回滚事务是指让这个事务里面的所有操作都撤销,rollback只能对
未提交的数据撤销，已经Commit的数据是无法撤销的，因为commit之后已经持久化到数据库中
当一个sql命令执行一个事务就开始了，当遇到以下情况，事务自动完成
    1.commit或者rollback
    2.DDL或者DCL命令执行
    3.错误，退出，或者系统崩溃


事务的四个特点:（ACID）
1、原子性（Atomic）：事务中所有数据的修改，要么全部执行，要么全部不执行。
只有所有的操作执行成功，整个事务才能提交，事务中任何一个数据库操作失败，己经执行的任何
操作都必须撤销，让数据返回到初状态。
　　2、一致性（Consistence）：事务完成时，要使所有所有的数据都保持一致的状态，换言之：通过事务进行 的所有数据修改，必须在所有相关的表中得到反映。
如从A账户转账100元到B账户，不管操作成功与否，A和B的存款总额不变的。
　　3、隔离性（Isolation）：事务应该在另一个事务对数据的修改前或者修改后进行访问(事务之间互不影响)
在并发数据操作时，不同的事务拥有各自的数据空间，它们的操作不会对对方产生干扰。准确地
说，并非要求做到完全无干扰，数据库规定了多种事务隔离级别，不同隔离级别，对应不同的
干扰程度，隔离级别越高，数据一致性越好，但并发性越弱。


数据并发的问题:
脏读（Dirty Read）：A事务读取B事务尚未提交的更改数据，并在这个数据的基础上操作。
如果恰巧B事务回滚，那么A事务读到的数据根本是不被承认的。
事务T1更新了一行数据，还没有提交所做的修改，T2读取更新后的数据，
T1回滚，T2读取的数据无效，这种数据称为脏读数据(如果读到了)。


不可重复读（UNrepeatable Read）：A事务读取到了B事务已经提交的更改的数据。
假设A在取款事务的过程中，B往该账户转账100元，
A两次读取的账户的余额发生不一致
事务T1读取一行数据，T2修改了T1刚刚读取的记录(并提交)，T1再次
查询，发现与第一次读取的记录不相同，称为不可重复读。


幻读（Phantom Read）：A事务读取了B事务提交的新增数据，这时A事将出现幻象读.
 举一个例子，假设银行系统在同一个事务中，两次统计存款账户的总金额
 ,在两次统计过程中刚好新增了一个存款户，并存入100元，这时
 两次统计的总金额不一致
 事务T1读取一条带WHERE条件的语句，返回结果集，T2插入一条新纪录，
 恰好也是T1的WHERE条件，T1再次查询，结果集中又看到T2的记录，
 新纪录就叫做幻读。
幻读和不可重复读是两个容易混淆的概念，前者是指读到了其他己经提交的事务的新增数据，而后者是指读到了己经提交事务的更改数据（更改或删除），为了避免这种情况，采取的对策是不同的一个着重对整张表，一个着重对某些记录加限制。


为了处理这些问题，SQL标准定义了以下几种事务隔离级别:
　　 NO_TRANSACTION　　　　   不支持事务


　　 READ UNCOMMITED　　　    允许脏读、不可重复读、幻读
　　 READ COMMITED　　　　    允许不可重复读、幻读，不允许脏读
　　 REPEATABLE READ 　　　　 允许幻读，不允许脏读、不可重复读
　　 SERIALIZABLE　　　　　　 脏读、不可重复读、幻读都不允许
Oracle数据库支持READ COMMITTED(默认) 和 SERIALIZABLE这两种事务隔离级别(可以进行设置)，
所以Oracle始终不支持脏读。
SET TRANSACTION ISOLATION LEVEL
[READ UNCOMMITTED|READ COMMITTED|REPEATABLE READ|SERIALIZABLE]
Set transaction isolation level read committed
Set transaction isolation level serializable


测试(read committed)：
使用两个终端窗口,同一个账号登录到数据库中,观察事务是否提交对用户查看数据的影响
注:一个用户对A表某一列做了DML操作,但是没有提交事务,这时候别的用户是不能对A表这一列再做其他的DML操作。(为了保证数据的安全和一致性)
create table test_tcl1(
id number(3) primary key
);
窗口一：
select * from test_tcl1;//读不到数据
窗口二：
insert into test_tcl1 values(1);//不提交
窗口一：
select * from test_tcl1;//读不到数据，不支持脏读
窗口二：
commit;
窗口一：
select * from test_tcl1;//发现多了一行记录，出现幻影读
窗口二：
update test_tcl1 set id = 11 where id =1;
commit;
窗口一：
select * from test_tcl1;//发现值已更改，出现了不可重复读
窗口二：
insert into test_tcl1 values(2);
commit;
窗口一：
select * from test_tcl1;//发现值为两列，出现了幻影读
　　4、持久性（Durability）：保证事务对数据库的修改是持久有效的，一旦事务提交成功后,即使发生
系统故障，也不应该丢失。


在这些事务特性中，数据“一致性”是最终目标，其他特性都是为达到这个目标的措施、要求或手段。








5.第一类丢失更新：
事务A撤销事务时，将事务B已经提交的事务覆盖了。
第二类丢失更新：
事务A和事务B同时修改某行的值，
1.事务A将数值改为1并提交
2.事务B将数值改为2并提交。
这时数据的值为2，事务A所做的更新将会丢失。




6.隐式事务提交：
    1.DDL语句（create..），执行commit
    2.DCL语句（gant....），执行commit
    3.正常退出终端。


    note：如果系统崩溃，或者sqlplus不正常退出，事务回滚。


7.事务提交或者回滚之前的状态
1.因为数据库缓存区的存在，数据前一次的状态可以被回复
2.当前用户可以会看使用DML操作的数据的结果，但是其他用户不能看到当前用户的DML操作结果
3.所有受影响的行会被锁定，其他用户不能修改。


8.显示结束事务
commit：之前所做的所有会影响数据库的操作，都会对数据库产生持久的影响。
rollback：取消之前所做的所有操作


note：事务一旦提交，不能rollback


savepoint: 保存回滚点
savepoint point_name;


rollback to point_name;回滚到指定的标记点。标记点之后所做的所有操作都会被取消，但是之前的不受影响。
create table test_tcl2(
id number(3) primary key
);
insert into test_tcl2 values(1);
insert into test_tcl2 values(2);
savepoint p1;
commit;
rollback to p1;
update test_tcl2 set id = 11 where id =1;
savepoint p2;
insert into test_tcl2 values(3);
insert into test_tcl2 values(4);
savepoint p3;
select * from test_tcl2;
rollback to p2;
select * from test_tcl2;
exit