Oracle 动态游标 PL/SQL 动态SQL语句 open for [using] 语句

小咪咪 2022-04-06 05:12 1114阅读 0赞

### PL/SQL:open for \[using\] 语句 ###

2017年07月19日 09:52:55 [学孩儿无牙哭做粥][Link 1] 阅读数：681 标签： [oracle][][SQLPLSQL][] 更多

个人分类： [ORACLE][][SQL/PLSQL][SQL_PLSQL]

--------------------

# ※ OPEN FOR \[USING\] 语句 ※ #

--------------------

目的:

和ref cursor配合使用, 可以将游标变量分配给不同的SQL (而不是在declare中把游标给定死), 增加处理游标的灵活性

语法：

declare

type type\_cursor  is ref cursor \[return 记录类型\];  --使用 ref cursor 才能把游标分配给不同的SQL,return不能用在动态SQL中

v\_cursor type\_cursor ;

begin

OPEN v\_cursor FOR select first\_name, last\_name from student;

OPEN v\_cursor FOR **' **select first\_name,last\_name  from student where zip = :1 **'**

USING 绑定变量1;

<table> 
 <tbody> 
  <tr> 
   <td style="vertical-align:middle;">open</td> 
   <td style="vertical-align:middle;">静态SQL</td> 
   <td style="vertical-align:middle;">cursor</td> 
   <td style="vertical-align:middle;">cursor c1 is &lt;静态SQL文本&gt;<br> open c1; fetch ... into ... ; close c1;</td> 
  </tr> 
  <tr> 
   <td>open for&nbsp; &nbsp;&nbsp;</td> 
   <td>静态SQL&nbsp; &nbsp;&nbsp;</td> 
   <td colspan="1">ref cursor</td> 
   <td>type t_1 is ref cursor;<br> c2&nbsp;&nbsp;t_1&nbsp;;<br><strong>open&nbsp;c2&nbsp;for&nbsp;&lt;静态SQL语句&gt;;</strong></td> 
  </tr> 
  <tr> 
   <td style="vertical-align:middle;">open for&nbsp;using</td> 
   <td style="vertical-align:middle;">动态SQL</td> 
   <td style="vertical-align:middle;">type t_1 is ref cursor;<br> c2&nbsp;&nbsp;t_1&nbsp;;<br><strong>open&nbsp;c2&nbsp;for&nbsp;&lt;动态SQL语句&gt;&nbsp;using&nbsp;... ;</strong></td> 
  </tr> 
 </tbody> 
</table>

例子1:

declare

type student\_cur\_type is ref CURSOR RETURN test\_stu%ROWTYPE;  --声明ref cursor类型, return类型固定

v\_first\_name test\_stu.first\_name%TYPE;

v\_last\_name test\_stu.last\_name%TYPE;

cur\_stud student\_cur\_type;

begin

open cur\_stud for select first\_name,last\_name from student ;  --带return的ref cursor只能用在静态sql中

loop

fetch cur\_stud into v\_first\_name, v\_last\_name;

exit when cur\_stud%NOTFOUND;

dbms\_output.put\_line(v\_first\_name || ' ' || v\_last\_name);

end loop;

close cur\_stud;

end;

例子2:

declare

v\_zip        varchar2(5) := '&sv\_zip';

v\_first\_name varchar2(25);

v\_last\_name  varchar2(25);

type student\_cur\_type is ref cursor;  *--声明ref cursor类型*

student\_cur student\_cur\_type;  *--student\_cur是游标变量 / student\_cur\_type 是引用游标类型*

begin

*--2打开游标变量，让它指向一个动态select查询的结果集 ; 就是使用open for语句代替一般的open语句代开游标*

open student\_cur for 'select first\_name,last\_name ' from student where zip = :1'

using v\_zip;

loop

fetch student\_cur into v\_first\_name, v\_last\_name;

exit when student\_cur%NOTFOUND;

dbms\_output.put\_line(v\_first\_name || ' ' || v\_last\_name);

