SQL数据定义
每个关系
SQL基本类型
char（n）：固定长度字符串，用户指定长度，也可以使用全称character。
varchar（n)：可变长度字符串，用户指定最大长度n，等价于全称character varying。
int：整数类型（和机器相关的整数有限子集）
smallint：小整数类型（和整数相关整数类型子集）
numeric（p, d):定点数，精度由用户指定。这个数有p为数字（加上一个符号位），其中d位数字在小数点右边。这种类型的字段上，numeric(3,1)可以精确储存44.5，但是不能精确存储44.5或者0.32这样的数。
real，double precision：浮点数于双精度浮点数，精度与机器相关。
float（n）：精度至少为n的浮点数。
char(10)，当我们存放“asd”时，会追加7个空字符达到10个的长度，但是在varchar（10）则不会。存放相同值，但是类型为char或者varchar，在数据库系统下，有可能不同。推荐使用varchar。
SQL提供nvarchar类型存放使用Unicode表示多语言数据。然而，很多数据库甚至允许在var插入类型存放Unicode（采用UTF-8）.
基本模式定义
create 他变了创建SQL关系
c r e a t e t a b l e t a b l e N a m e ( A 1 D 1 , A 2 D 2 , . . . , A n D n , < 完 整 性 约 束 1 > , < 完 整 性 约 束 1 > ) ; create table tableName( A_1 D_1,\\ A_2 D_2,\\ ..., \\ A_n D_n,\\ <完整性约束_1>,\\ <完整性约束_1> ); createtabletableName(A1D1,A2D2,...,AnDn,<完整性约束1>,<完整性约束1>);
SQL支持很多不同的完整性约束，在本节只讨论其中几个：
primary key（A j 1 _{j1} j1,A j 2 j_2 j2,A j 3 _{j3} j3,…A j m _{jm} jm):primary-key声明表示属性 A j 1 _{j1} j1,A j 2 j_2 j2,A j 3 _{j3} j3,…A j m _{jm} jm构成关系主码，主码属性必须非空且唯一。
foreign key（A k 1 _{k1} k1,A k 2 _{k2} k2,A k 3 _{k3} k3,…A k m _{km} km）reference：foreign key 声明表示在关系中任意元组在属性（A k 1 _{k1} k1,A k 2 _{k2} k2,A k 3 _{k3} k3,…A k m _{km} km）上的取值必须对应于关系s中某元组在主码属性上的取值。
not null：表明在该属性上不允许空值。
create database School;create table department(dept_name varchar(20),building varchar(15),budget numeric(12, 2),primary key(dept_name));create table course(course_id varchar(7),title varchar(50),dept_name varchar(20),credits numeric(2,0),primary key (course_id),foreign key(dept_name) references department(dept_name));create table instructor(ID varchar(5),name varchar(20) not null,dept_name varchar(20),salary numeric(2,0),primary key(ID),foreign key (dept_name) references department(dept_name));create table section(course_id varchar(8),sec_id varchar(8),semester varchar(6),year numeric(4,0),building varchar(15),room_number varchar(7),time_clot_id varchar(4),primary key (course_id, sec_id, semester, year),foreign key (course_id) references course(course_id));create table teachers(ID varchar(5),course_id varchar(8),sec_id varchar(8),semester varchar(8),year numeric(4,0),primary key (ID, course_id, sec_id, semester, year),foreign key(course_id, sec_id, semester, year) references section(course_id, sec_id, semester, year),foreign key(ID) references instructor (ID));
注意：这里外键写法是MySQL下面的，按照树上的写法foreign key(ID) references instructor ，MySQL会报错。
SQL 禁止破坏完整性约束的任何数据库更新，如：插入或者修改的元组在任意主码属性上有空值，或者在元组主码属性上和其他元组相同，报错禁止更新。
insert将数据加载到关系中 ，如：
insert into instructorvalues（10211， 'smith', 'Biology', 66000);
值得顺序应该遵循敌营属性在关系模式中列出的顺序。
delete可以从关系中删除元组。命令
delete from student；
在数据库中去掉一个关系，使用drop table，drop table命令从数据库中删除关于被去掉关系的所有信息。命令：
drop table r；
是比delete更强的语句，后者保留关系r，前者不仅删除r的所有元组，还删除r的模式。一旦r被去掉，除非create table命令重建r，否则没有其他元组可以插入到r中。
alter table命令为已有关系增加属性。关系中所有元组在新属性上取值将被设为null。命令格式如下：
alter table r add A D；
其中r是现有关系的名字，A是带添加属性的名字，D是带添加属性的域。
SQL查询的基本结构
SQL查询的基本结构由 三个 子句构成：select， from和where。
单关系查询
找出所有教师的名字，教师名字可以在instructor关系中找到，因此我们把关系放在from子句中，教师的名字出现在name属性中，因此我们把它放在select子句中。
select name from instructor
在查询中想要强行删除重复，可以select后面加入关键词distinct。
select distinct dept_name from instrutor；
SQL使用关键词all显示指明不去重复，默认也是不去重复：
select distinct dept_name from instructor;
select子句还可以含带+，-，*，/运算符的算术表达式，运算对象可以是常数或是元组的属性：
select ID, name, dept_name, salary*1.1 from instructor;
where子句允许我们只选出那些在from子句的结果关系中，满足特定谓词的元组。考虑查询所有在computer Science系，并且工资草果70000美元教师的姓名：
select name from instructor where dept_name = 'Comp.Sci' and salary > 70000
where子句中使用逻辑连词and， or， not。逻辑连词的运算对象可以包括运算符，<, <=,>,>=,=和<>的表达式。SQL允许使用比较运算符来比较字符串，算术表达式以及特殊类型，如日期类型。
多关系查询
通常查询需要从多个关系中获得信息。举例：“找出所有教师的姓名，以及它们所在系的名称和系所在建筑的名称”。
考虑instructor关系的模式，我们可以从dept_name属性得到系名，但是系所在建筑的名称实在department的building属性给出的。为了回答查询，instructor关系中的每个元组必须于department关系的元组匹配，后者dept_name上的取值相配于instructor元组在dept_name上的取值。
select name, instructor.dept_name, buildingfrom instructor, departmentwhere instructor.dept_name = department.dept_name;
注意：dept_name属性即属于instructor也属于department，关系名被用作前缀来说明我们使用的而是哪个属性。一个典型的查询具有如下形式：
s e l e c t A 1 , A 2 , . . . , A n f r o m r 1 , r 2 , . . . , r n w h e r e P ; select \quad A_1,A_2,..., A_n\\ from \quad r_1, r_2,..., r_n\\ where \quad P; selectA1,A2,...,Anfromr1,r2,...,rnwhereP;
每一A i _i i代表一个属性，每个r i _i i戴白哦一个关系，P是一个谓词，如果省略where子句，则谓词P为true。
通过笛卡尔积吧来自instructor和teaches中没有相互关联的元组组合起来。instructor中的每个元组和teaches中所有元组都要进行组合，这样通常是没有意义的。where可以限制笛卡尔积所建立的组合，只留下有意义的组合。
笛卡尔积在SQL中实现的方式既是交叉连接（cross join）,所有的连接方式都会先生成临时的笛卡儿积表，笛卡尔积是关系代数里面的一个概念，表示两个表中的每一行数据任意组合。
举例2：输出教师名和课程标识
select name, course_idfrom instructor, teacherswhere instructor.ID = teachers.ID;
举例3：如果我们只想找出Computer Science系的教师名和课程标识。
select name, course_idfrom instructor, teacherswhere instructor.ID = teachers.ID and instructor.dept_name = 'Comp.Sci';
自然连接
自然连接运算作用于两个关系，并产生一个关系作为结果。不同于两个关系上的笛卡尔积，将第一个关系上的每个元组与第二个关系所有元组都进行连接；自然连接只考虑那些在两个关系中都出现的属性上取值相同的元组对。
考虑两个关系都出现的属性，属性的值相同。
上面的举例2可以简化为
select name, course_idfrom instructor natural join teachers；
以上和举例2产生相同的结果.
在一个SQL查询的from子句中，可以用自然连接将多个关系结合在一起，如下所示：
$$
select \quad A_1,A_2,…, A_n\
from \quad r_1 \quad natual \quad join \quad r_2 \quad nature\quad join\quad…\quad nature\quad join\quad r_n\
where \quad P;
\
or
\
from \quad E_1\quad E_2\quad … \quad E_n
$$
E i _i i既可以表示的单一关系，也可以表示包含自然连接的表达式。
举例4.列出教师的名字以及他们所授课程的名称
select name, titlefrom instructor natural join teachers, coursewhere teachers.course_id = course.ourse_id
先计算instructor和teacher的自然连接，在计算笛卡尔积。但是若是两个自然连接则会报错。
select name, titlefrom instructor natural join teachers, course nature join course
这里不会出现相同结果，因为instructor natural join后，生成的关系包括（ID， name， dept_name, salary， course_id， sec_id), 而course关系包括（course_id, title，dept_name, credits)有两个属性相同的的元组，需要同时保持两个属性自相同。SQL提供一种构造形式，允许用户指定需要那些列相等。
select name, title from (instructor natural join teachers) join course using (course_id)
join … using 运算中需要给定属性名列表，其两个输入中都必须具有指定名称的属性。
附加的基本运算
更名运算
前面使用过查询
select name, course_idfrom instructor, teacherswhere instructor.ID = teachers.ID;
查询的结果是具有下列属性的关系：
name, course_id
我们不能总是使用这个方法派生名字，可能有相同属性出现；使用算术表达式，结果属性没有名字出现。SQL提供重命名结果关系属性的方法。使用as子句：
old-name as new-name
as子句既可以出现在select语句又可以又又可以出现在from语句中。
select T.name, S.course_idfrom instructor as T, teachers as Swhere T.ID = S.ID;
重命名关系的另一个原因是为了适用于需要比较同一个关系中的元组的情况。如果不重命名的话，就不可能把一个元组与其他元组区分开来。举例：“找出满足下面条件的所有教师的姓名，他们的工资至少比Biology系的某一个教师工资要高”
select name, course_idfrom instructor, teacherswhere (instructor.ID, dept_name) = (teachers.ID, 'Biology');
注意：我们不能使用instructor。salary这样的写法，因为其不清楚希望引用哪一个instructor。像T和S那样被用来重命名关系的表示符在SQL标准中被称作相关名称但通常称作表别名或者相关变量或者元组变量。
字符串运算
SQL使用一对单引号来标示字符串。还允许使用在字符串上使用多种函数，例如串联（使用”||“），提取子串，计算字符串的长度，大小写转换（upper(s)， lower（s)),去掉字符串后面的空格（使用trim（s)）等等，不同数据库系统提供的函数集是不同的。
在字符串上使用like操作符是西安模式匹配。
百分号（%）：匹配任意子串下划线（_) ：匹配任意一个字符，模式是大小写敏感的’Intro%'匹配任何以‘intro’开头的字符串'___'匹配只含三个字符的字符串'___%'匹配至少含三个字符的字符串
在like比较运算中使用escape关键词来定义转义字符。
like ‘abab%cd%’ eacape ‘’ 匹配所有以”abab%cd“开头的字符串。like ‘ab\\cd%’ escape’’ 匹配所有以”ab\cd“开头的字符串
SQL允许使用not like比较运算符搜寻不匹配项
排列元组的显示次序
SQL为用户提供一些对关系中元组显示次序的控制，order by子句就可以让查询结果中元组按排列顺序显示。默认为升序，降序为desc，升序为asc例子：
select name from instructorwhere dept_name = 'Physics'order by name
where子句谓词
SQL提供between and比较运算符来说明一个值小于或者等于某个值，同时大于或者等于某个值。
select name from instructorwhere salary between 9000 and 900000;
SQL允许我们用记号 ( v 1 , v 2 , . . . , v n ) (v_1, v_2, ..., v_n) (v1,v2,...,vn)来表示分别为 v 1 , v 2 , . . . , v n v_1,v_2,...,v_n v1,v2,...,vn的n维元组，在元组上面可以使用比较运算符，按照字典顺序进行比较
select name, course_idfrom instructor, teacherswhere (instructor.course_id, dept_name) = (teachers.course_id, 'Biology')
集合运算
SQL作用在关系上的union、intersect和except运算对应数学集合论中的∪、∩和－运算。
举例：秋季学期开课，或者在春季开课的，或者在两学期都开课的所有课程，union运算自动消除重复。union all保留所有重复
(select course_id from sectionwhere semester = 'Fall' and year = )union(select course_idfrom sectionwhere semester = 'Spring' and year = );
交运算
找出在秋季和春季同时开课的所有课程的集合，intersect all保留所有，intersect自动消除重复：
(select course_id from sectionwhere semester = 'Fall' and year = )intersect(select course_idfrom sectionwhere semester = 'Spring' and year = );
差运算
找出在秋季但是不在春季开课的所有课程的集合，except all保留所有，except自动消除重复，代码和上面一样，只是改变一下关键词。
空值
空值给关系运算带来特殊问题，包括算术运算，比较运算和集合运算。
SQL将任何涉及空值的任何比较运算都是为unknown（既不是谓词is null，也不是 is not null） 创建了true和false之外的第三逻辑值。
and： true和unknown的结果是unknown，false and unknown结果是false，unknown和unknown是unknownor：true和unknown的结果是true， false and unknown结果是unknown，unknown和unknown是unknownnot：not unknown是unknown
如果算术表达式的任意输入为空，则该算术表达式为空。
当使用使用色了select distinct子句时，重复的远祖将被去除，如果两个值非空且值相等，或者值为空；这里和谓词‘null = null’ 是不同的
聚集函数
聚集函数是以值得一个集合（集或者多重集）为输入，返回的单个值的函数。SQL提供五个固有聚集函数：
平均值：avg；最小值：min；最大值：max；总和：sum；计数： count；
sum和avg输入的必须是数字集，单其他运算符还可以作用在非数字数据类型的集合上；
基本聚集
”找出Computer Science系的教师的平均工资"
select avg(salary)from instructorwhere dept_name = 'Comp.Sci';
可以用as赋予该属性一个名称；
select avg(salary) as avg_salaryfrom instructorwhere dept_name = 'Comp.Sci';
在某些情况，想删除重复元组，可以在聚集表达式中使用关键词distinct
select count(distinct(ID))from teacherswhere semester = 'Spring' and year =
但是在count（*）下，不可以使用distinct，但是在用max和min时，使用distinct是合法的。
分组聚集
希望其作用在一组元组上面；在SQl可以使用group by子句实现这个愿望，group by子句给出一个或者多个属性用来构造分组。在group by子句中所有属性上取值相同的元组渐被分在同一个组中。
举例：找出每个系的平均工资：
select count(distinct(ID))from teacherswhere semester = 'Spring' and year = ;
举例：找出么个系在春季教授一门课程教师的人数。
select dept_name, count(distinctID) as instr_countfrom instructor natural join teacherswhere semeseter = 'Spring' and year = group by dept_name;
当SQL查询使用分组时，保证出现在select 与剧中的但没有出现在被聚集的属性只能出现在group by自居的那些属性，换句话说，任何没有出现在group by的属性，如果出现在select子句的话，只能出现在聚集函数内部，否则报错
having子句
对分组限定条件比元组限定条件更有用。having子句的谓词在形成后才起作用，因此可以使用聚集函数。
于select子句的情况类似，任何出现在having子句中，但没有被聚集的属性必须出现在group by子句中，否则查询就被当成是错误的。
与不带聚集的查询情况类似，最先根绝from子句来计算一个关系。如果出现了where子句上， where子句中的谓词将应用到from子句的结果关系上。如果出现了group by子句，满足where谓词的元组通过group by子句形成的分组。如果没有group by子句，满足where谓词的整个元组集被当作一个分组。如果出现了having子句，他将应用到每个分组上；不满足having子句谓词的分组将被抛弃。select子句利用身下的分组产生出查询结果中的元组，即在每个分组上应用聚集函数来得到单个结果元组。
对控制和布尔值的聚集
聚集函数根据以下原则处理空值：除了count(*)外所有的聚集函数都忽略输入集合中的空值。由于空值被忽略，有可能造成参加函数运算的输入值集合为空集。规定空集的count运算值的为0，其他的所有的聚集运算在输入为空集的情况下返回一个空值。
一、GROUP BY
GROUP BY语句用来与聚合函数(aggregate functions such as COUNT, SUM, AVG, MIN, or MAX.)联合使用来得到一个或多个列的结果集。
语法如下：
SELECT column1, column2, ... column_n, aggregate_function (expression) FROM tables WHERE predicates GROUP BY column1, column2, ... column_n;
举例
比如说我们有一个学生表格(student)，包含学号(id)，课程(course)，分数(score)等等多个列，我们想通过查询得到每个学生选了几门课程，此时我们就可以联合使用COUNT函数与GROUP BY语句来得到这一结果
SELECT id, COUNT(course) as numcourseFROM studentGROUP BY id
因为我们是使用学号来进行分组的，这样COUNT函数就是在以学号分组的前提下来实现的，通过COUNT(course)就可以计算每一个学号对应的课程数。
注意
因为聚合函数通过作用于一组数据而只返回一个单个值，因此，在SELECT语句中出现的元素要么为一个聚合函数的输入值，要么为GROUP BY语句的参数，否则会出错。
例如，对于上面提到的表格，我们做一个这样的查询：
select id, count(course) as numcourse, scorefrom studentgroup by id
此时查询便会出错，错误提示如下：
Column ‘student.score’ is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause.
出现以上错误的原因是因为一个学生id对应多个分数，如果我们简单的在SELECT语句中写上score，则无法判断应该输出哪一个分数。如果想用score作为select语句的参数可以将它用作一个聚合函数的输入值，如下例，我们可以得到每个学生所选的课程门数以及每个学生的平均分数：
select id, count(course) as numcourse, avg(score) as avgscorefrom studentgroup by id
二、HAVING
HAVING语句通常与GROUP BY语句联合使用，用来过滤由GROUP BY语句返回的记录集。
HAVING语句的存在弥补了WHERE关键字不能与聚合函数联合使用的不足。
语法：
SELECT column1, column2, ... column_n, aggregate_function (expression)FROM tablesWHERE predicatesGROUP BY column1, column2, ... column_nHAVING condition1 ... condition_n;
同样使用本文中的学生表格，如果想查询平均分高于80分的学生记录可以这样写：
SELECT id, COUNT(course) as numcourse, AVG(score) as avgscoreFROM studentGROUP BY idHAVING AVG(score)>=80;
在这里，如果用WHERE代替HAVING就会出错。
嵌套子查询
SQL提供潜逃子查询。子查询使嵌套在宁一个查询的 select-from-where表达式。紫钗性能嵌套在where子句中，通常用于对集合的成岩资格，集合的比较以及集合的基数进行检查。
集合成员资格
SQL允许测试元组在关系中成员资格。连接词 in测试元组是否使集合中的成员，集合是由select子句产生的一组值构成的，连接词not in则测试元组是否不是集合中的成员。
举例：查找在春季和秋季开课的课程。
select distinct course_idfrom sectionwhere semester = 'Fall' and year = andcourse_id in (select course_id from sectionwhere semester = 'Spring' and year = );
举例：为了找出所有在 年秋季学期开学，到那时没有在春季开学的学生
select distinct course_idfrom sectionwhere semester = 'Fall' and year = andcourse_id not in (select course_id from sectionwhere semester = 'Spring' and year = );
in和not in操作符也能用于枚举集合。下面查询找出既不叫‘Mozart’，也不叫‘Einstein’的教师的姓名：
select distinct namefrom instructorwhere name not in ('Mozart', 'Einstern');
在前面是单属性关系测试成员资格，在SQL任意关系测试成员资格也是可以的。例如：找出（不同的）学生总数，它们选秀了ID为10101教师所教授的课程
select count(distinct(ID))from takeswhere (course_id, sec_id, semester,year) in (select course_id, sec_id, semester, year from teacherswhere teachers.ID = 1101);
集合比较
嵌套子查询可以对集合进行比较。例如：找出满足下面条件的所有教师的姓名，他们的工资至少比biology系的某一个教师工资高
select distinct T.namefrom instructor as T, instructor as Swhere T.salary > S.salary and S.dept_name = 'Biology';#or select namefrom instructorwhere salary > some(selectfrom instructorwhere dept_name = "Biology");
dll 对应的是每个；查找比每个biology系的老师都高：
select namefrom instructorwhere salary > all(selectfrom instructorwhere dept_name = "Biology");
找出平均工资最高的系
select dept_namefrom instructorgroup by dept_namehaving avg(salary) >= all(select avg(salary)from instructorgroup by dept_name);
空关系测试
SQL可测试一个子查询结果是否存在元祖。exist结构在作为参数的子查询非空时，返回true值。找到在秋季和春季同时开课的所有课程：
select course_idfrom section as Swhere semester = 'Fall' and year = andexists (select *from section as Twhere semester = 'Spring' and year = andS.course_id = T.course_id)
上述说明SQL的一个新特性，来自外层查询的一个相关名称（上述查询的中的S）可以用在where子句的子查询。使用外层查询相关名称的子查询被称作相关子查询。相关名称可以运用作用域规则。还可以运用not exist。尽管运算符
重复元组存在性测试
SQL提供一个布尔函数，用于测试在一个子查询的结构中是否存在重复元组。如果作为子查询结果中没有重复元组，unique结果将返回一个true。找出所有在最多开设一次课程，如下所示：
select T.course_idfrom course as Twhere 1 >= (select R.course_idfrom section as Rwhere T.course_id = R.course_id andR.year = );#下面MySQL不支持unique这种用法select T.course_idfrom course as Twhere unique (select R.course_idfrom section as Rwhere T.course_id = R.course_id andR.year = );
from子句中的子查询
SQL允许from子句在使用子查询表达式。任何select-from-where表达式返回的结果都是关系，因而可以被插入另一个select-from-where中任何关系出现的位置。
例如找出系平均工资超过42000美元的那些系中教师的平均工资。
select dept_name, avg_salaryfrom (select dept_name, avg(salary)from instructorgroup by dept_name)as dept_avg(dept_name, avg_salary)where avg_salary > 42000;
找出戏中工资总额的最大的系：
select max(tol_salary)from(select dept_name, sum(salary)from instructorgroup by dept_name)as dept_totol(dept_name, tol_salary);
在from自居的嵌套查询不能使用来自from子句其他关系的相关变量。然而SQL：允许from子句中的子查询用关键词lateral作为前缀，以便访问from 子句在他前面的二标或者子查询中的属性。
select name, salary, avg_salaryfrom instructor I1, lateral(select avg(salary) as avg_salaryfrom instructor I2where I2.dept_name = I1.dept_name) as table1
注意：这里需要对查询派生出来的的表取一个别名否则会报错。 进行嵌套查询的时候子查询出来的的结果是作为一个派生表来进行上一级的查询的，所以子查询的结果必须要有一个别名 。
with子句
with提供临时定义关系的方法。这个定义只对包含with子句查询有效。
with max_budget(value) as (select max(budget) from department)select budgetfrom department, max_budgetwhere department.dept_name = max_budget.value
举例：加入我们要查出所有工资大于所有系平均工资总额的系：
with dept_total(dept_name, value) as(select dept_name, sum(salary)from instructorgroup by dept_name),dept_total_avg(value) as(select avg(value)from dept_total)select dept_namefrom dept_total, dept_total_avgwhere dept_total.value >= dept_total_avg.value
标量子查询
SQL允许使用子查询出现在返回单个值的表达式能够出现的任何地方，只要该子查询只返回i包含单个属性的单个元组， 这样的子查询称为标量子查询。
select dept_name,(select count(*)from instructorwhere department.dept_name = instructor.dept_name)as num_instructorfrom department
数据库的修改
SQL来增加、删除和修改信息
删除
删除请求与查询非常类似。我们只能删除整个元组，而不能删除整个元组，而不能删除某些属性上的值。
delete from rwhere P;
其中P代表一个谓词，r代表表一个关系。delete语句首先从r中找出所有使 P ( t ) P(t) P(t)为真的元组t，然后把他从r中删除。
delete只能作用于一个关系。删除一个关系的所有元组，关系本身仍然存在，但是已经变空了。
delete from instructorwhere dept_name = "Finance";#ordelete from instructorwhere salary between 13000 and 15000;#ordelete from instructorwhere dept_name in(select dept_namefrom deparmentwhere building = 'Waston');
插入
要往关系中插入数据，我们可以镇定插入的元组，或者写成一条查询语句来生成待插入元组集合。元组属性的排列顺序和管旭模式属性排列顺序是一致的，也可以指定属性。
insert into coursevalues('CS-437', 'Database Systems', 'Comp.Sci', 4);insert into course(course_id, title, dept_name, credits)values('AM-324', 'Admanced mathematics', 'Math', 4);insert into course(course_id, title, credits, dept_name)values('AM-324', 'Admanced mathematics', 4, 'Math');
在这里要先插入其的外键，不然会产生错误。违反约束。
大部分关系数据库有特殊的“bulk loader”工具，他可以像关系中插入一个非常大的元组集合。这些红菊允许从格式化文本读出。
更新
在不改变整个元组的情况下改变其部分属性值。可以使用update语句。可以从select语句中找到。
update instructorset salary = salary * 1.05;
update的whereizju可以包含select语句中的where子句中的任何合法结构。
update instructorset salary = salary * 1.03where salary > 10000;update instructorset salary = salary * 1.05where salary < 10000;
这里更新的次序很重要，次序不一样，可能更新完到10000，然后又涨0.05；
这里可以使用case结构：
update instructorset salary = casewhen salary <= 10000 then salary * 1.05else salary * 1.03end;
标量子查询也可以用在SQL更新语句。
每个student元组的tol_cred属性值设为该生成功修完学分的中和，假设该生偶们科的成绩既不是F，也不是null，表示该生修完该门课程。
update student Sset tol_cred = (select sum(credits)from takes natural join coursewhere S.ID = takes.ID andtakes.grade <> 'F' andtakes.grade is not null)
