数据库SQL查询练习

--重点推荐使用natural join,inner join!!!,尽量避免使用广义的笛卡尔积
--重点推荐使用natural join,inner join!!!,尽量避免使用广义的笛卡尔积
--重点推荐使用natural join,inner join!!!,尽量避免使用广义的笛卡尔积

--设有一个SPJ数据库，
--包括S,P,J,SPJ四个关系模式：

--供应商表S(英文全称为:supplier)
--S(SNO,SNAME,STATUS,CITY)
--供应商代码Sno,供应商名称Sname,供应商状态Status,供应商所在城市City

--零件表P(英文名称为:Part)
--P(PNO,PNAME,COLOR,WEIGHT)
--Pno零件代码,Pname零件名称,Color零件的颜色,Weight零件的重量

--工程项目表J(英文全称为Project,因为之前已经使用了P作为零件的简称,所以这里选择了J作为项目工程表的名字)
--J(JNO,JNAME,CITY)
--工程项目代码Jno,工程项目名称Jname,工程项目所在城市City

--供应情况表SPJ(英文全称supplier-part-project)
--SPJ(SNO,PNO,JNO,QTY)
--供应商代码Sno,零件代码Pno,工程项目代码Jno,供应数量Qty

  /* --供应商表S由供应商代码(SNO)、供应商姓名(SNAME)、供应商状态(STATUS)、供应商所在城市(CITY)组成； --S(SNO,SNAME,STATUS,CITY) S表 SNO SNAME STATUS CITY S1 精益 20 天津 S2 盛锡 10 北京 S3 东方红 30 北京 S4 丰泰盛 20 天津 S5 为民 30 上海 --零件表P由零件代码(PNO)、零件名(PNAME)、颜色(COLOR)、重量(WEIGHT)组成； --P(PNO,PNAME,COLOR,WEIGHT) P表 PNO PNAME COLOR WEIGHT P1 螺母 红 12 P2 螺栓 绿 17 P3 螺丝刀 蓝 14 P4 螺丝刀 红 14 P5 凸轮 蓝 40 P6 齿轮 红 30 --工程项目表J由工程项目代码(JNO)、工程项目名(JNAME)、工程项目所在城市(CITY)组成； --J(JNO,JNAME,CITY) J表 JNO JNAME CITY J1 三建 北京 J2 一汽 长春 J3 弹簧厂 天津 J4 造船厂 天津 J5 机车厂 唐山 J6 无线电厂 常州 J7 半导体厂 南京 --供应情况表SPJ由供应商代码(SNO)、零件代码(PNO)、工程项目代码(JNO)、供应数量(QTY)组成， --表示某供应商 供应某种零件 给某工程项目的数量为QTY。 --SPJ(SNO,PNO,JNO,QTY) SPJ表 SNO PNO JNO QTY S1 P1 J1 200 S1 P1 J3 100 S1 P1 J4 700 S1 P2 J2 100 S2 P3 J1 400 S2 P3 J2 200 S2 P3 J4 500 S2 P3 J5 400 S2 P5 J1 400 S2 P5 J2 100 S3 P1 J1 200 S3 P3 J1 200 S4 P5 J1 100 S4 P6 J3 300 S4 P6 J4 200 S5 P2 J4 100 S5 P3 J1 200 S5 P6 J2 200 S5 P6 J4 500 */
请根据以上内容完成下面题目，写出相应的SQL语句.
2、创建表
--创建供应商表S
--供应商代码Sno,供应商名称Sname,供应商状态Status,供应商所在城市City
create table S ( Sno char(2) primary key, --假设供应商代码的长度为定长2 Sname varchar2(9) ,--假设供应商的名称最多为三个汉字 Status varchar2(3) not null,--假设供应商供应状态为最多有三个数字 City varchar2(15) not null --假设城市最长为5个字符的汉字 );            

drop table S;
--查询S表的所有信息
select * from S;
--查询表的结构


--创建零件P表
--Pno零件代码,Pname零件名称,Color零件的颜色,Weight零件的重量
create table P ( Pno char(2), --假设Pno为2位定长的字符 Pname varchar2(9) not null, --假设Pname最多有三个汉字 Color char(3) check (Color in('红','绿','蓝')), --颜色只能是一个汉字,并且这个字只能为红绿蓝三种中的一种 Weight smallint not null,--重量是个整数,并且不能为空 constraint PK_P primary key (Pno) );