end loop;

close student\_cur;

end;

[https://blog.csdn.net/crzzyracing/article/details/75336196][https_blog.csdn.net_crzzyracing_article_details_75336196]

--------------------

#  #

# 动态SQL中使用Open for语句 #

2017年09月06日 19:35:55 [keven2840][] 阅读数：3199 标签： [动态sql][sql][open for][][多行动态查询][Link 2] 更多

个人分类： [Oracle之SQL和PLSQL][Oracle_SQL_PLSQL]

Open for本是为了支持游标变量，现在用它实现多行动态查询。OPEN FOR的语法如下：

OPEN\{cursor\_variable | :host\_cursor\_viable\}FOR SQL\_string

\[USING bind\_argument \[, bind\_argument\]…\];

解释：

Cursor\_variable是一种弱类型的游标变量。

:host\_cursor\_variable是在PL/SQL宿主环境下声明的游标变量，如Oracle调用接口程序。

SQL\_string包含动态执行的SELECT语句。

USING子句与EXECUTE IMMEDIATE语句遵循相同的规则。

使用OPEN FOR语句打开动态查询的例子：

PROCEDURE show\_parts\_inventory(

parts\_table IN VARCHAR2, where\_in IN VARCHAR2)

TYPE query\_curtype IS REF CURSOR;

dyncur query\_curtype;

BEGIN

OPEN dyncur FOR

'SELECT \* FROM' || parts\_table || 'WHERE' || where\_in;

。。。

执行OPEN FOR语句时，PL/SQL运行引擎操作如下：

1、  将游标变量与在查询字符串找到的查询相关联。

2、  对绑定参数求值，并用这些值替换查询字符串内的占位符。

3、  执行查询。

4、  识别结果集。

5、  将游标放在结果集第一行。

6、  把由%ROWCOUNT返回的行计数值归零。

注意，查询中任何绑定参数（由USING子句提供），仅当游标变量打开时才能求值。这意味着如果我们想对相同的动态查询使用不同的绑定参数值，

就必须使用该参数再执行一次OPEN FOR语句。

执行多行查询需遵循以下步骤：

1、  声明一个REFCURSOR类型（或使用Oracle定义的SYS\_REFCURSOR弱CURSOR类型）。

2、  基于这个REF CURSOR类型声明一个游标变量。

3、  用这个游标变量打开查询字符串。

4、  使用FETCH语句提供查询确认的一行或多行结果集。

5、  必要时检查游标属性（%FOUND、%NOTFOUND、%ROWCOUNT、%ISOPEN）。

6、  使用标准CLOSE语句关闭游标变量。

/\*显示任何一个表中由WHERE子句所选出的行的指定列的内容（对数字、日期和字符串列有效）\*/

/\*参数说明：tab:表名、col：列名、whr：条件\*/

PROCEDURE showcol(tab IN VARCHAR2,

col IN Varchar2,

whr IN VARCHAR2:=NULL)

cv SYS\_REFCURSOR;

val VARCHAR2(32767);

BEGIN

OPEN cv FOR

\--注意字符串之间的空格

'SELECT ' || col ||

' FROM ' || tab ||

' WHERE ' || NVL(whr, '1 = 1');

LOOP

--取cv的值给val,如果找不到就退出，和显示游标相同

FETCH cv INTO val;

EXIT WHEN cv%NOTFOUND;

--如果取到第一行，显示头部的信息

IFcv%ROWCOUNT = 1

THEN

Dbms\_Output.put\_line(RPAD('\_',60,'\_'));

Dbms\_Output.put\_line(

'Contents of ' || UPPER(tab)|| '.' || UPPER(col));

Dbms\_Output.put\_line(RPAD('\_',60,'\_'));

END IF;

Dbms\_Output.put\_line(val);

END LOOP;

--记得关闭游标

CLOSE cv;

END;

/\*升级版showcol程序，显示带有一个时间列，并且时间列在一定范围数值内的所有列的信息\*/

PROCEDURE showcol(tab VARCHAR2,

col VARCHAR2,

dtcol VARCHAR2,

dt1 DATE,

dt2 DATE := NULL)

cvSYS\_REFCURSOR;

val VARCHAR2(32767);

BEGIN

OPEN cv FOR

--注意空格

'SELECT ' || col ||

' FROM ' || tab ||

' WHERE ' || dtcol ||

' BETWEEN TRUNC (:startdt) AND TRUNC (:enddt)'

USING dt1, NVL (dt2, dt1+1);

LOOP

--取cv的值给val,如果找不到就退出

FETCH cv INTO val;

EXIT WHEN cv%NOTFOUND;

--如果取到第一行，显示信息

IF cv%ROWCOUNT = 1

THEN

Dbms\_Output.put\_line(

'Contents of ' || UPPER(tab)|| '.' || UPPER(col) ||

' for ' || UPPER(dtcol) ||

' between ' || dt1 || ' AND' || NVL (dt2, dt1+1));

END IF;

Dbms\_Output.put\_line(val);

ENDLOOP;

CLOSE cv;

END;

[https://blog.csdn.net/keven2840/article/details/77870465/][https_blog.csdn.net_keven2840_article_details_77870465]

# [oracle中游标与动态绑定变量][oracle 1] #

**一、      ****游标：**

用数据库语言来描述：游标是映射在结果集中一行数据上的位置实体，有了游标用户就可以访问结果集中的任意一行数据了，将游标放置到某行后，即可对该行数据进行操作，例如提取当前行的数据等等。

在Oracle9i之前，使用FETCH语句每次只能提取一行数据；从Oracle9i开始，通过使用FETCH…BULK COLLECT INTO语句，每次可以提取多行数据。语法如下：

(1) FETCH cursor\_name INTO variable1,variable2,…；

此方法必须要使用循环语句处理结果集的所有数据。

(2) FETCH cursor\_name BULK COLLECT INTO collect1,collect2,…\[LIMIT rows\]

\[LIMIT rows\]可用来限制每次游标每次提取的行数。

**游标的分类：** 显式游标和隐式游标

**显示游标的使用：**

1.  声明游标

CURSOR mycur(vartype number) is

select emp\_no,emp\_zc from cus\_emp\_basic

where com\_no = vartype;

1.  打开游标

open mycur(000627) 注：000627:参数

1.  读取数据

fetch mycur into varno,varprice;

1.  关闭游标

close mycur;

**游标的属性**

oracle游标有4个属性： %ISOPEN 、%FOUND 、%NOTFOUND、%ROWCOUNT

*  %ISOPEN 判断游标是否被打开，如果打开%ISOPEN 等于true,否则等于false
 *  %FOUND %NOTFOUND 判断游标所在的行是否有效，如果有效，则%FOUNDD等于true，否则等于false
 *  %ROWCOUNT 返回当前位置为止游标读取的记录行数。

**二、      ****动态绑定变量**

动态绑定变量解决Oracle应用程序可伸缩性的一个关键环节;而Oracle的共享池就决定了开发人员必须使用绑定变量；如果想要Oracle 运行减慢,甚至完全终止，那就可以不用绑定变量。

这里举例说明上述问题;

为了查询一个员工代号是123,你可以这样查询:

select \* from emp where empno=’123’;

你也可以这样查询:

select \* from emp where empno=:empno;

象我们往常一样,你查询员工’123’一次以后,有可能再也不用;接着你有可能查询员工’456’,然后查询’789’等等;如果查询使用象第一个查询语句,你每次查询都是一个新的查询(我们叫它硬编码的查询方法);因此,Oracle每次必须分析,解析,安全检查, 优化等等;

第二个查询语句提供了绑定变量:empno,它的值在查询执行时提供,查询经过一次编译后,查询方案存储在共享池中,可以用来检索和重用;在性能和伸缩性方面,这两者的差异是巨大的,甚至是惊人的;通俗点讲,就不是一个级别;

第一个查询使用的频率越高,所消耗的系统硬件资源越大,从而降低了用户的使用数量;它也会把优化好的其它查询语句从共享池中踢出;就象一个老鼠坏了一锅汤似的,系统的整体性能降低; 而执行绑定变量,提交相同对象的完全相同的查询的用户(这句话,大家听起来比较难理解,随后我会给出详细的解释),一次性使用就可重复使用,其效率不言耳语; 打个形象的比喻来说,第一个查询就象一次性使用的筷子,而第二个查询象是铁筷子,只要洗干净,张三李四都能用,合理有效地使用了资源

**动态绑定与静态对比：**

DECLARE

v\_sql VARCHAR2(500);

BEGIN

\--不使用绑定变量

/\*FOR i IN 1..50000 LOOP

v\_sql :='insert into t\_temp values('||i||')';

EXECUTE IMMEDIATE v\_sql;

END LOOP;\*/

\--使用绑定变量增加数据

FOR i IN 1..50000 LOOP

v\_sql :='insert into t\_temp values(:a)';

EXECUTE IMMEDIATE v\_sql USING i;

END LOOP;

END;

\--TRUNCATE TABLE t\_temp;

**动态查询****sql****举例：**

\--查询的动态sql

DECLARE

V\_SQL    VARCHAR2(100);

V\_CURSOR SYS\_REFCURSOR;

V\_EMP    EMP%ROWTYPE;

BEGIN

V\_SQL := 'select \* from emp &条件';

OPEN V\_CURSOR FOR V\_SQL;

LOOP

FETCH V\_CURSOR INTO V\_EMP;

EXIT WHEN V\_CURSOR%NOTFOUND;

DBMS\_OUTPUT.PUT\_LINE(V\_EMP.ENAME);

END LOOP;

CLOSE V\_CURSOR;

END;

[https://www.cnblogs.com/leafde/p/3830505.html][oracle 1]

# Oracle动态游标入门一 #

2008年01月12日 09:50:00 [xjzdr][] 阅读数：18038

## ##

说明：下面的存储过程在Oracle817下全部通过测试，编译和运行均是正确的

一、最简单的一个动态游标：  
CREATE OR REPLACE PROCEDURE test\_cur  
is  
strSql1 varchar(1000);  
TYPE TCUR IS REF CURSOR;   
CUR TCUR;  
AC\_WHERE VARCHAR2(100);  
AC VARCHAR2(100);   
BEGIN  
AC\_WHERE := '(52228,52230)';  
OPEN CUR FOR 'SELECT bill\_id FROM bill\_main WHERE bill\_id IN '|| AC\_WHERE;  
LOOP  
FETCH CUR INTO AC;  
EXIT WHEN CUR%NOTFOUND;

DBMS\_OUTPUT.PUT\_LINE(AC);

END LOOP;  
CLOSE CUR;  
end test\_cur;

二、动态游标中使用动态的SQL语句并执行：  
CREATE OR REPLACE PROCEDURE test\_cur  
(  
p\_orgid\_wins string  
)  
is  
strSql1 varchar2(1000);  
TYPE My\_CurType IS REF CURSOR;   
CUR\_1 My\_CurType;--指示CUR\_1的类型为My\_CurType，而My\_CurType是游标类型  
AC\_WHERE VARCHAR2(100);  
AC VARCHAR2(100);   
BEGIN  
AC\_WHERE := '(52228,52230)';  
OPEN CUR\_1 FOR 'SELECT bill\_id FROM bill\_main WHERE bill\_id IN '|| AC\_WHERE;--打开动态游标  
LOOP  
FETCH CUR\_1 INTO AC;  
EXIT WHEN CUR\_1%NOTFOUND;  
strSql1:='delete bill\_main where bill\_id='||AC;  
DBMS\_OUTPUT.PUT\_LINE(strSql1);  
DBMS\_OUTPUT.PUT\_LINE(AC);  
execute immediate strSql1;--执行一个动态的SQL语句  
commit;  
END LOOP;  
CLOSE CUR\_1;  
end test\_cur;

三、动态游标中执行动态DQL语句：  
CREATE OR REPLACE PROCEDURE test\_cur  
(  
p\_orgid\_wins string  
)  
is  
strSql1 varchar2(1000);

strSql2 varchar2(1000);  
TYPE My\_CurType IS REF CURSOR;   
CUR\_1 My\_CurType;--指示CUR\_1的类型为My\_CurType，而My\_CurType是游标类型  
AC\_WHERE VARCHAR2(100);  
t\_to\_orgid number;  
t\_bill\_id number;   
BEGIN  
AC\_WHERE := '(98978,98980)';  
strSql1:='SELECT bill\_id,to\_orgid FROM bill\_main WHERE bill\_id IN '|| AC\_WHERE;  
DBMS\_OUTPUT.PUT\_LINE(strSql1);  
OPEN CUR\_1 FOR strSql1;--打开动态游标  
LOOP  
FETCH CUR\_1 INTO t\_bill\_id,t\_to\_orgid;  
EXIT WHEN CUR\_1%NOTFOUND;  
DBMS\_OUTPUT.PUT\_LINE('t\_to\_orgid='||t\_to\_orgid);

strSql2:='delete bill\_main where bill\_id='||t\_bill\_id;

strSql2:=strSql2|| 'and start\_no='||'16506';  
DBMS\_OUTPUT.PUT\_LINE(strSql2);  
DBMS\_OUTPUT.PUT\_LINE(t\_bill\_id);  
execute immediate strSql1;--执行一个动态的SQL语句  
commit;  
END LOOP;  
CLOSE CUR\_1;  
end test\_cur;

[https://blog.csdn.net/xjzdr/article/details/2038904?utm\_source=blogxgwz8][https_blog.csdn.net_xjzdr_article_details_2038904_utm_source_blogxgwz8]

# [在Oracle中执行动态SQL的几种方法][Oracle_SQL] #

在[Oracle][]中执行动态SQL的几种方法

在一般的sql操作中，sql语句基本上都是固定的，如：  
SELECT t.empno,t.ename  FROM scott.emp t WHERE t.deptno = 20;  
但有的时候，从应用的需要或程序的编写出发，都可能需要用到动态SQl，如：  
当 from 后的表 不确定时，或者where 后的条件不确定时，都需要用到动态SQL。

一、使用动态游标实现  
1、声明动态游标  
TYPE i\_cursor\_type IS REF CURSOR;  
2、声明游标变量  
my\_cursor i\_cursor\_type;  
3、使用游标  
n\_deptno:=20;  
dyn\_select := 'select empno,ename from emp where deptno='||n\_deptno;  
OPEN my\_cursor FOR dyn\_select;  
LOOP   
  FETCH my\_cursor INTO n\_empno,v\_ename;  
  EXIT WHEN my\_cursor%NOTFOUND;  
  --用n\_empno,v\_ename做其它处理  
  --....  
END LOOP;  
CLOSE dl\_cursor;  
4、小结：动态游标可以胜任大多数动态SQL的需求了，使用简洁方便居家旅行之必备杀人放火之法宝。

二、使用 EXECUTE IMMEDIATE  
最早大家都使用DBMS\_SQL包，但是太太麻烦了，最终都放弃了。但是自从有了EXECUTE IMMEDIATE之后，但要注意以下几点：  
EXECUTE IMMEDIATE代替了以前Oracle8i中DBMS\_SQL package包.它解析并马上执行动态的SQL语句或非运行时创建的PL/SQL块.动态创建和执行SQL语句性能超前，EXECUTE IMMEDIATE的目标在于减小企业费用并获得较高的性能，较之以前它相当容易编码.尽管DBMS\_SQL仍然可用，但是推荐使用EXECUTE IMMEDIATE,因为它获的收益在包之上。   
 使用技巧

1. EXECUTE IMMEDIATE将不会提交一个DML事务执行，应该显式提交  
 如果通过EXECUTE IMMEDIATE处理DML命令，那么在完成以前需要显式提交或者作为EXECUTE IMMEDIATE自己的一部分. 如果通过EXECUTE IMMEDIATE处理DDL命令,它提交所有以前改变的数据

2. 不支持返回多行的查询,这种交互将用临时表来存储记录(参照例子如下)或者用REF cursors.

3. 当执行SQL语句时，不要用分号，当执行PL/SQL块时，在其尾部用分号.

4. 在Oracle手册中，未详细覆盖这些功能。下面的例子展示了所有用到Execute immediate的可能方面.希望能给你带来方便.

5. 对于Forms开发者,当在PL/SQL 8.0.6.3.版本中，Forms 6i不能使用此功能.

EXECUTE IMMEDIATE用法例子

1. 在PL/SQL运行DDL语句

begin  
  execute immediate 'set role all';  
 end;

2. 给动态语句传值(USING 子句)

declare  
  l\_depnam varchar2(20) := 'testing';  
  l\_loc    varchar2(10) := 'Dubai';  
  begin  
  execute immediate 'insert into dept values  (:1, :2, :3)'  
    using 50, l\_depnam, l\_loc;  
  commit;  
 end;

3. 从动态语句检索值(INTO子句)

declare  
  l\_cnt    varchar2(20);  
 begin  
  execute immediate 'select count(1) from emp'  
    into l\_cnt;  
  dbms\_output.put\_line(l\_cnt);  
 end;

4. 动态调用例程.例程中用到的绑定变量参数必须指定参数类型.黓认为IN类型,其它类型必须显式指定

declare  
  l\_routin   varchar2(100) := 'gen2161.get\_rowcnt';  
  l\_tblnam   varchar2(20) := 'emp';  
  l\_cnt      number;  
  l\_status   varchar2(200);  
 begin  
  execute immediate 'begin ' || l\_routin || '(:2, :3, :4); end;'  
    using in l\_tblnam, out l\_cnt, in out l\_status;

if l\_status != 'OK' then  
     dbms\_output.put\_line('error');  
  end if;  
 end;

5. 将返回值传递到PL/SQL记录类型;同样也可用%rowtype变量

declare  
    type empdtlrec is record (empno  number(4),ename  varchar2(20),deptno  number(2));  
    empdtl empdtlrec;  
 begin  
    execute immediate 'select empno, ename, deptno '||'from emp where empno = 7934'  
    into empdtl;  
 end;

6. 传递并检索值.INTO子句用在USING子句前

declare  
   l\_dept    pls\_integer := 20;  
   l\_nam     varchar2(20);  
   l\_loc     varchar2(20);  
 begin  
    execute immediate 'select dname, loc from dept where deptno = :1'  
       into l\_nam, l\_loc  
       using l\_dept ;  
 end;

7. 多行查询选项.对此选项用insert语句填充临时表，用临时表进行进一步的处理,也可以用REF cursors纠正此缺憾.  
   
 declare  
  l\_sal   pls\_integer := 2000;  
 begin  
  execute immediate 'insert into temp(empno, ename) ' ||  
                   '          select empno, ename from emp ' ||  
                   '          where  sal > :1'  
    using l\_sal;  
  commit;  
 end;

对于处理动态语句,EXECUTE IMMEDIATE比以前可能用到的更容易并且更高效.当意图执行动态语句时，适当地处理异常更加重要.应该关注于捕获所有可能的异常.

## ##

### [ORACLE 动态执行SQL语句][ORACLE _SQL] ###

**博客分类：**

*   
 *  [Oracle][Oracle 1]

[SQL][][Oracle][Oracle 2][C][][C++][C 1][C\#][C 2]

Oracle 动态SQL  
Oracle 动态SQL有两种写法：用 DBMS\_SQL 或 execute immediate，建议使用后者。试验步骤如下：  
  
  
1. DDL 和 DML

Sql代码  ![收藏代码][icon_star.png]

1.  /\*\*\* DDL \*\*\*/  
2.  begin  
3.      EXECUTE IMMEDIATE 'drop table temp\_1';  
4.      EXECUTE IMMEDIATE 'create table temp\_1(name varchar2(8))';  
5.  end;  
6.    
7.  /\*\*\* DML \*\*\*/  
8.  declare  
9.      v\_1 varchar2(8);  
10.     v\_2 varchar2(10);  
11.     str varchar2(50);  
12. begin  
13.     v\_1:='测试人员';  
14.     v\_2:='北京';  
15.     str := 'INSERT INTO test (name ,address) VALUES (:1, :2)';  
16.     EXECUTE IMMEDIATE str USING v\_1, v\_2;  
17.     commit;  
18. end;

2. 返回单条结果

Sql代码  ![收藏代码][icon_star.png]

1.  declare  
2.      str varchar2(500);  
3.      c\_1 varchar2(10);  
4.      r\_1 test%rowtype;  
5.  begin  
6.      c\_1:='测试人员';  
7.      str:='select \* from test where name=:c WHERE ROWNUM=1';  
8.      execute immediate str into r\_1 using c\_1;  
9.      DBMS\_OUTPUT.PUT\_LINE(R\_1.NAME||R\_1.ADDRESS);  
10. end ;

3. 返回结果集

Sql代码  ![收藏代码][icon_star.png]

1.  CREATE OR REPLACE package pkg\_test as  
2.      /\* 定义ref cursor类型  
3.      不加return类型，为弱类型，允许动态sql查询，  
4.      否则为强类型，无法使用动态sql查询;  
5.      \*/  
6.      type myrctype is ref cursor;  
7.    
8.      --函数申明  
9.      function get(intID number) return myrctype;  
10. end pkg\_test;  
11. /  
12.   
13. CREATE OR REPLACE package body pkg\_test as  
14. \--函数体  
15.     function get(intID number) return myrctype is  
16.         rc myrctype; --定义ref cursor变量  
17.         sqlstr varchar2(500);  
18.     begin  
19.         if intID=0 then  
20.             --静态测试，直接用select语句直接返回结果  
21.             open rc for select id,name,sex,address,postcode,birthday from  
22. student;  
23.         else  
24.             --动态sql赋值，用:w\_id来申明该变量从外部获得  
25.             sqlstr := 'select id,name,sex,address,postcode,birthday from student  
26. where id=:w\_id';  
27.             --动态测试，用sqlstr字符串返回结果，用using关键词传递参数  
28.             open rc for sqlstr using intid;  
29.         end if;  
30.   
31.         return rc;  
32.     end get;  
33.   
34. end pkg\_test;  
35. /

### [sql server 自定义函数的使用][sql server] ###

自定义函数

用户定义自定义函数像内置函数一样返回标量值，也可以将结果集用表格变量返回

用户自定义函数的类型:

标量函数:返回一个标量值

表格值函数\{内联表格值函数、多表格值函数\}:返回行集（即返回多个值）

1、标量函数

Create function 函数名（参数）

Returns 返回值数据类型

\[with \{Encryption | Schemabinding \}\]

\[as\]

begin

SQL语句(必须有return 变量或值)

End

Schemabinding :将函数绑定到它引用的对象上（注：函数一旦绑定，则不能删除、修改，除非删除绑定）

Create function AvgResult(@scode varchar(10))

Returns real

Begin

Declare @avg real

Declare @code varchar(11)

Set @code=@scode + ‘%’

Select @avg=avg(result) from LearnResult\_baijiali

Where scode like @code

Return @avg

End

执行用户自定义函数

select 用户名。函数名 as 字段别名

select dbo.AvgResult(‘s0002’) as result

用户自定义函数返回值可放到局部变量中，用set ,select,exec赋值

declare @avg1 real ,@avg2 real ,@avg3 real

select @avg1= dbo.AvgResult(‘s0002’)

set @avg2= dbo.AvgResult(‘s0002’)

exec @avg3= dbo.AvgResult ‘s0002’

select @avg1 as avg1 ,@avg2 as avg2 ,@avg3 as avg3

函数引用

create function code(@scode varchar(10))

returns varchar(10)

begin

declare @ccode varchar(10)

set @scode = @scode + ‘%’

select @ccode=ccode from cmessage

where ccode like @scode

return @ccode

end

select name from class where ccode = dbo.code(‘c001’)

2、表格值函数

a、 内联表格值函数

格式：

create function 函数名（参数）

returns table

\[with \{Encryption | Schemabinding \}\]

return(一条SQL语句)

create function tabcmess(@code varchar(10))

returns table

return(select ccode,scode from cmessage where ccode like @ccode)

b、 多句表格值函数

create function 函数名（参数）

returns 表格变量名table (表格变量定义)

\[with \{Encryption | Schemabinding \}\]

begin

SQL语句

end

多句表格值函数包含多条SQL语句，至少有一条在表格变量中填上数据值

表格变量格式

returns @变量名 table (column 定义| 约束定义 \[,…\])

对表格变量中的行可执行select,insert,update,delete ， 但select into 和 insert 语句的结果集是从存储过程插入。

Create function tabcmessalot (@code varchar(10))

Returns @ctable table(code varchar(10) null,cname varchar(100) null)

Begin

Insert @ctable

Select ccode,explain from cmessage

Where scode like @code

return

End

Select \* from tabcmessalot(‘s0003’)

[https://www.cnblogs.com/hanruyue/p/5974036.html][Oracle_SQL]

[Link 1]: https://me.csdn.net/crzzyracing
[oracle]: http://so.csdn.net/so/search/s.do?q=oracle&t=blog
[SQLPLSQL]: http://so.csdn.net/so/search/s.do?q=SQLPLSQL&t=blog
[ORACLE]: https://blog.csdn.net/crzzyracing/article/category/6695193
[SQL_PLSQL]: https://blog.csdn.net/crzzyracing/article/category/6787379
[https_blog.csdn.net_crzzyracing_article_details_75336196]: https://blog.csdn.net/crzzyracing/article/details/75336196
[keven2840]: https://me.csdn.net/keven2840
[sql]: http://so.csdn.net/so/search/s.do?q=%E5%8A%A8%E6%80%81sql&t=blog
[open for]: http://so.csdn.net/so/search/s.do?q=open%20for&t=blog
[Link 2]: http://so.csdn.net/so/search/s.do?q=%E5%A4%9A%E8%A1%8C%E5%8A%A8%E6%80%81%E6%9F%A5%E8%AF%A2&t=blog
[Oracle_SQL_PLSQL]: https://blog.csdn.net/keven2840/article/category/7148331
[https_blog.csdn.net_keven2840_article_details_77870465]: https://blog.csdn.net/keven2840/article/details/77870465/
[oracle 1]: https://www.cnblogs.com/leafde/p/3830505.html
[xjzdr]: https://me.csdn.net/xjzdr
[https_blog.csdn.net_xjzdr_article_details_2038904_utm_source_blogxgwz8]: https://blog.csdn.net/xjzdr/article/details/2038904?utm_source=blogxgwz8
[Oracle_SQL]: https://www.cnblogs.com/hanruyue/p/5974036.html
[Oracle]: http://lib.csdn.net/base/oracle
[ORACLE _SQL]: http://zhaisx.iteye.com/blog/856472
[Oracle 1]: http://zhaisx.iteye.com/category/62787
[SQL]: http://www.iteye.com/blogs/tag/SQL
[Oracle 2]: http://www.iteye.com/blogs/tag/Oracle
[C]: http://www.iteye.com/blogs/tag/C
[C 1]: http://www.iteye.com/blogs/tag/C++
[C 2]: http://www.iteye.com/blogs/tag/C%23
[icon_star.png]: /images/20220406/ecf66690ce084201b02e0c488dc4f4ff.png
[sql server]: http://www.cnblogs.com/diony/archive/2010/12/17/1909014.html