该博客说说关于数据库中一个重要的知识点——约束
 
 
一、什么是约束
 
 
 
约束英文：constraint
 
 
约束实际上就是表中数据的限制条件
 
 
 
二、约束作用
 
 
 
表在设计的时候加入约束的目的就是为了保证表中的记录完整和有效
 
 
比如name字段中要让其用户名不重复，这就需要添加约束。或者必须注册的时候需要添加邮箱等
 
 
三、约束种类
 
非空约束(not null)
唯一性约束(unique)
主键约束(primary key) PK
外键约束(foreign key) FK
检查约束(目前MySQL不支持、Oracle支持)
 
 
 
下面将逐一介绍以上约束
 
 
 
四、非空约束
 
 
 
用not null约束的字段不能为null值，必须给定具体的数据
 
 
创建表，给字段添加非空约束（创建用户表，用户名不能为空）
 
	mysql> create table t_user(
    -> id int(10),
    -> name varchar(32) not null
    -> );
Query OK, 0 rows affected (0.08 sec)
 
如果没有插入name字段数据，则会报错
 
mysql> insert into t_user (id) values(1);
ERROR 1364 (HY000): Field 'name' doesn't have a default value
 
 
五、唯一性约束
 
 
 
unique约束的字段，具有唯一性，不可重复，但可以为null
 
 
###创建表，保证邮箱地址唯一(列级约束)
 
mysql> create table t_user(
    -> id int(10),
    -> name varchar(32) not null,
    -> email varchar(128) unique
    -> );
Query OK, 0 rows affected (0.03 sec)
 
1、表级约束
 