--删除P表定义及其数据
drop table P;
--查询P表的所有信息
select * from P;

--创建工程项目表J表
--工程项目表J由工程项目代码(JNO)、工程项目名(JNAME)、工程项目所在城市(CITY)组成；
create table J ( Jno char(2) , --假设工程项目代码是由定长的两位字符组成 Jname varchar2(12), --假设工程名称最多为长度为4的汉字组成 City varchar2(15), --假设工程项目所在的城市的名称最多含有5个汉字 constraint PK_J primary key (Jno) );


--删除J表定义及其数据
drop table J;
--查询J表的所有信息
select * from J;

--创建供应情况表SPJ表
--供应情况表SPJ由供应商代码(SNO)、零件代码(PNO)、工程项目代码(JNO)、供应数量(QTY)组成
create table SPJ ( Sno char(2), Pno char(2), Jno char(2), Qty int constraint C1 check(Qty between 0 and 1000), constraint SPJKey primary key(Sno,Pno,Jno), constraint FK_Sno foreign key(Sno) references S(Sno) on delete cascade, constraint FK_Pno foreign key(Pno) references P(Pno) on delete cascade, constraint FK_Jno foreign key(Jno) references J(Jno) on delete cascade );

--删除SPJ表定义及其数据
drop table SPJ;
--查询SPJ表的所有信息
select * from SPJ;

--使用该语句可以查询当前数据库的字符编码:我这里是
--SIMPLIFIED CHINESE_CHINA.ZHS16GBK
--如果是UTF-8:则一个汉字占三个字符的大小
--如果是GBK:则一个汉字占两个字符的大小
--为了避免出错:这里我统一按照一个汉字占三个字符的标准(UTF-8)
select userenv('language') from dual;

3、插入数据
--向供应商表中插入数据
--向S表中插入数据
  --S表
          -- SNO SNAME STATUS CITY
          -- S1 精益 20 天津
          -- S2 盛锡 10 北京
          -- S3 东方红 30 北京
          -- S4 丰泰盛 20 天津
          -- S5 为民 30 上海
insert into S(Sno,Sname,Status,City) values('S1','精益','20','天津');

insert into S(Sno,Sname,Status,City) values('S2','盛锡','10','北京');

insert into S(Sno,Sname,Status,City) values('S3','东方红','30','北京');

insert into S(Sno,Sname,Status,City) values('S4','丰泰盛','20','天津');

insert into S(Sno,Sname,Status,City) values('S5','为民','30','上海');

select * from S;

--向P表中插入有效数据
--P(PNO,PNAME,COLOR,WEIGHT)
            --P表
            --PNO PNAME COLOR WEIGHT
            --P1 螺母 红 12
            --P2 螺栓 绿 17
            --P3 螺丝刀 蓝 14
            --P4 螺丝刀 红 14
            --P5 凸轮 蓝 40
            --P6 齿轮 红 30
insert into P(Pno,Pname,Color,Weight) values('P1','螺母','红',12);

insert into P(Pno,Pname,Color,Weight) values('P2','螺栓','绿',17);

insert into P(Pno,Pname,Color,Weight) values('P3','螺丝刀','蓝',14);

insert into P(Pno,Pname,Color,Weight) values('P4','螺丝刀','红',14);

insert into P(Pno,Pname,Color,Weight) values('P5','凸轮','蓝',40);

insert into P(Pno,Pname,Color,Weight) values('P6','齿轮','红',30);

--查询P表中的所有数据
select * from P;


--向J表中插入有效数据
--J(JNO,JNAME,CITY)
           -- J表
            --JNO JNAME CITY
            --J1 三建 北京
            --J2 一汽 长春
            --J3 弹簧厂 天津
            --J4 造船厂 天津
            --J5 机车厂 唐山
            --J6 无线电厂 常州
            --J7 半导体厂 南京
insert into J(Jno,Jname,City) values('J1','三建','北京');

insert into J(Jno,Jname,City) values('J2','一汽','长春');

insert into J(Jno,Jname,City) values('J3','弹簧厂','天津');

insert into J(Jno,Jname,City) values('J4','造船厂','天津');

insert into J(Jno,Jname,City) values('J5','机车厂','唐山');

