Mysql之约束&概念模型

一：约束：是添加在列上的,用来约束列的！
主键约束
非空约束
唯一约束
外键约束

二：概念模型
对象模型（java实体类）
关系模型（数据库中的表）
一对一，一对多，多对多！


1.1：主键约束特点（唯一标识）
非空，唯一，被引用(一般会被外键引用！)，
主键自增长(可以保证主键：非空和唯一！)：AUTO_INCREMENT

CREATE TABLE stu(
    -- 指定sid为主键并设置自动增长!
	sid	  INT PRIMARY KEY AUTO_INCREMENT,
	sname	VARCHAR(20),
);

假如创建了一个表，不记得加主键，想后来补上！

修改表时指定主键：ALTER TABLE stu ADD PRIMARY KEY(sid);
删除主键：ALTER TABLE stu DROP PRIMARY KEY;

主键自增长

CREATE TABLE stu(
      sid   INT PRIMARY KEY AUTO_INCREMENT,
      sname	VARCHAR(20)
  );

-- 如下都会自动设置主键的值！
insert into stu values(null,'wzj');
insert into stu(sname) values('hg');

修改表时设置主键自增长：ALTER TABLE stu CHANGE sid sid INT AUTO_INCREMENT;
修改表时删除主键自增长：ALTER TABLE stu CHANGE sid sid INT;

1.2：非空约束
因为某些列不能设置为NULL值，所以可以对列添加非空约束

 -- 对sname设置了非空约束
 CREATE TABLE stu(
		sid INT PRIMARY KEY AUTO_INCREMENT,
		sname	VARCHAR(20) NOT NULL
  );
  

 

1.3：唯一约束
因为某些列不能设置为重复的值，所以可以对列添加唯一约束

 -- 对手机号设置成了唯一 
 CREATE TABLE stu(
		sid INT PRIMARY KEY AUTO_INCREMENT,
		sname	VARCHAR(20) NOT NULL,
		phoneNumber VARCHAR(20) UNIQUE
  );

1.4：外键约束
A：外键一般要引用一个表的主键
B：外键可以重复，可以为空，但不可以引用一个不在的主键！
C：一张表中可以有多个外键！

用个例子“我有多台车”的例子说明 A,B两点
先来分析一下我和车的关系：
人和车： 一个人可以有多辆车，但一辆车只属于一个人,所以是人和车是一对多的关系，因为物以稀为贵，所以人是主表，车是从表
，而且多方是引用一方的，就相当于外键引用主键，就说明车里面有一个外键是指向人里面的主键！！

-- 一方是主表
create table person(
	pid int primary key auto_increment,
	pname varchar(20)

);

insert into person(pid,pname) values(1001,'wzj');
insert into person values(1002,'dyt');

select * from person;

-- 多方是从表！
create table car(
	cid int primary key auto_increment,
	cname varchar(20),
	-- 外键
   pid int,
  constraint fk_car_person foreign key(pid) references person(pid)
);


-- 外键是引用一个主键,而且引用的主键可以重复,可以为空,但是不能没有!

insert into car(cid,cname,pid) values(1,'法拉利',1001);
insert into car(cid,cname,pid) values(2,'奔驰',1001);
insert into car(cid,cname,pid) values(3,'宾利',null);
-- insert into car(cid,cname,pid) values(4,'宝马',1003); 会报错！

 

下面这个例子：用来说明C点
部门和我的关系是一对多，班级和我的关系也是一对多，所以我是从表，多方引用一方，外键引用主键
就说明在我的表中，有两个外键分别指向部门的主键和班级的主键

create table department(
	did int primary key auto_increment,
  dname varchar(20)
);


create table class(
	cid int primary key auto_increment,
  cname varchar(20)
);


create table my(
	mid int primary key auto_increment,
  mname varchar(20),
	did int,
	cid int,
  constraint  fk_my_department foreign key(did) references department(did),
  constraint  fk_my_class      foreign key(cid) references department(cid)
);

注：一般先创建主表（一的那方），再创建从表（多的那方），这样等创建从表的时候就可以用外键引用主表中的主键了