mysql> create table t_user(
    -> id int(10),
    -> name varchar(32) not null,
    -> email varchar(128），
	-> unique(email)
    -> );
 
如果插入相同email会报错
 
mysql> insert into t_user(id,name,email) values(1,'xlj','932834897@qq.com');
Query OK, 1 row affected (0.00 sec)

mysql> insert into t_user(id,name,email) values(2,'jay','932834897@qq.com');
ERROR 1062 (23000): Duplicate entry '932834897@qq.com' for key 'email'
 
2、使用表级约束，给多个字段联合约束
 
 
 
联合约束，表示两个或以上的字段同时与另一条记录相等，则报错
 
 
mysql> create table t_user(
    -> id int(10),
    -> name varchar(32) not null,
    -> email varchar(128),
    -> unique(name,email)
    -> );
Query OK, 0 rows affected (0.01 sec)
 
插入第一条数据
 
mysql> insert into t_user(id,name,email) values(1,'xxx','qq.com');
Query OK, 1 row affected (0.05 sec)
 
插入第二条数据如果是与联合字段中的一条相同另一条相同，也是可以的
 
mysql> insert into t_user(id,name,email) values(2,'mmm','qq.com');
Query OK, 1 row affected (0.05 sec)
 
插入第三条数据，如果与联合字段都相同，则报错
 
mysql> insert into t_user(id,name,email) values(3,'mmm','qq.com');
ERROR 1062 (23000): Duplicate entry 'mmm-qq.com' for key 'name'
 
3、表级约束可以给约束起名字(方便以后通过这个名字来删除这个约束)
 
mysql> create table t_user(
    -> id int(10),
    -> name varchar(32) not null,
    -> email varchar(128),
    -> constraint t_user_email_unique unique(email)
    -> );
Query OK, 0 rows affected (0.06 sec)
 
 
 
constraint是约束关键字，t_user_email_unique自己取的名字
 
 
例：用户名既不能为空，也不能重复
 
name varchar(32) not null unique
 
 
六、主键约束(primary key)PK
 
 
 
表设计时一定要有主键
 
 
1、主键涉及术语
 
主键约束
主键字段
主键值
 
2、以上三种术语关系
 
 
 
表中的某个字段添加主键约束后，该字段为主键字段，主键字段中出现的每一个数据都称为主键值
 
 
3、主键约束与“not null unique”区别
 
 
 
给某个字段添加主键约束之后，该字段不能重复也不能为空，效果和"not null unique"约束相同，但是本质不同。
 
 
 
 
主键约束除了可以做到"not null unique"之外，还会默认添加"索引——index"
 
 
4、一张表应该有主键字段，如果没有，表示该表无效
 
主键值：是当前行数据的唯一标识、是当前行数据的身份证号
即使表中两行记录相关数据相同，但由于主键值不同，所以也认为是两行不同的记录
 
5、按主键约束的字段数量分类
 
 
 
无论是单一主键还是复合主键，一张表主键约束只能有一个(约束只能有一个，但可以作用到好几个字段)
 
 
单一主键：给一个字段添加主键约束
复合主键：给多个字段联合添加一个主键约束(只能用表级定义)
 
单一主键(列级定义)
 
mysql> create table t_user(
    -> id int(10) primary key,
    -> name varchar(32)
    -> );
Query OK, 0 rows affected (0.07 sec)
 
单一主键(表级定义)
 
mysql> create table t_user(
    -> id int(10),
    -> name varchar(32) not null,
    -> constraint t_user_id_pk primary key(id)
    -> );
Query OK, 0 rows affected (0.01 sec)
 
复合主键(表级定义)
 
mysql> create table t_user(
    -> id int(10),
    -> name varchar(32) not null,
    -> email varchar(128) unique,
    -> primary key(id,name)
    -> );
Query OK, 0 rows affected (0.05 sec)
 
6、在MySQL数据库提供了一个自增的数字，专门用来自动生成主键值，主键值不用用户维护，自动生成，自增数从1开始，以1递增(auto_increment)
 
mysql> create table t_user(
    -> id int(10) primary key auto_increment,
    -> name varchar(32) not null
    -> );
Query OK, 0 rows affected (0.03 sec)
 
插入两行记录，id主键值会自动增加
 
mysql> insert into t_user(name) values('jay');
Query OK, 1 row affected (0.04 sec)

mysql> insert into t_user(name) values('man');
Query OK, 1 row affected (0.00 sec)


mysql> select * from t_user;
+----+------+
| id | name |
+----+------+
|  1 | jay  |
|  2 | man  |
+----+------+
2 rows in set (0.00 sec)
 
 
七、外键约束(foreign key)FK
 
只能是表级定义（如以下例子）
 
foreign key(classno) references t_class(cno)
 
什么是外键
 
若有两个表A、B，id是A的主键，而B中也有id字段，则id就是表B的外键，外键约束主要用来维护两个表之间数据的一致性。
 
A为基本表，B为信息表
 
1、外键涉及到的术语
 
外键约束
外键字段
外键值
 
2、外键约束、外键字段、外键值之间的关系
 
 
 
某个字段添加外键约束之后，该字段称为外键字段，外键字段中每个数据都是外键值
 
 
3、按外键约束的字段数量分类
 
单一外键：给一个字段添加外键约束
复合外键：给多个字段联合添加一个外键约束
 
4、一张表可以有多个外键字段（与主键不同）
 
5、分析场景
 
设计数据库表，用来存储学生和班级信息
 
两种方案
 
方案一：将学生信息和班级信息存储到一张表
 
sno     sname      classno      cname
1       jay			100			浙江省第一中学高三1班
2		lucy		100			浙江省第一中学高三1班
3		king		200			浙江省第一中学高三2班
 
 
 
缺点：数据冗余，比如cname字段的数据重复太多
 
 
方案二：将学生信息和班级信息分开两张表存储
 
学生表（添加单一外键）
 
sno(pk)		sname		classno(fk)
1			jack		100
2			lucy		100
3			king		200
 
班级表
 
cno(pk)		cname
100			浙江省第一中学高三1班
200			浙江省第一中学高三2班
 
结论
 
 
 
为了保证学生表中的classno字段中的数据必须来自于班级表中的cno字段中的数据，有必要给学生表中的classno字段添加外键约束
 
 
注意点
 
外键值可以为null
外键字段去引用一张表的某个字段的时候，被引用的字段必须具有unique约束
有了外键引用之后，表分为父表和子表 
  
班级表：父表
学生表：子表
 
创建先创建父表
删除先删除子表数据
插入先插入父表数据
 
存储学生班级信息
 
mysql> drop table if exists t_student;
mysql> drop table if exists t_class;

mysql> create table t_class(
    -> cno int(10) primary key,
    -> cname varchar(128) not null unique
    -> );

mysql> create table t_student(
    -> sno int(10) primary key auto_increment,
    -> sname varchar(32) not null,
    -> classno int(3),
    -> foreign key(classno) references t_class(cno)
    -> );

mysql> insert into t_class(cno,cname) values(100,'aaaaaaxxxxxx');
mysql> insert into t_class(cno,cname) values(200,'oooooopppppp');
mysql> insert into t_student(sname,classno) values('jack',100);
mysql> insert into t_student(sname,classno) values('lucy',100);
mysql> insert into t_student(sname,classno) values('king',200);
 
班级表t_class
 
mysql> select * from t_class;
+-----+--------------+
| cno | cname        |
+-----+--------------+
| 100 | aaaaaaxxxxxx |
| 200 | oooooopppppp |
+-----+--------------+
 
学生表t_student
 
mysql> select * from t_student;
+-----+-------+---------+
| sno | sname | classno |
+-----+-------+---------+
|   1 | jack  |     100 |
|   2 | lucy  |     100 |
|   3 | king  |     200 |
+-----+-------+---------+
 
上表中找出每个学生的班级名称
 
mysql> select s.*,c.* from t_student s join t_class c on s.classno=c.cno;
+-----+-------+---------+-----+--------------+
| sno | sname | classno | cno | cname        |
+-----+-------+---------+-----+--------------+
|   1 | jack  |     100 | 100 | aaaaaaxxxxxx |
|   2 | lucy  |     100 | 100 | aaaaaaxxxxxx |
|   3 | king  |     200 | 200 | oooooopppppp |
+-----+-------+---------+-----+--------------+
 
结论
 
以上是典型的一对多的设计：在多个地方加外键(子表加外键)

使用在sequence_item中；
 定义数据有约束的随机化；
 constraint addr_type_cons {addr_type ==0;}
 
constraint request_type_cons { if(op_type==READ)
									requst_type =0;
									else if（op_type==WRITE） 
										requst_type==1;
									else
										requst_type==0;
}
 
constraint discontinue_gap_cons {discontinue_gap>=5;discontinue_gap<=10;}
 
constraint_mode = 0：关闭约束，1：开启约束
 
class A;
  rand bit [31:0] arr[];
 
  constraint arr_size { arr.size() inside {[10:15]}; }
  constraint arr_uniq { unique {arr}; }
 //数组元素不重复
endclass

 
 
 
 
主要就是增加数据约束的。
 
 
 
 
 
 
 
Oracle中的约束简单介绍
 
约束   Including Constraints
 
    在数据库中使用约束(constraints)是为了在该数据库中实施所谓的"业务规则"其实就是防止非法信息进入数据库,满足管理员和应用开发人员所定义的规则集.
 
    ORACLE使用完整性约束(integrity constraints)防止不合法的数据写入数据库,管理员和开发人员可以定义完整性规则,增强商业规则,限制数据表中的数据.如果一个DML语句执行的任何结果破坏了完整性约束,ORACLE就会回滚语句,返回错误信息.

     约束是通过使用CREATE TABLE或ALTER TABLE语句生成的.(建立表时或者表建立后修改都可)如果相关的约束定义在单列上,可以在列这一级指定约束的定义;多列约束必须定义在数据表级,相关的列要在括号中指定,用逗号分隔.如果没有为约束提供一个名字,那么ORACLE会分配一个系统生成的唯一名字,以SYS_开头,你可以使用关键字CONSTRAINTS后面跟随相关的约束名字来为约束指定名字.

 ORACLE支持五种类型的完整性约束
 NOT NULL (非空)--防止NULL值进入指定的列,在单列基础上定义,默认情况下,ORACLE允许在任何列中有NULL值.
 CHECK (检查)--检查在约束中指定的条件是否得到了满足.
 UNIQUE (唯一)--保证在指定的列中没有重复值.在该表中每一个值或者每一组值都将是唯一的.
 PRIMARY KEY (主键)--用来唯一的标识出表的每一行,并且防止出现NULL值,一个表只能有一个主键约束.
 POREIGN KEY (外部键)--通过使用公共列在表之间建立一种父子(parent-child)关系,在表上定义的外部键可以指向主键或者其他表的唯一键.
 
 
 


 以下几种约束 、并 一一列举：

1.主键约束：
 要对一个列加主键约束的话，这列就必须要满足的条件就是分空
 因为主键约束：就是对一个列进行了约束，约束为（非空、不重复）
 以下是代码  要对一个列加主键，列名为id,表名为emp

 格式为：
 alter table 表格名称 add constraint 约束名称 增加的约束类型 （列名）

 例子：
 alter table emp add constraint ppp primary key (id)

 ————————————————————————————————

2.check约束：
 就是给一列的数据进行了限制
 比方说，年龄列的数据都要大于20的
 表名（emp） 列名（age）

 格式：
 alter table 表名称 add constraint 约束名称 增加的约束类型 （列名）

 例子：
 alter table emp add constraint xxx check(age>20)

 ______________________________________________________________________

3.unique约束：
 这样的约束就是给列的数据追加的不重复的约束类型

 格式：
 alter table 表名 add constraint 约束名称 约束类型（列名）
 比方说可以给ename列加个unique，让ename列的数据不重复
 例子：
 alter table emp add constraint qwe unique(ename)

 ————————————————————————————————

4.默认约束：
 意思很简单就是让此列的数据默认为一定的数据

 格式：
 alter table 表名称 add constraint 约束名称 约束类型 默认值） for 列名

 比方说：emp表中的gongzi列默认为10000

 alter table emp add constraint jfsd default 10000 for gongzi


 ————————————————————————————————

5.外键约束：
 这个有点难理解了，外键其实就是引用
 因为主键实现了实体的完整性，
 外键实现了引用的完整性，
 应用完整性规定，所引用的数据必须存在！

 其实就是个引用，
 比方说一个表名称叫dept 里面有2列数据 一列是ID一列是ENAME
 id：表示产品的编号
 ename：表示产品的名称

 另外一个表格名称是emp 里面有2列数据，一列是ID 一列是DID
 id:表示用户号
 did：表示购买的产品号

 要让emp表中的did列去引用dept表中的id

 可以用下面的方法

 格式：
 alter table 表名 add constraint 约束名称 约束类型 (列名) references 被引用的表名称 （列名）

 例子：
 
alter table emp add constraint jfkdsj foreign key (did) references dept (id)
 
 
 
 
 
 
 

  
 
约束定义存储在数据字典中,查询USER_CONSTRAINTS可以获得相关信息.
 

定义约束
 CREATE TABLE [schema.]table
                   (column datatype [DEFAULT expr]
                   [column_constraint],
                       ...
                   [table_constraint][,...]);
 e.g.
 CREATE TABLE employees
                   (employee_id NUMBER(6),
                       first_name     VARCHAR2(20),
                       ...
                       job_id           VARCHAR2(10) NOT NULL,
                       CONSTRAINTS emp_emp_id_pk PRIMARY KEY (EMPLOYEE_ID));
 列级的约束定义
 column [CONSTRAINT constraint_name] constraint_type,
 表级约束的定义
 column,..
 [CONSTRAINT constraint_name] constraint_type (column,...)

NOT NULL约束
 只能定义在列级,不能定义在表级.
 e.g.
 CREATE TABLE employees
                   (employee_id NUMBER(6),
                       last_name     VARCHAR2(25) NOT NULL, //没有指定名字,将用系统SYS_命名
                       salary          NUMBER(8,2),
                       commission_pct NUMBER(2,2),
                       hire_date    DATE CONSTRAINT emp_hire_date_nn NOT NULL);   //用户定义了名字

UNIQUE约束
 用来保护一个表中的一个或者多个列没有任何两行在收到保护的列中具有重复的数据.ORACLE在唯一键列上自动生成一个唯一索引以实现唯一性
 e.g.
 CREATE TABLE employees
                   (employee_id NUMBER(6),
                       last_name     VARCHAR2(25) NOT NULL, 
                       salary          NUMBER(8,2),
                       commission_pct NUMBER(2,2),
                       hire_date DATE NOT NULL,
                       CONSTRAINT emp_email_uk UNIQUE(email));

PRIMARY KEY约束
 唯一键的所有特征都适用于主键约束,只是在主键列中不允许有NULL值.一个表只能有一个主键.
 e.g.
 CREATE TABLE departments
                   (department_id NUMBER(4),
                       department_name VARCHAR2(30) CONSTRAINT dept_name_nn NOT NULL,
                       manager_id       NUMBER(6),
                       location_id           NUMBER(4),
                       CONSTRAINT dept_id_pk PRIMARY KEY(department_id));

FOREIGN KEY 约束
 用来保护一个表中的一个或者多个列,它会通过一个主键主键或者唯一键保证对于每个非NULL值在数据库的其他地方都有一个数据可用.这个外部键就是在生成此约束的表(子表)中的一个或多个列,在父级表和子表中,相关列的数据类型必须匹配.外部键列和引用键(reference key)列可以位于相同的表中(自引用完整性约束).
 e.g.
 CREATE TABLE employees
                   (employee_id NUMBER(6),
                       last_name     VARCHAR2(25) NOT NULL, 
                       salary          NUMBER(8,2),
                       commission_pct NUMBER(2,2),
                       hire_date DATE NOT NULL,
                       deparment_id NUMBER(4),
                       CONSTRAINT emp_dept_fk FOREIGN KEY(department_id) REFERENCES departments(department_id),
                       CONSTRAINT emp_email_uk UNIQUE(email));

 上例中是在表级定义外部键约束,如果在列级定义,不同的是:
 CREATE TABLE employees
                   (...,
                       department_id NUMBER(4) CONSTRAINT emp_deptid_fk REFERENCES departments(department_id),
                   ...);
                    //没有关键字FOREIGN KEY
 FOREIGN KEY约束还有两个关键字是
 ON DELETE CASCADE --当删除所引用的父表记录时,删除子表中相关的记录
 ON DELETE SET NULL--与上面不同的是删除时,转换子表中相关记录为NULL值
 默认情况下,如果没有指定以上两个中任一,则父表中被引用的记录将不能被删除.

CHECK 约束
 [CONSTRAINT <constraint name>] CHECK (<condition>
 这里CHECK子句中的CONDITION应该求值为一个布尔值结果,并且可以引用相同行中其他列的值;不能包含子查询,序列,环境函数(SYSDATE,UID,USER,USERENV)和伪列(ROWNUM,LEVEL,CURRVAL,NEXTVAL),一个列上可以定义多个CHECK约束,如果所定义的条件为FALSE,则语句将回滚.
 CREATE TABLE employees
                   (...,
                       salary NUMBER(8,2) CONSTRAINT emp_salary_min CHECK (salary>0),
                       ...);
 
 
 
 
 
添加约束
 ALTER TABLE employees
 ADD CONSTRAINT emp_manager_fk FOREIGN KEY(manager_id) REFERENCES employees(employee_id);
删除约束
 ALTER TABLE employees
 DROP CONSTRAINT emp_manager_fk;
 ALTER TABLE departments
 DROP PRIMARY KEY CASCADE; //由于departments被employees.department_id引用了
 对于NOT NULL约束,用ALTER TABLE MODIFY子句来删除
 ALTER TABLE employees MODIFY last_name NULL;
关闭约束
 ALTER TABLE employees
 DISABLE CONSTRAINT emp_emp_id_pk CASCADE;   //如果没有被引用则不需CASCADE关键字
 当你生成一个约束时,约束自动打开(除非你指定了DISABLE子句0,当用DISABLE关闭UNIQUE或者PRIMARY KEY约束时,ORACLE会自动删除相关的唯一索引,再次打开时,ORACLE又会自动建立的.
打开约束
 ALTER TABLE employees
 ENABLE CONSTRAINT emp_emp_id_pk; //注意,打开一个先前关闭的被引用的主键约束,并不能自动打开相关的外部键约束

 可以从USER_CONSTRAINTS表和USER_CONS_COLUMNS视图中查询约束的信息
 SELECT constraint_name,constraint_type,search_condition
 FROM user_constraints
 WHERE   table_name='EMPLOYEES';

约束类型
 C--CHECK和NOT NULL都算为C TYPE
 P--PRIMARY KEY
 R--REFERENTIAL INTEGRITY就是外部键约束
 U--UNIQUE

 SELECT constraint_name,column_name
 FROM user_cons_columns
 
WHERE   table_name='EMPLOYEES';
 
 
 
 
 
 
 
主要就是增加数据约束的。
 
 
 
 

把一个工程导入as 的时候报错，Failed to resolve: com.android.support.constraint:constraint-layout:1.0.0-alpha9，
 
很明显是constraint-layout的依赖的问题。
 
 
 
 
怎么解决这个问题呢，其实也不难，主要是你的Android studio里没有constraint-layout:1.0.0-alpha9这个东西。怎样确定你的Android studio里有哪个版本呢？
 
 
 
 
 
 
第一步，先点击1处的SDK Manager，然后就会有个弹出一个比较大的对话框
 
第二步，点击SDK tools。
 
第三步，勾选右下角的show Package Details
 
第四步，你就可以看到你安装了constraint-layout的哪个版本了，如果一个也没有装，那就赶紧勾选一个，然后点击ok，Android studio就会开始下载了。
 
 
 
刚刚我们说到你的Android studio里没有constraint-layout:1.0.0-alpha9这个东西，所以报错，那么解决这个bug的方法就是，安装constraint-layout:1.0.0-alpha9这个版本就好了。
 
 
 
当然比如说你的Android studio里装的是constraint-layout:1.0.0而不是constraint-layout:1.0.0-alpha9，那么你也可以把app的build.gradle里constraint-layout:1.0.0-alpha9改成constraint-layout:1.0.0。这样Sync按钮后也可以解决这个问题。
 
在android studio3.5以上的版本中，可能找不到support repository这个目录，建议把constraint-layout:1.0.0-alpha9的依赖改为    implementation "com.android.support.constraint:constraint-layout:1.1.3"
 
 
 
如果本文对你有帮助的话，麻烦在左侧点个赞，谢谢支持！