insert into J(Jno,Jname,City) values('J6','无线电厂','常州');

insert into J(Jno,Jname,City) values('J7','半导体厂','南京');
--查询J表中的所有数据
select * from J;

--向SPJ表中插入有效数据
--SPJ(SNO,PNO,JNO,QTY)
            /* SPJ表 SNO PNO JNO QTY S1 P1 J1 200 S1 P1 J3 100 S1 P1 J4 700 S1 P2 J2 100 S2 P3 J1 400 S2 P3 J2 200 S2 P3 J4 500 S2 P3 J5 400 S2 P5 J1 400 S2 P5 J2 100 S3 P1 J1 200 S3 P3 J1 200 S4 P5 J1 100 S4 P6 J3 300 S4 P6 J4 200 S5 P2 J4 100 S5 P3 J1 200 S5 P6 J2 200 S5 P6 J4 500 */
insert into SPJ(Sno,Pno,Jno,Qty) values('S1','P1','J1',200);

insert into SPJ(Sno,Pno,Jno,Qty) values('S1','P1','J3',100);

insert into SPJ(Sno,Pno,Jno,Qty) values('S1','P1','J4',700);

insert into SPJ(Sno,Pno,Jno,Qty) values('S1','P2','J2',100);

insert into SPJ(Sno,Pno,Jno,Qty) values('S2','P3','J1',400);

insert into SPJ(Sno,Pno,Jno,Qty) values('S2','P3','J2',200);

insert into SPJ(Sno,Pno,Jno,Qty) values('S2','P3','J4',500);

insert into SPJ(Sno,Pno,Jno,Qty) values('S2','P3','J5',400);

insert into SPJ(Sno,Pno,Jno,Qty) values('S2','P5','J1',400);

insert into SPJ(Sno,Pno,Jno,Qty) values('S2','P5','J2',100);

insert into SPJ(Sno,Pno,Jno,Qty) values('S3','P1','J1',200);

insert into SPJ(Sno,Pno,Jno,Qty) values('S3','P3','J1',200);

insert into SPJ(Sno,Pno,Jno,Qty) values('S4','P5','J1',100);

insert into SPJ(Sno,Pno,Jno,Qty) values('S4','P6','J3',300);

insert into SPJ(Sno,Pno,Jno,Qty) values('S4','P6','J4',200);

insert into SPJ(Sno,Pno,Jno,Qty) values('S5','P2','J4',100);

insert into SPJ(Sno,Pno,Jno,Qty) values('S5','P3','J1',200);

insert into SPJ(Sno,Pno,Jno,Qty) values('S5','P6','J2',200);

insert into SPJ(Sno,Pno,Jno,Qty) values('S5','P6','J4',500);

--查询SPJ表中的所有数据
select * from SPJ;


--查询S表中的所有数据
select * from S;
--查询P表中的所有数据
select * from P;
--查询J表中的所有数据
select * from J;
--查询SPJ表中的所有数据
select * from SPJ;
4、请用SQL语句完成下面题目的查询。
(1)求供应工程J1零件的供应商号码SNO：
select Sno from SPJ where Jno='J1';

--可以使用distinct关键字去掉重复的元组
select distinct Sno from SPJ where Jno='J1';
(2)求供应工程J1零件P1的供应商号码SNO：
select Sno from SPJ where Jno='J1' and Pno='P1';
(3)求供应工程J1零件为红色的供应商号码SNO：
--这时候我们发现这里涉及到供应商代码Sno,供应工程Jno,这两个字段处于SPJ表中
--而零件的颜色在P表中出现,在其他的表中都没有出现,这时候就需要使用多表的连接查询



