Oracle知识

川长思鸟来 2022-08-24 00:49 278阅读 0赞

Number(38,0)类型:38表示总长度，0表示小数的长度，为0，如果为2，就表示后面有2位小数

存储过程无参的话，不加（），存储过程一般用在数据库的更新上

用sequence实现自增长

\-- 创建

create sequence tt

minvalue 1

maxvalue 999999

nocycle --不循环

start with 201

increment by 1

cache 100--缓存 100个

order;

\--删除

drop sequence tt;

--修改

alter sequence tt

cycle;

insert into temp(id) values( tt.nextval);

Insert into temp(id) values(tt.currval)

dbms\_output.put('the first');//单独用这条语句无法打印，需要结合DBMS\_OUTPUT.NEW\_LINE;

\--获取表中的数据放入变量中

declare

userid    NUMBER(38, 0) := 0;

user\_name varchar2(50) := '';

pass\_word varchar2(50) := '';

begin

select id, username, password  into userid, user\_name, pass\_word

from tuser

where id = 1;

dbms\_output.put\_line(userid || ' -->  ' || user\_name || ' -->  ' ||

pass\_word);

end;

\--null运算

select null\+5 from dual;

\--select null < 5 from dual;

select NULL|| 'ABC' from dual;

\-显示游标(用记录类型获取)

declare

\--声明游标

cursor c\_tuser is

select \* from tuser;

\--声明变量

v\_tuser tuser%rowtype;

begin

open c\_tuser;

loop

fetch c\_tuser

into v\_tuser;

dbms\_output.put\_line(v\_tuser.id || '   ' || v\_tuser.username || '    ' || v\_tuser.password);

exit when c\_tuser%notfound;

end loop;

close c\_tuser;

end;

\--for循环操作游标

declare

begin

for v\_tuser in (select \* from tuser) loop

dbms\_output.put\_line(v\_tuser.id || '   ' || v\_tuser.username || '    ' || v\_tuser.password);

end loop;

end;

PL/SQL语言是的SQL语言扩展，具有为程序开发而设计的特性，如数据封装、异常处理、面向对象等特性。

PL/SQL是嵌入到Oracle服务器和开发工具中的，具有很高的执行效率和同Oracle数据库的完美结合。在PL/SQL模块中可以使用查询语句和数据操纵语句(即进行DML操作)，这样就可以编写具有数据库事务处理功能的模块。

至于数据定义(DDL)和数据控制(DCL)命令的处理，需要通过Oracle提供的特殊的DMBS\_SQL包来进行。PL/SQL还可以用来编写过程、函数、包及数据库触发器。过程和函数也称为子程序，在定义时要给出相应的过程名和函数名。它们可以存储在数据库中成为存储过程和存储函数，并可以由程序来调用，它们在结构上同程序模块类似。

PL/SQL过程化结构的特点是：

可将逻辑上相关的语句组织在一个程序块内；

通过嵌入或调用子块，构造功能强大的程序；

可将一个复杂的问题分解成为一组便于管理、定义和实现的小块。

块结构和基本语法

PL/SQL程序的基本单元是块(BLOCK)，块就是实现一定功能的逻辑模块。一个PL/SQL程序由一个或多个块组成。块有固定的结构，也可以嵌套。一个块可以包括三个部分，每个部分由一个关键字标识。块中各部分的作用解释如下：

(1)  DECLARE：声明部分标志。

2)  BEGIN：可执行部分标志。

(3)  EXCEPTION：异常处理部分标志。

(4)  END；:程序结束标志。

显示PL/SQL程序模块的输出信息。

DBMS\_OUTPUT.PUT(字符串表达式)；

DBMS\_OUTPUT.PUT\_LINE(字符串表达式)；

DBMS\_OUTPUT.NEW\_LINE；//回车

注意：是否显\}示用DBMS\_OUTPUT.PUT\_LINE包进行输出的信息。