外键的语法
语法：CONSTRAINT 约束名称 FOREIGN KEY(外键列名) REFERENCES 关联表(关联表的主键) 

  创建表时指定外键约束
  create talbe emp (
    empno int primary key,
    ...
    deptno int,
    CONSTRAINT fk_emp FOREIGN KEY(mgr) REFERENCES emp(empno)  
  );

  修改表时添加外键约束
  ALERT TABLE emp
  ADD CONSTRAINT fk_emp_deptno FOREIGN KEY(deptno) REFERENCES dept(deptno);

  修改表时删除外键约束
  ALTER TABLE emp
  DROP FOREIGN KEY fk_emp_deptno;/*约束名称*/

 

二：概念模型
对象模型：可以双向关联，而且引用的是对象，而不是一个主键！在java中是domain！！！例如：User、Student（实体类）
关系模型：只能多方引用一方，而且引用的只是主键，而不是一整行记录。在数据库中表

一对一，一对多，多对多：分别用对象模型和关系模型描述一下！ 
注：一对多跟多对一是一回事，只是考虑问题的不同角度罢了！
比如：一个爸爸有多个女儿，从爸爸的角度来看，一对多，从女儿们的角度来看是多对一！！！

 2.1：Java中的体现：

  //1. 一对一
  class Employee {//多方关联一方
     ...
     private Department department;
  }
  class Department {//一方关联多方
     ...
     private List<Employee> employees;
  }

  // 2. 一对一
  class Husband {
     ...
     private Wife wife;
  }
  class Wife {
     ...
     private Husband
  }

  //3. 多对多
  class Student {
     ...
     private List<Teacher> teachers
  }
  class Teacher {
     ...
     private List<Student> students;
  }

 2.2：在数据中的表中的体现！！
 2.2.1：一对一关系：在表中建立一对一关系比较特殊，需要让其中一张表的主键，即是主键又是外键

-- 一对一！我和老婆
create table wife(
	wid int primary key auto_increment,
	wname varchar(20)
);

insert into wife values(null,'dyt');
insert into wife values(null,'西施');
insert into wife values(null,'妲己');

select * from wife;

-- 所以hid即是主键也是外键！ 主键：非空,唯一, 外键: 引用主键！
create table husband(
	hid int primary key,
	hname varchar(20),
  constraint fk_husband_wife foreign key(hid) references wife(wid) 
);

insert into husband values(1,'wzj');
insert into husband values(2,'张三');
insert into husband values(3,'李四');
-- insert into husband values(4,'王五');  -- 不符合外键的特性：引用了没有的主键！

select * from husband;

2.2.2：一对多关系： 

-- 一方是主表
create table person(
	pid int primary key auto_increment,
	pname varchar(20)

);

insert into person(pid,pname) values(1001,'wzj');
insert into person values(1002,'dyt');

select * from person;

-- 多方是从表！
create table car(
	cid int primary key auto_increment,
	cname varchar(20),
	-- 外键
  pid int,
  constraint fk_car_person foreign key(pid) references person(pid)
);


-- 外键是引用一个主键,而且引用的主键可以重复,可以为空,但是不能没有!

insert into car(cid,cname,pid) values(1,'法拉利',1001);
insert into car(cid,cname,pid) values(2,'奔驰',1001);
insert into car(cid,cname,pid) values(3,'宾利',null);
-- insert into car(cid,cname,pid) values(4,'宝马',1003); 会报错！

select * from car;

 2.2.3：多对多关系：在表中建立多对多关系需要使用中间表，即需要三张表，在中间表中使用两个外键，分别引用其他两个表的主键。

-- 多对多需要使用第三张表，也就是中间表,
create table teacher(
	tid int primary key,
  tname varchar(20)
);


insert into teacher(tid,tname) values(1,'王老师');
insert into teacher(tid,tname) values(2,'张老师');
insert into teacher(tid,tname) values(3,'李老师');

select * from teacher;


create table student(
	sid int primary key,
  sname varchar(20)
);

insert into student(sid,sname) values(1,'马云同学');
insert into student(sid,sname) values(2,'马化腾同学');
insert into student(sid,sname) values(3,'乔布斯同学');

select * from student


create table stu_teach(
	sid int,
	tid int,

	constraint fk_student foreign key(sid) references student(sid),
	constraint fk_teacher foreign key(tid) references teacher(tid)
);

insert into stu_teach(sid,tid) values(1,1);
insert into stu_teach(sid,tid) values(1,2);
insert into stu_teach(sid,tid) values(1,3);

select * from stu_teach