--使用子查询来实现对该条件的查询
--关键分析过程:显然这种做法最后得到的结果是不正确的.
--1.首先在SPJ表中确定供应工程J1零件的零件代码Pno得到一个结果集
select distinct Pno from SPJ where Jno='J1';
--2.然后在P表中筛选出零件的颜色为红色的零件的零件号(从上面得到的结果集中进行筛选)
select Pno from P where Color='红' and Pno in (select distinct Pno from SPJ where Jno='J1');
--3.因为最后需要得到的字段是Sno,我们有了Pno需要得到Sno,
--这时候我们可以在SPJ表中根据Pno的值查找出对应的Sno字段
select distinct Sno from SPJ where Pno in (select Pno from P where Color='红' and Pno in (select distinct Pno from SPJ where Jno='J1' ) ) --显然这种方式得到的结果也是正确的: --因为目标列是要得到SPJ.Sno --那么久说明了有时候的多表查询是不能够使用子查询进行替换的, --表面上看上去是相同的,但是可能不是等价的替换 --方式一:使用等值连接实现该查询要求 --这种使用广义的笛卡尔积的方式我们是需要极力避免的方式. --分析关键过程: --1.涉及到的数据表供应商供应情况表SPJ和零件表P --2.将供应商供应情况表SPJ和零件表P表进行内连接 --3.确定连接时的关联字段SPJ表和P表的关联字段为Pno select distinct SPJ.Sno from SPJ,P where SPJ.Jno='J1' and SPJ.Pno=P.Pno and Color='红';

--方式二:使用inner join关键字来实现该查询要求:
select Sno from P inner join SPJ on SPJ.Pno=P.Pno and Jno='J1' and Color='红';

--根据目标列进行投影的时候发现出现了重复的元组,这时候可以使用distinct关键去掉重复的元组
select distinct Sno from P inner join SPJ on SPJ.Pno=P.Pno and Jno='J1' and Color='红';

--方式三:使用自然连接来实现该查询要求:
select Sno from P natural join SPJ where Jno='J1' and Color='红';

--使用distinct关键字去掉重复的元组
select distinct Sno from P natural join SPJ where Jno='J1' and Color='红';

--方式四:使用子查询和in关键字来实现该查询条件
--1.首先在P表中确定零件的颜色(颜色字段只是在P表中出现)为红色的零件的零件号Pno
select Pno from P where Color='红';
--2.然后需要在SPJ表中查询供应工程代码为J1的并且该它的零件的颜色为红色的那些元组的Sno值
select Sno from SPJ where Jno='J1' and Pno in (select Pno from P where Color='红' );

--方法五:使用子查询和exist关键字来实现该查询条件
select distinct Sno from SPJ where Jno = 'J1' and exists ( select Pno from P where color = '红' and P.Pno = SPJ.Pno );

(4)求没有使用天津供应商生产的红色零件的工程号JNO：
--分析过程:
--如果我们将工程代码的所有取值看成全集的话
--那么使用了天津供应商生产的零件的工程代码的取值构成集合A,
--使用的红色零件的工程代码的取值构成集合Ｂ,
--那么使用了天津供应商生产的红色零件的工程代码的取值为集合C
--那么我们可以得到:C=A∩B
--那么没有使用天津供应商生产的红色零件的工程代码的取值应该为:
--U-(A∩B)

--方式一:
--首先我们查询出使用天津供应商生产的红色零件的工程号JNO
--这种方式其实只是在显示上消除了笛卡尔积的问题,
--但是笛卡尔积的情况依然是存在的,因为数据库的查询机制
--是逐行进行查询的,实际上的笛卡尔积依然是存在的.

select distinct Jno from S,P,SPJ where S.Sno=SPJ.Sno and P.Pno=SPJ.Pno and City='天津' and Color='红';

--然后查询出没有使用天津供应商生产的红色零件的工程号JNO
select Jno from J where Jno not in (select Jno from S,P,SPJ where S.Sno=SPJ.Sno and P.Pno=SPJ.Pno and City='天津' and Color='红' );

--在内层查询的时候我们可以去掉重复的元组来提升外层查询的速度
--然后查询出没有使用天津供应商生产的红色零件的工程号JNO
select Jno from J where Jno not in (select distinct Jno from S,P,SPJ where S.Sno=SPJ.Sno and P.Pno=SPJ.Pno and City='天津' and Color='红' );