SQL> SET SERVEROUT\[PUT\] \{ON|OFF

块结构和基本语法

在PL/SQL模块中可以使用查询语句和数据操纵语句(即进行DML操作)，所以PL/SQL程序是同SQL语言紧密结合在一起的。

在PL/SQL程序中，最常见的是使用SELECT语句从数据库中获取信息，同直接执行SELECT语句不同，在程序中的SELECT语句总是和INTO相配合，INTO后跟用于接收查询结果的变量，形式如下：

SELECT 列名1，列名2... INTO 变量1，变量2... FROM 表名 WHERE 条件；

注意：接收查询结果的变量类型、顺序和个数同SELECT语句的字段的类型、顺序和个数应该完全一致。

并且SELECT语句返回的结果集必须是一行，否则将引发系统错误。当接收返回的多行结果时，可以采用后面介绍的游标的方法。

基本语法

使用INSERT、DELETE和UPDATE的语法没有变化，但在程序中要注意判断语句执行的状态，并使用COMMIT或ROLLBACK进行事务处理。

“--”是注释符号，后边是程序的注释部分。该部分不编译执行，所以在输入程序时可以省略。/\*......\*/中间也是注释部分，同“--”注释方法不同，它可以跨越多行进行注释。

Varchar2:是数据库特有的数据类型，varchar:是数据库都有的数据类型

PL/SQL数据类型

数据类型

定义变量

变量的作用是用来存储数据，可以在过程语句中使用。

变量在声明部分可以进行初始化，即赋予初值。

变量在定义的同时也可以将其说明成常量并赋予固定的值

变量的命名规则是：

以字母开头，后跟其他的字符序列，字符序列中可以包含字母、数值、下划线等符号

最大长度为30个字符，不区分大小写。

不能使用Oracle的保留字作为变量名。

变量名不要和在程序中引用的字段名相重，如果相重，变量名会被当作列名来使用。

定义变量empno=..de mingzi  shi

变量的作用范围是在定义此变量的程序范围内，如果程序中包含子块，则变量在子块中也有效。但在子块中定义的变量，仅在定义变量的子块中有效，在主程序中无效。

语法：变量名 \[CONSTANT\] 类型标识符 \[NOT NULL\]\[:=值|DEFAULT 值\];

关键字CONSTANT用来说明定义的变量是常量，如果是常量，必须有赋值部分进行赋值。

关键值NOT NULL用来说明变量不能为空。

∶=或DEFAULT用来为变量赋初值。

变量可以在程序中使用赋值语句重新赋值。通过输出语句可以查看变量的值。

变量名:=值 或 PL/SQL 表达式;

两种特殊的类型

%TYPE:根据表的字段或变量类型定义变量

变量的声明还可以根据数据库表的字段进行定义或根据已经定义的变量进行定义。方法是在表的字段名或已经定义的变量名后加 %TYPE，将其当作数据类型。定义字段变量的方法如下：

变量名 表名.字段名%TYPE;

%ROWTYPE:记录变量的定义

还可以根据表或视图的一个记录中的所有字段定义变量，称为记录变量。记录变量包含若干个字段，在结构上同表的一个记录相同，定义方法是在表名后跟%ROWTYPE。记录变量的字段名就是表的字段名，数据类型也一致。

记录变量名 表名%ROWTYPE；获得记录变量的字段的方法是：记录变量名.字段名，如emp\_record.ename。

declare

v\_record student%rowtype;

begin

select \* into v\_record from student where name='mly';

Dbms\_Output.put\_line('id:'||v\_record.studentid ||'  name:' ||v\_record.name || '  age:' ||v\_record.age);

end ;

运算符和函数

PL/SQL常见的运算符和函数包括以下方面：

算术运算：加(+)、减(-)、乘(\*)、除(/)、指数(\*\*)。

关系运算：小于(<)、小于等于(<=)、大于(>)、大于等于(>=)、等于(=)、不等于(!=或<>)。

字符运算：连接(||)。

逻辑运算：与(AND)、或(OR)、非(NOT)。

运算符说明

IS NULL或IS NOT NULL用来判断运算对象的值是否为空，不能用“=”去判断。另外，对空值的运算也必须注意，对空值的算术和比较运算的结果都是空，但对空值可以进行连接运算，结果是另外一部分的字符串。例如：

NULL+5的结果为NULL。

NULL>5的结果为NULL。

NULL|| 'ABC' 的结果为'ABC'。

在PL/SQL中可以使用绝大部分Oracle函数，但是组函数(如AVG( )、MIN( )、MAX( )等)只能出现在SQL语句中，不能在其他语句中使用。还有GREATEST( )、LEAST( )也不能使用。类型转换在很多情况下是自动的，在不能进行自动类型转换的场合需要使用转换函数。

PL/SQL的基本构成

基本语法

数据类型

变量定义

结构控制语句

分支结构

if语句

case语句

循环

游标、异常

IF语句

分支结构是最基本的程序结构，分支结构由IF语句实现。

使用IF语句，根据条件可以改变程序的逻辑流程。IF语句有如下的形式:

IF 条件1 THEN

语句序列1；

\[ELSIF 条件2 THEN

语句序列2；

ELSE

语句序列n；\]

END IF;

declare

v\_id varchar2(100);

begin

select studentid into v\_id from student where name='mly';

if v\_id='001' then

Dbms\_Output.put\_line(v\_id);

end if ;

if v\_id='001' then

Dbms\_Output.put\_line('v\_id=001');

elsif v\_id='002' then

Dbms\_Output.put\_line('v\_id=002');

else

Dbms\_Output.put\_line('v\_id is null');

end if ;

end;

IF语句说明

条件部分是一个逻辑表达式，值只能是真(TRUE)、假(FALSE)或空(NULL)。

语句序列为多条可执行的语句。

Oracle还提供了一种搜索CASE结构，它没有选择变量，直接判断条件表达式的值，根据条件表达式决定转向。

CASE

WHEN 条件表达式1 THEN

语句序列1

WHEN 条件表达式2 THEN

语句序列2

WHEN 条件表达式n THEN

语句序列n

ELSE

语句序列n+1

END CASE;

case

when v\_id='001' then

Dbms\_Output.put\_line('v\_id is 001');

when v\_id='002' then

Dbms\_Output.put\_line('v\_id is 002 ');

else

Dbms\_Output.put\_line('v\_id is null');

end case ;

CASE语句

CASE语句适用于分情况的多分支处理，可有以下三种用法。

基本CASE结构

语句的语法如下：

CASE 选择变量名

WHEN 值1 THEN

语句序列1

WHEN 值n THEN

语句序列n

ELSE

语句序列n+1

END CASE;

在整个结构中，选择变量的值同表达式的值进行顺序匹配，如果相等，则执行相应的语句序列，如果不等，则执行ELSE部分的语句序列。

表达式结构CASE语句

在Oracle中，CASE结构还能以赋值表达式的形式出现，它根据选择变量的值求得不同的结果。它的基本结构如下：

变量:=CASE 选择变量名

WHEN 表达式1 THEN 值1

WHEN 表达式n THEN 值n

ELSE值n+1

END;

v\_result:=CASE v\_grade

WHEN 'A' THEN '优‘

WHEN 'D' THEN '差'

ELSE '未知'

END;

基本LOOP

基本循环的结构如下：

LOOP  --循环起始标识

语句1;

语句2;

EXIT \[WHEN 条件\];

END LOOP; --循环结束标识

该循环的作用是反复执行LOOP与END LOOP之间的语句。

EXIT用于在循环过程中退出循环，WHEN用于定义EXIT的退出条件。如果没有WHEN条件，遇到EXIT语句则无条件退出循环。

写循环计算：sum=1+2+3+4+…10

declare

i integer := 1;

v\_sum number := 0;

begin

loop

v\_sum := v\_sum+i;

exit when i = 10;

i:=i+1;

end loop;

Dbms\_Output.put\_line(v\_sum);

end looppro;

While 循环

While 条件 loop

…..

End loop ;

v\_step :=1 ;

v\_result := 0 ;

while v\_step<11 loop

v\_result := v\_result + v\_step ;

v\_step := v\_step  + 1 ;

end loop ;

FOR LOOP

FOR循环是固定次数循环，格式如下：

FOR 控制变量 in \[REVERSE\] 下限..上限

LOOP

语句1;

语句2;

END LOOP;

循环控制变量是隐含定义的，不需要声明。

下限和上限用于指明循环次数。正常情况下循环控制变量的取值由下限到上限递增，REVERSE关键字表示循环控制变量的取值由上限到下限递减。

写循环计算：sum=1+2+3+4+…10

declare

j integer := 1;

v\_sum number := 0;

begin

for j in 1..10 loop

v\_sum := v\_sum +j;

end loop ;

Dbms\_Output.put\_line(v\_sum);

end loop;

游标是SQL的一个内存工作区，由系统或用户以变量的形式定义。

游标的作用就是用于临时存储从数据库中提取的数据块。在某些情况下，需要把数据从存放在磁盘的表中调到计算机内存中进行处理，最后将处理结果显示出来或最终写回数据库。这样数据处理的速度才会提高，否则频繁的磁盘数据交换会降低效率。

游标有两种类型：显式游标和隐式游标。

在前述程序中用到的SELECT...INTO...查询语句，一次只能从数据库中提取一行数据，对于这种形式的查询和DML操作，系统都会使用一个隐式游标。

但是如果要提取多行数据，就要由程序员定义一个显式游标，并通过与游标有关的语句进行处理。显式游标对应一个返回结果为多行多列的SELECT语句。

游标一旦打开，数据就从数据库中传送到游标变量中，然后应用程序再从游标变量中分解出需要的数据，并进行处理。

隐式游标

如前所述，DML操作和单行SELECT语句会使用隐式游标，它们是：

插入操作：INSERT。

更新操作：UPDATE。

删除操作：DELETE。

单行查询操作：SELECT ... INTO ...。

当系统使用一个隐式游标时，可以通过隐式游标的属性来了解操作的状态和结果，进而控制程序的流程。

隐式游标可以使用名字SQL来访问，但要注意，通过SQL游标名总是只能访问前一个DML操作或单行SELECT操作的游标属性。所以通常在刚刚执行完操作之后，立即使用SQL游标名来访问属性。游标的属性有四种，如表7-1所示。

隐式游标属性

隐式游标－例子

使用隐式游标的属性，判断对雇员工资的修改是否成功。

SET SERVEROUTPUT ON

BEGIN

UPDATE emp SET sal=sal+100 WHERE empno=1234;

IF SQL%FOUND THEN

DBMS\_OUTPUT.PUT\_LINE('成功修改雇员工资！');

COMMIT;

ELSE

DBMS\_OUTPUT.PUT\_LINE('修改雇员工资失败！');

END IF;

END;

显式游标

游标的使用分成以下4个步骤。

1．声明游标

在DECLARE部分按以下格式声明游标：

CURSOR 游标名 \[(参数1 数据类型\[，参数2 数据类型...\])\]

IS SELECT语句;

参数是可选部分，所定义的参数可以出现在SELECT语句的WHERE子句中。如果定义了参数，则必须在打开游标时传递相应的实际参数。

SELECT语句是对表或视图的查询语句，甚至也可以是联合查询。可以带WHERE条件、ORDER BY或GROUP BY等子句，但不能使用INTO子句。在SELECT语句中可以使用在定义游标之前定义的变量。

显式游标

2．打开游标

在可执行部分，按以下格式打开游标：OPEN 游标名\[(实际参数1\[，实际参数2...\])\];

打开游标时，SELECT语句的查询结果就被传送到了游标工作区。

3．提取数据

在可执行部分，按以下格式将游标工作区中的数据取到变量中。提取操作必须在打开游标之后进行。

FETCH 游标名 INTO 变量名1\[，变量名2...\];或  FETCH 游标名 INTO 记录变量;

游标打开后有一个指针指向数据区，FETCH语句一次返回指针所指的一行数据，要返回多行需重复执行，可以使用循环语句来实现。控制循环可以通过判断游标的属性来进行。

游标

获取数据格式：

第一种格式中的变量名是用来从游标中接收数据的变量，需要事先定义。变量的个数和类型应与SELECT语句中的字段变量的个数和类型一致。

第二种格式一次将一行数据取到记录变量中，需要使用%ROWTYPE事先定义记录变量，这种形式使用起来比较方便，不必分别定义和使用多个变量。

定义记录变量的方法如下：

其中的表必须存在，游标名也必须先定义。

变量名 表名|游标名%ROWTYPE；

4．关闭游标 CLOSE 游标名;

显式游标打开后，必须显式地关闭。游标一旦关闭，游标占用的资源就被释放，游标变成无效，必须重新打开才能使用。

例子1

【1】  用游标提取emp表中7788雇员的名称和职务。

SET SERVEROUTPUT ON

DECLARE

v\_ename VARCHAR2(10);

v\_job VARCHAR2(10);

CURSOR emp\_cursor IS

SELECT ename,job FROM emp WHERE empno=7788;

BEGIN

OPEN emp\_cursor;

FETCH emp\_cursor INTO v\_ename,v\_job;

DBMS\_OUTPUT.PUT\_LINE(v\_ename||','||v\_job);

CLOSE emp\_cursor;

END;

【训练2】  用游标提取emp表中7788雇员的姓名、职务和工资。

SET SERVEROUTPUT ON

DECLARE

CURSOR emp\_cursor IS  SELECT ename,job,sal FROM emp WHERE empno=7788;

emp\_record emp\_cursor%ROWTYPE;

BEGIN

OPEN emp\_cursor;

FETCH emp\_cursor INTO emp\_record;

DBMS\_OUTPUT.PUT\_LINE(emp\_record.ename||','||emp\_record.job||','|| emp\_record.sal);

CLOSE emp\_cursor;

END;

例子3

【训练3】  显示工资最高的前3名雇员的名称和工资。

SET SERVEROUTPUT ON

DECLARE

V\_ename VARCHAR2(10);

V\_sal NUMBER(5);

CURSOR emp\_cursor IS  SELECT ename,sal FROM emp ORDER BY sal DESC;

BEGIN

OPEN emp\_cursor;

FOR I IN 1..3 LOOP

FETCH emp\_cursor INTO v\_ename,v\_sal;

DBMS\_OUTPUT.PUT\_LINE(v\_ename||','||v\_sal);

END LOOP;

CLOSE emp\_cursor;

END;

游标循环

【训练1】使用特殊的FOR循环形式显示全部雇员的编号和名称。

SET SERVEROUTPUT ON

DECLARE

CURSOR emp\_cursor IS

SELECT empno, ename FROM emp;

BEGIN

FOR Emp\_record IN emp\_cursor LOOP

DBMS\_OUTPUT.PUT\_LINE(Emp\_record.empno|Emp\_record.ename);

END LOOP;

END;

说明：可以看到该循环形式非常简单，隐含了记录变量的定义、游标的打开、提取和关闭过程。Emp\_record为隐含定义的记录变量，循环的执行次数与游标取得的数据的行数相一致。

不用打开游标

游标

【训练2】  另一种形式的游标循环。

SET SERVEROUTPUT ON

BEGIN

FOR re IN (SELECT ename FROM EMP)  LOOP

DBMS\_OUTPUT.PUT\_LINE(re.ename)

END LOOP;

END;

说明：该种形式更为简单，省略了游标的定义，游标的SELECT查询语句在循环中直接出现。

显式游标属性

游标名%属性

要判断游标emp\_cursor是否处于打开状态，可以使用属性emp\_cursor%ISOPEN。如果游标已经打开，则返回值为“真”，否则为“假”。具体可参照以下的训练。

游标参数的传递

SET SERVEROUTPUT ON

DECLARE

V\_empno NUMBER(5);

V\_ename VARCHAR2(10);

CURSOR emp\_cursor(p\_deptno NUMBER,  p\_job VARCHAR2) IS SELECT empno, ename FROM emp  WHERE deptno = p\_deptno AND job = p\_job;

BEGIN

OPEN emp\_cursor(10, 'CLERK');

LOOP

FETCH emp\_cursor INTO v\_empno,v\_ename;

EXIT WHEN emp\_cursor%NOTFOUND;

DBMS\_OUTPUT.PUT\_LINE(v\_empno||','||v\_ename);

END LOOP;

END;

异常处理

错误处理部分位于程序的可执行部分之后，是由WHEN语句引导的多个分支构成的。错误处理的语法如下：

EXCEPTION

WHEN 错误1\[OR 错误2\] THEN

语句序列1；…

WHEN OTHERS THEN

语句序列n；

END;

错误是在标准包中由系统预定义的标准错误，或是由用户在程序的说明部分自定义的错误，参见下一节系统预定义的错误类型。

语句序列就是不同分支的错误处理部分。

说明

凡是出现在WHEN后面的错误都是可以捕捉到的错误，其他未被捕捉到的错误，将在WHEN OTHERS部分进行统一处理，OTHERS必须是EXCEPTION部分的最后一个错误处理分支。如要在该分支中进一步判断错误种类，可以通过使用预定义函数SQLCODE( )和SQLERRM( )来获得系统错误号和错误信息。

如果在程序的子块中发生了错误，但子块没有错误处理部分，则错误会传递到主程序中。

下面是由于查询编号错误而引起系统预定义异常的例子。

SQLCODE(),SQLERRM()

常用exception

Too\_many\_rows 行过多

No\_data\_found 数据为空

Case\_not\_found 建case时无分支语句

Cursor\_already\_open 重新打开已打开的游标

Dup\_val\_on\_index 主键冲突

Invalid\_cursor 要对未打开或已关闭的游标读取数据

Zero\_divide 除0异常

系统预定义异常

PL/SQL集合

索引表

嵌套表

变长数组

记录表

当执行DML语句时，Oracle会在作用表上加表锁，以防止用户改变结构；同时会在被作用行上加行锁，防止其他DML在相应行上执行DML语句。

在Oracle数据库中为了确保数据的一致性，不允许其他用户读脏数据（未提交的数据）

读“脏”数据的例子：

事务1修改某一数据，并将其写回磁盘

事务2读取同一数据后

事务1由于某种原因被撤消，这时事务1已修改过的数据恢复原值

事务2读到的数据就与数据库中的数据不一致，

是不正确的数据，又称为“脏”数据。

使用commit可以提交事务，执行commit后会确认事务变化，结束事务，删除保存点，释放锁。其他事务也能看到事务变化后的数据。

\--设置串型化事务管理：两个事务同时操作同一数据，同一条记录时，数据库里的数据可能会乱，这时数据库不知道先执行那条，故加串型化事务管理，可以让一方，让先执行的语句提交，执行完后，再让第二方执行

设置串型化事务管理，使先操作的语句，加了行锁，只有等当前操作完，另一个用户的语句才可以执行提交

\--会话1（--》SQL界面1）

set transaction isolation level serializable;

update tuser set ausername=ausername||1 where aid=1;

\--会话2（--》SQL界面2）

select \* from tuser for update nowait;

当用户1在执行，没提交时，用户2加了nowait时，就会提示资源忙，当不加nowait时就会一直等待，等待用户1的语句执行完

在创建表之后，创建表的嵌套表

create type phone\_table\_type is table of varchar2(100);

declare

phone\_tables phone\_table\_type := phone\_table\_type('1303243434',

'13234343434');

begin

update tuser set phone = phone\_tables where id = 20;

commit;

end;

回退事务

保存点是事务中的一点，用于取消部分事务，当结束事务时会删除所定义的保存点。执行rollback时，可以根据保存点回退部分事务。

Rollback to A 回退到保存点A

Rollback取消全部事务

declare

Begin

insert into student values(6,'zhangsan',20);

savepoint a1 ;

insert into student values(7,'lisi',21);

savepoint a2 ;

insert into student values(6,'wangwu',22);

commit ;

exception

when dup\_val\_on\_index then

rollback to a1;

commit;

end;

当rollback to a1;只增加了6,'zhangsan',20一条数据

当rollback to a1;增加了6,'zhangsan',20和7,'lisi',21

只读事务是只允许读操作，不允许其他DML操作。当使用只读事务时可以确保用户取得特定时间点的数据。假定要在16点统计最近24小时的销售记录，当设置了只读事务后，尽管其他回话会提交新事务，但只读事务不会取得新数据。

set transaction read write

select \* from tuser;

set transaction read only;

insert into tuser values (23, 'zhangsan', '12345');

select \* from tuser;

语法set transaction read \{only|write\}

事务只读事务中,再进行DML就会出错.

在cmd中运行：

先输入运行

set serveroutput on，

再运行调用的存储过程或函数的语句

select \* from student for update ;查询出来然后再修改表里面的数据

静态SQL和动态SQL的区别和比较

静态SQL是在编写PL/SQL块时直接嵌入的SQL语句。动态SQL是在运行PL/SQL块时动态输入的SQL语句。

静态SQL性能要优于动态SQL。如果功能确定应该适用静态SQL。

\--动态sql

declare

d\_sql varchar2(100) := '';

begin

d\_sql := 'drop table tuser1';

execute immediate d\_sql;

end;

\--动态sql采用变量

declare

d\_sql varchar2(100) := '';

begin

d\_sql := 'update tuser set username=:y where id=:x';

execute immediate d\_sql using 'zhangsan',4;

end;

\--动态sql单行查询

declare

d\_sql varchar2(100) := '';

\--定义记录类型

v\_tuser tuser%rowtype;

begin

\--编写动态sql

d\_sql := 'select \* from tuser where id=:x';

\--执行动态sql

execute immediate d\_sql into v\_tuser using 4;

dbms\_output.put\_line(v\_tuser.id||'   '||v\_tuser.username);

end;

处理包含占位符的语句

declare

v\_presql varchar2(100) ;

begin

v\_presql := 'update student set name=:x where id=100  ' ;

execute immediate v\_presql using 'lisi‘;

commit ;

end;

Java调用存储过程

加载ojdbc14.jar

Driver:oracle.jdbc.driver.OracleDriver

Connectionurl:jdbc:oracle:thin:@localhost:1521:orcl

Java调用存储过程和function.

Truncate数据被删除后，高水平线（high-water mark，HWM）并没有复位只是那些空间不再使用而已，再次查询依然会读取HWH以前的块查找是否有可用的数据。而截断表将复位HWH，告诉这些空间没有保存数据。

一是truncate速度快，无法回滚，因为truncate不是dml语句；二是truncate能降低HWM，而delete 无法降低HWM，因此无法表在用delete删除，表的大小没有改变！

merge 语法\--把tuser1 里面的数据加到tuser里面，并替换掉

merge into tuser t

using tuser1 t1

on (t.id = t1.id)

when matched then

update set t.username = t1.username, t.password = t1.password

when not matched then

insert values (t1.id, t1.username, t1.password)

复合数据类型

PL/SQL记录

PL/SQL集合

PL/SQL记录

它由一组相关的成员变量组成

有两种定义方式：

(1) type student\_record is record (

stuid number(4),

name varchar2(20),

sex number(1) ,

age number(3)

);

(2) emp\_record emp%rowtype;

见例子:record\_define.txt

可以通过select into 语句将单行记录写入PL/SQL记录。

例:

v\_emp\_rec emp%rowtype ;

select \* into v\_emp\_rec from emp   where  empno=7369;

在insert语句中使用insert into emp values emp\_record;

例:

v\_emp\_rec.empno := 7340;

insert into emp values v\_emp\_rec ;

\--定义记录类型

declare

\--定义记录类型

type tuser\_record\_type is record(

v\_id       tuser.id%type,

v\_username tuser.username%type,

v\_password tuser.password%type);

\--定义记录类型变量

tuser\_record tuser\_record\_type;

begin

select \* into tuser\_record from tuser where id = 20;

dbms\_output.put\_line(tuser\_record.v\_id || '   ' ||

tuser\_record.v\_username || '   ' ||

tuser\_record.v\_password);

end;

\--2

declare

\--定义记录类型变量

tuser\_record tuser%rowtype;

begin

select \* into tuser\_record from tuser where id = 20;

dbms\_output.put\_line(tuser\_record.id || '   ' || tuser\_record.username ||

'   ' || tuser\_record.password);

end;

select \* from tuser;

PL/SQL集合：

索引表(PL/SQL表)

它是Oracle早期版本中用于处理PL/SQL数组的数据类型.

索引表的下标可以为负值,而且其元素个数没有限制.

declare

--数组下标索引

i  binary\_integer := -1 ;

--定义索引表数组类型

type ename\_table\_type is table of emp.ename%type index by binary\_integer ;

--创建数组变量

v\_ename\_table ename\_table\_type ;

cursor v\_emp\_cur is select \* from emp where deptno=20 ;

begin

--给数组变量赋值

for v\_record in v\_emp\_cur loop

v\_ename\_table(i) := v\_record.ename ;

i := i+1 ;

end loop;

--判断索引表里是否有元素

if(v\_ename\_table.count>0) then

--输出数组里的值

for j in v\_ename\_table.first..v\_ename\_table.last loop

dbms\_output.put\_line(v\_ename\_table(j));

end loop ;

end if ;

end;

\--索引表

declare

\--定义索引表类型

type username\_sy\_type is table of varchar2(100) index by binary\_integer;

\--定义索引表变量

username\_sy username\_sy\_type;

\--建立索引表下标--下标可以是负整数，0，正整数

i binary\_integer := -1;

\--定义游标获取tuser表数据

cursor c\_tuser is

select username from tuser;

begin

\--循环游标将username放入索引表

open c\_tuser;

loop

\--将值放入索引表

fetch c\_tuser

into username\_sy(i);

i := i + 1;

\--退出循环

exit when c\_tuser%notfound;

end loop;

\--将数据从索引表中取出并打印

for j in username\_sy.first .. username\_sy.last loop

dbms\_output.put\_line(username\_sy(j));

end loop;

end;

\--嵌套表

数组下标从1开始，长度不限.

嵌套表需要先进行初始化才能使用.

可以做为表列的数据类型使用.

Type ename\_table\_type is table of varchar(100);

Ename\_table ename\_table\_type ;

--构造方法,初始情况下有两个元素.

Ename\_table :＝ ename\_table\_type （’A’,’A’）;

\--构造方法,初始情况下没有元素.

ename\_table\_type（）;

\--分配一个空间

Ename\_table.extend ;

Select name into ename\_table(2) from emp where ….

declare

\--定义嵌套表类型

type password\_qt\_type is table of varchar2(100);

\--定义嵌套表变量并调用构造函数初始化

password\_qt password\_qt\_type := password\_qt\_type();

i           binary\_integer := 1;\--嵌套表类型的下标从1开始

begin

\--循环遍历游标

for u in (select password from tuser) loop

\--给嵌套表开辟新的长度

password\_qt.extend;

\--给嵌套表赋值

password\_qt(i) := u.password;

i := i + 1;

end loop;

\--变量嵌套表并打印数据

for j in 1 .. password\_qt.count loop

dbms\_output.put\_line(password\_qt(j));

end loop;

end;

在pl/sql块中使用嵌套表：

declare

--定义嵌套表数据类型

type ename\_table\_type is table of emp.ename%type;

--定义嵌套表类型的变量,并调用构造方法进行初始化.

ename\_table ename\_table\_type := ename\_table\_type();

cursor v\_emp\_cur is select ename from emp where deptno =20 ;

--定义嵌套表的开始下标

i binary\_integer :=1 ;

begin

for v\_record in v\_emp\_cur loop

--给ename\_table变量分配空间

ename\_table.extend;

--给ename\_table变量赋值

ename\_table(i) :=v\_record.ename ;

i := i+1 ;

end loop ;

--输出嵌套表变量ename\_table里的所有值

for j in 1..ename\_table.count loop

dbms\_output.put\_line( ename\_table(j) );

end loop ;

end;

nested table PHONE store as my\_phone:设置表的列为嵌套表类型

nested table p store as <nested\_table\_name>：

<nested\_table\_name>：设置嵌套表的名字，可以任意取

在创建表时，创建表的嵌套表

注:在表列中使用嵌套表,需要先使用create type 命令先创建嵌套表类型.

create type phone\_table\_type is table of varchar2(20);

\--新建

create table student

(

stuid  number(5) ,

name varchar2(20),

phone phone\_table\_type

) nested table phone store as phone\_table ;

public class Function \{

public static void main(String\[\] args) throws SQLException \{

Connection connection = Conn.getconn();

// 存储过程调用语句

String sql = "\{?=call decfun(?,?)\}";

// 获取存储过程调用对象

CallableStatement call = connection.prepareCall(sql);

// 设置输入参数

call.setInt(2, 10);

call.setInt(3, 2);

// 设置输出参数

call.registerOutParameter(1, OracleTypes.INTEGER);

// 执行函数

call.executeUpdate();

// 获取返回值

int rs = call.getInt(1);

System.out.println(rs);

connection.close();

public static void main(String\[\] args) throws SQLException \{

Connection connection = Conn.getconn();

// 存储过程调用语句

String sql = "\{call adderpro(?,?,?)\}";

// 获取存储过程调用对象

CallableStatement call = connection.prepareCall(sql);

// 设置输入参数

call.setInt(1, 10);

call.setInt(2, 20);

// 设置输出参数

call.registerOutParameter(3, OracleTypes.INTEGER);

// 执行存储过程

call.executeUpdate();

// 获取存储过程返回值

int rs = call.getInt(3);

System.out.println(rs);

connection.commit();

connection.close();

declare

v\_phone\_table phone\_table\_type ;

begin

--在PL/SQL块中为nested table 插入数据

insert into student  values(1,'lisi',phone\_table\_type('138111111','139111111'));

\--在PL/SQL块中检索nested table 列的数据

select phone into v\_phone\_table from student where stuid=1 ;

for i in 1..v\_phone\_table.count loop

dbms\_output.put\_line('phone:'||v\_phone\_table(i) );

end loop;

变长数组(Varray)

变长数组需要先进行初始化才能使用.

可以做为表列的数据类型使用.

数组下标从1开始,长度有限.

declare

--定义变长数组的类型名称,及最大长度

type ename\_varray\_type is varray(10) of varchar2(20);

--定义变长数组变量,并进行初始化

v\_ename\_varray ename\_varray\_type := ename\_varray\_type() ;

cursor v\_emp\_cur is select \* from emp where deptno=20 ;

i binary\_integer := 1 ;

begin

for v\_record in v\_emp\_cur loop

--给变长数组分配空间

v\_ename\_varray.extend ;

--给变长数组赋值

v\_ename\_varray(i) :=v\_record.ename ;

i := i + 1 ;

end loop;

--输出变长数组里的元素

for i in 1..v\_ename\_varray.count loop

dbms\_output.put\_line(v\_ename\_varray(i));

end loop;

end;

在表列中使用变长数组：

create type phone\_arr\_type is varray(5) of varchar2(20) ;

create table student

(

stuid number(4),

name varchar2(20),

phone phone\_arr\_type

);

//其它用法和嵌套表一样

\--记录表

declare

\--定义记录表类型

type tuser\_jl\_type is table of tuser%rowtype index by binary\_integer;

\--定义记录表变量

tuser\_jl tuser\_jl\_type;

\--自增变量

i binary\_integer := 1;

begin

\--循环遍历游标

for u in (select \* from tuser) loop

\--给记录表赋值

tuser\_jl(i) := u;

i := i + 1;

end loop;

\--变量嵌套表并打印数据

for j in tuser\_jl.first .. tuser\_jl.last loop

dbms\_output.put\_line(tuser\_jl(j).id || '  ' || tuser\_jl(j).username);

end loop;

end;

为了处理多行多列数据，可以使用记录表.

declare

--定义记录表类型

type emp\_table\_type is table of emp%rowtype index by binary\_integer ;

--定义记录表变量

v\_emp\_table emp\_table\_type ;

cursor v\_emp\_cur is select \* from emp where deptno=20 ;

--定义记录表下标索引

i binary\_integer := -1 ;

begin

--给记录表变量赋值

for v\_record in v\_emp\_cur loop

v\_emp\_table(i) := v\_record ;

i := i + 1 ;

end loop;

--输出记录表变量的值

for j in v\_emp\_table.first..v\_emp\_table.last loop

dbms\_output.put\_line(v\_emp\_table(j).ename);

end loop;

end;

批量绑定

是指执行单次SQL操作能传递所有集合元素的数据.

当在select,insert,update,delete 语句上处理批量数据时,通过批量绑定,可以极大加快数据处理速度.

Forall语句和bulk collect可以用来做批量绑定

Forall一般用于insert ,update ,delete.

Insert into student1 select \* from student2;执行的是批量操作。

批量修改：

declare

type id\_table\_type is table of number(6) index by binary\_integer ;

type name\_table\_type is table of varchar(20) index by binary\_integer ;

v\_id\_table id\_table\_type;

v\_name\_table name\_table\_type;

begin

for i in 1..5000 loop

v\_id\_table(i) := i ;

v\_name\_table(i) := 'name2' || to\_char(i) ;

end loop ;

forall i in 1..5000

update student set name = v\_name\_table(i) where id = v\_id\_table(i) ;

commit ;

dbms\_output.put\_line('end');

end;

Bulk collect 一般用于select into .

Bulk collect子句用与取得批量数据，适用于select into语句,fetch into 语句,DML返回子句，通过使用该子句，可以将批量数据存放到pl/sql集合变量中。

在select into语句中用bulk collect 子句：

declare

type student\_table\_type is table of student.name%type index by binary\_integer;

v\_student\_table student\_table\_type ;

begin

select name bulk collect into v\_student\_table from student ;

for i in 1..50 loop

dbms\_output.put\_line(v\_student\_table(i));

end loop ;

end;

在fetch into语句中用bulk collect 子句

declare

type student\_table\_type is table of student%rowtype index by binary\_integer;

v\_student\_table student\_table\_type ;

cursor v\_studentcursor  is select \* from student ;

begin

open v\_studentcursor ;

fetch v\_studentcursor bulk collect into       v\_student\_table ;

close v\_studentcursor ;

dbms\_output.put\_line(v\_student\_table.count);

end;

在DML返回子句中用bulk collect 子句：

declare

type student\_table\_type is table of student%rowtype index by binary\_integer;

v\_student\_table student\_table\_type ;

begin

delete from student where age<11 returning id,name ,age bulk collect into v\_student\_table ;

for i in 1..v\_student\_table.count loop

dbms\_output.put\_line(v\_student\_table(i).name);

end loop ;

commit;

end;

[Oracle-SQL-group by-报错：不是单组分组函数][Oracle-SQL-group_by-]

分类： [数据库技术][Link 1] 2010-03-16 19:469338人阅读[评论][Link 2](0)收藏[举报][Link 3]

报错：不是单组分组函数

实例：select deptno,count(empno) from emp;

报错：不是单组分组函数

原因：

1，  如果程序中使用了分组函数，则有两种情况可以使用：

程序中存在group by，并指定了分组条件，这样可以将分组条件一起查询出来

改为：select deptno,count(empno) from emp group by deptno;

如果不使用分组的活，则只能单独使用分组函数

改为：select count(empno) from emp;

2，  在使用分组函数的时候，不能出现分组条件之外的字段

总结：在select需要查询的语句中选中的字段，必须出现在group by子句中，除了分组函数的参数。

Group by

如果在查询的过程中需要按某一列的值进行分组,以统计该组内数据的信息时,就要使用group by子句。不管select是否使用了where子句都可以使用group by子句。

注意：group by子句一定要与分组函数结合使用,否则没有意义。

//求出每个部门的员工人数

SQL> select deptno,count(\*) as "人数" from emp group by deptno;

//求出每个部门的员工的平均工资

SQL> select deptno,avg(nvl(sal,0)) from emp group by deptno;

//注意：group by 子句中的列不必包含在SELECT 列表中

SQL> select avg(nvl(sal,0)) from emp group by deptno;

//求出某个部门中相同职位的员工人数   group by 后可以跟多个分组的字段

SQL> select deptno,job,count(\*) from emp group by deptno,job order by deptno;

Having 子句

HAVING 子句对 GROUP BY 子句设置条件的方式与 WHERE 子句和 SELECT 语句交互的方式类似。WHERE 子句搜索条件在进行分组操作之前应用；而 HAVING 搜索条件在进行分组操作之后应用。HAVING 语法与 WHERE 语法类似，但 HAVING 可以包含聚合函数。HAVING 子句可以引用选择列表中出现的任意项。

备注：having子句通常与group by子句结合使用

语法：

SELECT     column, group\_function

FROM                table

\[WHERE   condition\]

\[GROUP BY      group\_by\_expression\]

\[HAVING  group\_condition\]

\[ORDER BY       column\];

//查询部门的员工人数大于五部门编号

SQL> select deptno,count(\*) from emp group by deptno having count(\*)>5;

select pid,

sum(case when type=0 then 1 else 0 end) type\_0,

sum(case when type=1 then 1 else 0 end) type\_1,

sum(case when type=2 then 1 else 0 end) type\_2

from A

group by pid

//求出某个部门中相同职位的员工人数   group by 后可以跟多个分组的字段  
SQL> select deptno,job,count(\*) from emp group by deptno,job order by deptno;

非法使用组函数  
1、 所用包含于SELECT 列表中，而未包含于组函数中的列都必须包含于 GROUP BY 子句中。  
举例：  
SQL> select empno,count(job) from emp;  
正确写法如下：  
SQL> select empno,count(job) from emp group by empno;  
2、 不能在 WHERE 子句中使用组函数（注意）。  
SQL> select deptno from emp where count(job)>0 group by deptno;  
备注：ORA-00934: 此处不允许使用分组函数  
Having 子句  
    HAVING 子句对 GROUP BY 子句设置条件的方式与 WHERE 子句和 SELECT 语句交互的方式类似。WHERE 子句搜索条件在进行分组操作之前应用；而 HAVING 搜索条件在进行分组操作之后应用。HAVING 语法与 WHERE 语法类似，但 HAVING 可以包含聚合函数。HAVING 子句可以引用选择列表中出现的任意项。  
备注：having子句通常与group by子句结合使用

select m.mat\_collegeid from mat m where mat\_flag = 1 group by m.mat\_collegeid:可以过掉重复的id,

如果想删掉相同的id值，可以select t.\*,rowid from student t

根据rowid的不同来删除，可以拿到max(rowid) 来删掉其他的

比较运算符   
>,<:大于，小于   
>=.<=:大于等于，小于等于   
=:等于   
!=,<>,^=:不等于   
  
逻辑运算符运算的优先顺序是NOT，AND，OR。如果要改变优先顺序，可以使用括号  
  
逻辑运算符   
AND:逻辑与，表示两个条件必须同时满足   
OR:逻辑或，表示两个条件中有一个条件满足即可   
NOT:逻辑非，返回与某条件相反的结果   
  
特殊运算符   
\[NOT\] BETWEEN…AND…:用于测试是否在范围内   
\[NOT\] IN (…):用于测试是否在列表中   
\[NOT\] LIKE:用于进行模式匹配   
IS \[NOT\] NULL:用于测试是否为空值   
ANY SOME:同列表或查询中的每一个值进行比较，测试是否有一个满足，前面必须使用的运算符包括=、!=、>=、<=、>、<等   
ALL:同列表或查询中的每一个值进行比较，测试是否所有的值都满足，前面必须使用的运算符包括=、!=、>=、<=、>、<等   
\[NOT\] EXISTS:测试是否子查询至少返回一行   
  
IN的用法  
 使用以下运算形式，可以显示值满足特定集合的结果：   
 \[NOT\] IN (...)   
 显示职务为“SALESMAN'，“CLERK”和“MANAGER”的雇员信息。   
 输入并执行查询： Sql代码

1 SELECT \* FROM emp WHERE job IN ('SALESMAN','CLERK','MANAGER');

执行结果从略。   
 注意：如果在IN前面增加NOT，将显示职务不在集合列表中的雇员。以上用法同样适用于数值型集合，   
  
多行子查询  
如果子查询返回多行的结果，则我们称它为多行子查询。多行子查询要使用不同的比较运算符号，它们是IN、ANY和ALL。   
 查询工资低于任何一个“CLERK”的工资的雇员信息。   
 执行以下查询： Sql代码

2 SELECT  empno, ename, job,sal FROM emp

3         WHERE   sal < ANY (SELECT sal FROM emp WHERE job = 'CLERK')

4         AND job <> 'CLERK';

执行结果为：

Sql代码

5 EMPNO ENAME      JOB              SAL

6         ------------------- ------------ ----------------- ---------------------

7              7521 WARD       SALESMAN         1250

8             7654 MARTIN     SALESMAN         1250

说明：在emp表的雇员中有4个职务为“CLERK”，他们的工资分别是800、1100、950、1300。满足工资小于任何一个“CLERK”的工资的记录有2个，在这里使用了ANY运算符表示小于子查询中的任何一个工资。   
 注意：条件job <> 'CLERK'排除了职务是CLERK的雇员本身。   
查询工资比所有的“SALESMAN”都高的雇员的编号、名字和工资。   
 执行以下查询： Sql代码

9 SELECT  empno, ename,sal FROM emp

10         WHERE sal > ALL(SELECT sal FROM emp WHERE job= 'SALESMAN');

执行结果为：

Sql代码

11 EMPNO ENAME             SAL

12     ---------------- ------------- -----------------------

13       7566 JONES               2975

14       7698 BLAKE               2850

15       7782 CLARK               2450

16       7788 SCOTT               3000

17       7839 KING                5000

18       7902 FORD                3000

说明：在emp表的雇员中有4个职务为“SALESMAN”，他们的工资分别是1600、1250、1250、1500。在这里使用了ALL运算符，表示大于查询中所有的工资。   
查询部门20中职务同部门10的雇员一样的雇员信息。   
 执行以下查询：

Sql代码

19 SELECT  empno, ename, job FROM emp

20 WHERE   job IN (SELECT job FROM emp WHERE deptno=10)

21 AND deptno =20;

执行结果为：

Sql代码

22 EMPNO ENAME          JOB

23     ------------------ -------------- ----------------------

24       7369 SMITH        CLERK

25       7876 ADAMS        CLERK

26       7566 JONES        MANAGER

说明：在该训练中，使用IN运算符表示职务是子查询结果中的任何一个。部门10中有3种职务：MANAGER、PRESIDENT和CLERK，以上查询得到的是部门20中是这3种职务的雇员。   
  
多列子查询  
 如果子查询返回多列，则对应的比较条件中也应该出现多列，这种查询称为多列子查询。以下是多列子查询的训练实例。   
 查询职务和部门与SCOTT相同的雇员的信息。   
 执行以下查询： Sql代码

27 SELECT  empno, ename, sal FROM emp

28         WHERE (job,deptno) =(SELECT job,deptno FROM emp WHERE empno=7788);

执行结果为：

Sql代码

29 EMPNO ENAME      JOB

30         ------------------ --------------- ----------------

31             7902 FORD        ANALYST

说明：在该例的子查询中返回两列，查询条件中也要出现两列，表示雇员的职务和部门应该和SCOTT的职务和部门相同。   
  
LIKE的用法  
 使用LIKE操作符可完成按通配符查找字符串的查询操作，该操作符适合于对数据进行模糊查询。其语句法为：   
 \[NOT\] LIKE 匹配模式   
 匹配模式中除了可以包含固定的字符之外，还可以包含以下的通配符：   
 %：代表0个或多个任意字符。   
 \_ ：代表一个任意字符。   
显示姓名以“S”开头的雇员信息。   
 输入并执行查询： Sql代码

32 SELECT \* FROM emp WHERE ename LIKE 'S%';

执行结果为： Sql代码

33 EMPNO ENAME     JOB             MGR HIREDATE     SAL   COMM     DEPTNO

34         ------------- -------------- ------------------------- ---------- ------------------ ----------- ------------ ------------------

35 7369 SMITH    CLERK 7902 17-12月-80       800     20

36 7788 SCOTT    ANALYST   7566 19-4月 -87   3000           20

说明：SMITH和SCOTT名字均以S开头，名字后边的字符和长度任意。   
显示姓名第二个字符为“A”的雇员信息。   
 执行查询： Sql代码

37 SELECT \* FROM emp WHERE ename LIKE '\_A%';

说明：“\_”代表第一个字符任意，第二个字符必须为“A”，“%”代表第二个字符后面的字符为任意字符，个数任意。   
  
判断空值NULL  
 在表中，字段值可以是空，表示该字段没有内容。如果不填写，或设置为空则我们说该字段的内容为NULL。NULL没有数据类型，也没有具体的值，但是使用特定运算可以判断出来。这个运算就是：   
 IS  \[NOT\] NULL   
显示经理编号没有填写的雇员。   
 输入并执行查询： Sql代码

38 SELECT  ename, mgr FROM emp WHERE mgr IS NULL;

执行结果为： Sql代码

39 ENAME     MGR

40 SELECT \* FROM emp WHERE job IN ('SALESMAN','CLERK','MANAGER');

41 SELECT  empno, ename, job,sal FROM emp

42         WHERE   sal < ANY (SELECT sal FROM emp WHERE job = 'CLERK')

43         AND job <> 'CLERK';

执行结果为：

Sql代码

44 EMPNO ENAME      JOB              SAL

45         ------------------- ------------ ----------------- ---------------------

46              7521 WARD       SALESMAN         1250

47             7654 MARTIN     SALESMAN         1250

48 SELECT  empno, ename,sal FROM emp

49         WHERE sal > ALL(SELECT sal FROM emp WHERE job= 'SALESMAN');

执行结果为：

Sql代码

50 EMPNO ENAME             SAL

51     ---------------- ------------- -----------------------

52       7566 JONES               2975

53       7698 BLAKE               2850

54       7782 CLARK               2450

55       7788 SCOTT               3000

56       7839 KING                5000

57       7902 FORD                3000

Sql代码

58 SELECT  empno, ename, job FROM emp

59 WHERE   job IN (SELECT job FROM emp WHERE deptno=10)

60 AND deptno =20;

执行结果为：

Sql代码

61 EMPNO ENAME          JOB

62     ------------------ -------------- ----------------------

63       7369 SMITH        CLERK

64       7876 ADAMS        CLERK

65       7566 JONES        MANAGER

66 SELECT  empno, ename, sal FROM emp

67         WHERE (job,deptno) =(SELECT job,deptno FROM emp WHERE empno=7788);

执行结果为：

Sql代码

68 EMPNO ENAME      JOB

69         ------------------ --------------- ----------------

70             7902 FORD        ANALYST

71 SELECT \* FROM emp WHERE ename LIKE 'S%';

执行结果为： Sql代码

72 EMPNO ENAME     JOB             MGR HIREDATE     SAL   COMM     DEPTNO

73         ------------- -------------- ------------------------- ---------- ------------------ ----------- ------------ ------------------

74 7369 SMITH    CLERK 7902 17-12月-80       800     20

75 7788 SCOTT    ANALYST   7566 19-4月 -87   3000           20

说明：SMITH和SCOTT名字均以S开头，名字后边的字符和长度任意。   
显示姓名第二个字符为“A”的雇员信息。   
 执行查询： Sql代码

76 SELECT \* FROM emp WHERE ename LIKE '\_A%';

77 SELECT  ename, mgr FROM emp WHERE mgr IS NULL;

执行结果为： Sql代码

78 ENAME     MGR

79         ------------ ---------------

80         KING

81   
  注意：以下用法是错误的。  
 SELECT  ename, mgr FROM emp WHERE mgr=NULL;         ------------ ---------------

82         KING

注意：以下用法是错误的。  
 SELECT  ename, mgr FROM emp WHERE mgr=NULL;

[Oracle-SQL-group_by-]: http://blog.csdn.net/fdgaq/article/details/5386565
[Link 1]: http://blog.csdn.net/fdgaq/article/category/515775
[Link 2]: http://blog.csdn.net/fdgaq/article/details/5386565#comments
[Link 3]: http://blog.csdn.net/fdgaq/article/details/5386565#report