--我开始采用的是这种方式:
--其实我实际上是想将S表,P表,SPJ表使用S.Sno=SPJ.Sno
--和P.Pno=SPJ.Sno等条件将S表,P表,SPJ表进行内连接,
--但是使用下面这种方式是不能够达到这种想法的:
--下面这种写法:将S表和SPJ表进行内连接,将P表和SPJ表进行内连接,
--然后将S表和SPJ表进行内连接得到的表与将P表和SPJ表进行内连接得到的表
--进行笛卡尔积.这样显然和上面我的想法是不同的.这样得到的记录数是19*19=361;
select * from S inner join SPJ on S.Sno=SPJ.Sno, SPJ inner join P on P.Pno=SPJ.Pno --并且这个时候我按照这个查询语句进行查询的时候会提示 --:ORA-00918: 未明确定义列 --这里的原因是: --1.将S表和SPJ表进行内连接,-->得到19行记录,这里面包含一个SPJ.Jno --2.将P表和SPJ表进行内连接,-->得到19行记录,这里面包含一个SPJ.Jno --3.将上面的两个内连接的做广义的笛卡尔积,得到19*19=361行记录 --在这种情况下使用select Jno显然是不行的,最后得到的表中有两个Jno --并且这两个Jno的所属都是SPJ表,这时显然是不能确定需要查询出那个字段 --我开始没理解的时候还是用了select SPJ.Jno,发现这样也是不行的 --原因是最后得到的表中的Jno的所属都是SPJ,这时候显然是不能够确定 --需要将那个字段查询出来的. --虽然这种方式是不可行的,但是我觉得还是应该将理由想清楚. select Jno from J where Jno not in (select * from S inner join SPJ on S.Sno=SPJ.Sno, SPJ inner join P on P.Pno=SPJ.Pno where S.City='天津' and P.Color='红' );

--错误方式二:
--ORA-00905: 缺失关键字
--我开始是这么写过,始终想不明白一直报错:缺失关键字
--后来才发现不能这么写:这说明inner join ...on..(join和on是成对出现的)
select Jno from J where Jno not in (select distinct Jno from S inner join SPJ inner join P on SPJ.Pno=P.Pno and S.Sno=SPJ.Sno where City='天津' and Color='红' );

--方式二:使用内连接inner join来实现该查询要求:
--首先我们查询出使用天津供应商生产的红色零件的工程号JNO
select distinct Jno from S inner join SPJ on S.Sno=SPJ.Sno inner join P on SPJ.Pno=P.Pno where City='天津' and Color='红';

--然后查询出没有使用天津供应商生产的红色零件的工程号JNO
select Jno from J where Jno not in (select distinct Jno from S inner join SPJ on S.Sno=SPJ.Sno inner join P on SPJ.Pno=P.Pno where City='天津' and Color='红' );
--方式三:使用自然连接natural join 来实现该查询要求
--使用自然连接可以消除重属性名的属性列.推荐使用这种方式
--首先我们查询出使用天津供应商生产的红色零件的工程号JNO
select distinct Jno from S natural join P natural join SPJ where City='天津' and Color='红';

--然后查询出没有使用天津供应商生产的红色零件的工程号JNO
select Jno from J where Jno not in (select Jno from S natural join P natural join SPJ where City='天津' and Color='红');
--使用内连接方式就是按照关联字段来进行连接,连接完成之后会去掉重属性名的列
--如果将两个没有相同属性名的数据表进行natural join 也会成功.
--只是此时是将这两个表做笛卡尔积
select * from S natural join P;

select * from S natural join J;

--方式四:使用子查询和exists配合使用实现该查询要求:
select distinct Jno from J where not exists ( select Jno from SPJ natural join P natural join P where City = '天津' and Color = '红' and SPJ.Jno=J.Jno); 

--方式五:使用子查询和exist配合使用实现该查询要求:
select distinct Jno from J where Jno not in ( select Jno from SPJ where Sno in (select Sno from S where City = '天津' ) and Pno in (select Pno from P where Color = '红' ) );

(5)求至少用了供应商S1所供应的全部零件的工程号JNO：
--此题比较难以理解:
--方式一:使用子查询和exists关键字
select distinct jno from spj spjx where not exists (select pno from spj where sno = 'S1' and pno not in ( select pno from spj where jno = spjx.jno ) );
--方式二:使用子查询和exists关键字
select distinct jno from spj spjx where not exists (select * from spj spjy where sno = 'S1' and not exists (select * from spj where jno = spjx.jno and pno = spjy.pno ) );

5、请用SQL语句完成下面题目的查询。
--重点推荐使用natural join,inner join!!!,尽量避免使用广义的笛卡尔积
--重点推荐使用natural join,inner join!!!,尽量避免使用广义的笛卡尔积
--重点推荐使用natural join,inner join!!!,尽量避免使用广义的笛卡尔积
--只涉及到单张表的简单查询:
(1)找出所有供应商的姓名和所在城市。
select Sname,City from S;
(2)找出所有零件的名称、颜色、重量。
select Pname,Color,Weight from P;
(3)找出使用供应商S1所供应零件的工程号码。
select Jno from SPJ where Sno='S1';
--涉及到多张表的连接查询或者子查询
(4)找出工程项目J2使用的各种零件的名称及其数量。
--方式一:使用消除笛卡尔积的方式
select Pname,Qty from P,SPJ where P.Pno=SPJ.Pno and Jno='J2';
--方式二:使用内连接的方式实现该查询要求:
select Pname,Qty from P inner join SPJ on P.Pno=SPJ.Pno where Jno='J2';

--上面的那种方式也可以省略inner
select Pname,Qty from P join SPJ on P.Pno=SPJ.Pno where Jno='J2';
--方式三:使用自然连接的方式实现该查询要求:
--在使用自然连接的时候我们不需要指定连接条件
--它会按照表的相同字段来进行连接,并去掉重复的属性列
select Pname,Qty from P natural join SPJ where Jno='J2';
(5)找出上海厂商供应的所有零件号码。
--方式一:消除的笛卡尔积:效率较低
select distinct Pno from S,SPJ where S.Sno=SPJ.Sno and S.City='上海';

--方式二:使用内连接inner join来实现
select distinct Pno from S inner join SPJ on S.Sno=SPJ.Sno where S.City='上海';

--方式三:使用自然连接实现该查询要求:推荐使用这种方式
select distinct Pno from S natural join SPJ where S.City='上海';

--方式四:使用子查询和in关键字来实现该查询
--首先查询出上海供应商的供应商代码
select Sno from S where S.City='上海';
--然后查询出使用上海供应商的零件号
select Pno from SPJ where Sno in (select Sno from S where S.City='上海' );

--方式五:使用子查询和exist关键字来实现该查询
select distinct Pno from SPJ where exists (select Sno from S where City = '上海'and S.Sno = SPJ.Sno );
(6)找出使用上海产的零件的工程名称。
--方式一:使用消除笛卡尔积的方式实现子查询
select distinct Jname from S,J,SPJ where S.Sno=SPJ.Sno and J.Jno=SPJ.Jno and S.City='上海';

--方式二:使用内连接的方式来实现该查询
select distinct Jname from S inner join SPJ on S.Sno=SPJ.Sno inner join J on SPJ.Jno=J.Jno where S.City='上海';

--使用内连接的时候join关键字可以省略
select distinct Jname from S join SPJ on S.Sno=SPJ.Sno join J on SPJ.Jno=J.Jno where S.City='上海';

--方式三:使用自然连接的方式实现该查询
--这里不能够使用自然连接?NATURAL JOIN 
--注意 j 和 s 表都有属性 city
--select Jname
--from S natural join SPJ on S.Sno=SPJ.Sno natural join J on SPJ.Jno=J.Jno
--where S.City='上海';

--select *
--from S natural join J;

--select S.*,J.*
--from S natural join SPJ natural join J 
--where S.City='上海';

--方式三:使用子查询来实现该子查询
--首先在S表中确定供应商城市为上海的供应商代码
select distinct Sno from S where S.City='上海';

--然后根据已知的Sno在SPJ表确定生产的工程代码Jno
select distinct Jno from SPJ where Sno in (select Sno from S where S.City='上海');

--最后根据已知的Jno在J表中确定工程名称Jname
select Jname from J where Jno in (select distinct Jno from SPJ where Sno in (select Sno from S where S.City='上海' ) );    

--方式四:使用子查询和exists关键字来实现该子查询
select distinct jname from j where exists (select * from spj natural join s where city = '上海' and jno = j.jno );    
(7)找出没有使用天津产的零件的工程号码。
--我们可以先找出使用了天津产的零件的工程号码,
--方式一:使用消除笛卡尔积的方式
select distinct Jno from S,SPJ where S.Sno=SPJ.Sno and City='天津';
--然后使用整个的工程代码集合减去上面的工程号码
select Jno from J where Jno not in (select Jno from S,SPJ where S.Sno=SPJ.Sno and City='天津' );

--方式二:使用内连接的方式实现该查询
--我们可以先找出使用了天津产的零件的工程号码,
select distinct Jno from S inner join SPJ on S.Sno=SPJ.Sno where City='天津';

--然后使用整个工程代码集合减去上面的工程代码
select Jno from J where Jno not in (select distinct Jno from S inner join SPJ on S.Sno=SPJ.Sno where City='天津' );

--方式三:使用自然连接来实现该查询要求
--我们可以先找出使用了天津产的零件的工程代码,
select Jno from S natural join SPJ where City='天津';
--然后使用整个工程代码集合减去上面的工程代码集合
select Jno from J where Jno not in (select Jno from S natural join SPJ where City='天津' );

--方式四:使用子查询和in关键字来实现该子查询
--我们首先可以使用供应商城市为天津在S表中得到供应商代码Sno
select distinct Sno from S where City='天津';
--然后根据已知的Sno在SPJ表中查询工程代码Jno
select distinct Jno from SPJ where Sno in (select distinct Sno from S where City='天津' );

--最后使用整个的工程代码的集合减去满足条件的工程代码集合
select Jno from J where Jno not in (select distinct Jno from SPJ where Sno in (select distinct Sno from S where City='天津' ) );

--方式五:使用子查询和exists关键字来实现查询
--这里用的是SPJ表中Jno减去的,不考虑没有使用零件的工程
select distinct Jno from SPJ SPJX where not exists ( select Jno from SPJ natural join s where City = '天津' and Jno = SPJX.Jno );

(8)把全部红色零件的颜色改成蓝色。
--更新操作
update P set Color='蓝' where Color='红';

--检查是否更改
select * from P;
(9)由S5供给J4的零件P6改为由S3供应。
--更新操作
update SPJ set Sno='S3' where Sno='S5' and Pno='P6' and Jno='J4';

--检查是否更改
select * from SPJ;
(10)从供应商关系中删除供应商号是S2的记录，并从供应情况关系中删除相应的记录。
--删除操作
--从供应商关系中删除供应商号是S2的记录
delete from S where Sno='S2';

insert into S(Sno,Sname,Status,City) values('S2','盛锡','10','北京');

delete from SPJ where Sno='S2';

select * from S;
select * from P;
select * from J;
select * from SPJ;
--从这个例子可以看出oracle数据库默认选择的删除是级联删除
--在删除S表中指定被引用的元组时,同时也会删除SPJ表中相关的元组
--供应情况关系中删除相应的记录
(11)请将(S2，J6，P4，200)插入供应情况关系。
--插入操作
insert into SPJ values('S2'，'P4'，'J6'，200);
6、请为三建工程项目建立一个供应情况的视图，包括供应商代码(SNO)、零件代码(PNO)、供应数量(QTY)。
--创建供应情况的视图
create view S_P_J(Sno,Pno,Qty) as select Sno,Pno,Qty from SPJ;

--查询视图
select * from S_P_J;

针对该视图完成下列查询：
(1)找出三建工程项目使用的各种零件代码及其数量
--方式一:创建视图,查询子句使用消除笛卡尔积的方式
create view Project_Infor as select distinct Pno,SPJ.Qty from J,SPJ where J.Jno=SPJ.Jno and Jname='三建';

--方式二:创建视图,查询子句使用内连接的方式
create view Project_Infor as select distinct SPJ.Pno,SPJ.Qty from J inner join SPJ on J.Jno=SPJ.Jno where Jname='三建';

--方式三:创建视图,查询子句使用自然连接的方式
create view Project_Infor as select distinct Pno,Qty from J natural join SPJ where Jname='三建';

--方式四:创建试图,查询子句使用子查询和in关键字来实现
create view Project_Infor as select distinct Pno,Qty from SPJ where Jno in (select Jno from J where Jname='三建' );

--首先在J表中根据Jname='三建'查询出Jno
select Jno from J where Jname='三建';

--然后根据已知的Jno集合在SPJ表中确定Pno,Qty
select distinct Pno,Qty from SPJ where Jno in (select Jno from J where Jname='三建' );
--查询视图
select * from Project_Infor;
--删除视图
drop view Project_Infor;
(2)找出供应商S1的供应情况
--创建视图
create view S1_Infor as select * from SPJ where Sno='S1';

--查询视图
select * from S1_Infor;

--删除视图
drop view S1_Infor;