存储过程使用变量指针
㈠ Perl 如何处理 返回多个游标的DB2存储过程
一个游标(cursor)可以被看作指向结果集(a set of rows)中一行的指针(pointer)。游标每个时间点只能指向一行，但是可以根据需要指向结果集中其他的行。
例如：SELECT * FROM employees WHERE sex='M'会返回所有性别为男的雇员，在初始的时候，游标被放置在结果集中第一行的前面。使游标指向第一行，要执行FETCH。当游标指向结果集中一行的时候，可以对这行数据进行加工处理，要想得到下一行数据，要继续执行FETCH。FETCH操作可以重复执行，直到完成结果集中的所有行
在存储过程中使用游标，有如下几个步骤：
声明游标、打开游标、根据需要一次一行，讲游标指向的数据取到本地变量(local variables)中、结束时关闭游标
声明游标：
>>-DECLARE--cursor-name--CURSOR----+------------+--------->
'-WITH HOLD--'
>-----+--------------------------------+--------------------->
| .-TO CALLER--. |
'-WITH RETURN--+------------+--'
'-TO CLIENT--'
>----FOR--+-select-statement-+----------------------------><
'-statement-name---'
WITH RETURN子句用于将游标所定义的结果集传递给另一个存储过程或者应用(an application)
如果select语句中包含CURRENT DATE, CURRENT TIME和CURRENT TIMESTAMP，所有的FETCH语句都会返回相同的日期、时间、时间戳值，因为这些特定寄存器是在打开游标(OPEN CURSOR)的时候进行检查的
㈡ 修改sql Server2000中NTEXT的问题
text,ntext,image类型的字段操作有点特殊
WRITETEXT
允许对现有的
text、ntext
或
image
列进行无日志记录的交互式更新。该语句将彻底重写受其影响的列中的任何现有数据。WRITETEXT
语句不能用在视图中的
text、ntext
和
image
列上。
UPDATETEXT
更新现有
text、ntext
或
image
字段。使用
UPDATETEXT
在适当的位置更改
text、ntext
或
image
列的一部分。使用
WRITETEXT
来更新和替换整个
text、ntext
或
image
字段。
你看看这个例子修改下你的存储过程吧
示例
本示例把文本指针置于局部变量
@ptrval
中，然后使用
UPDATETEXT
更新拼写错误。
USE
pubs
GO
EXEC
sp_dboption
'pubs',
'select
into/bulk',
'true'
GO
DECLARE
@ptrval
binary(16)
SELECT
@ptrval
=
TEXTPTR(pr_info)
FROM
pub_info
pr,
publishers
p
WHERE
p.pub_id
=
pr.pub_id
AND
p.pub_name
=
'New
Moon
Books'
UPDATETEXT
pub_info.pr_info
@ptrval
88
1
'b'
GO
EXEC
sp_dboption
'pubs',
'select
into/bulk',
'false'
GO
返回特定文本数据
下例在
pubs
数据库的
pub_info
表中查找与
pub_id
0736
相关联的
text
列
(pr_info)。下例首先声明一个局部变量
@val。然后将文本指针(长二进制字符串)置于
@val
中，并将其作为参数提供给
READTEXT
语句，该语句将返回从第五个字节(偏移量为
4)开始的
10
个字节。
USE
pubs
GO
DECLARE
@val
varbinary(16)
SELECT
@val
=
TEXTPTR(pr_info)
FROM
pub_info
WHERE
pub_id
=
'0736'
READTEXT
pub_info.pr_info
@val
4
10
GO
㈢ 如何用java调用存储过程
已储存过程储存在数据库中。对已储存过程的调用是 CallableStatement对象所含的内容。这种调用是用一种换码语法来写的，有两种形式：一种形式带结果参，另一种形式不带结果参数。结果参数是一种输出 (OUT) 参数，是已储存过程的返回值。两种形式都可带有数量可变的输入（IN 参数）、输出（OUT 参数）或输入和输出（INOUT 参数）的参数。问号将用作参数的占位符。 在JDBC 中调用已储存过程的语法如下所示。注意，方括号表示其间的内容是可选项；方括号本身并不是语法的组成部份。{call 过程名[(?, ?, ...)]} 返回结果参数的过程的语法为：{? = call 过程名[(?, ?, ...)]} 不带参数的已储存过程的语法类似：{call 过程名} 通常，创建 CallableStatement 对象的人应当知道所用的 DBMS 是支持已储存过程的，并且知道这些过程都是些什么。然而，如果需要检查，多种DatabaseMetaData 方法都可以提供这样的信息。例如，如果 DBMS 支持已储存过程的调用，则supportsStoredProceres 方法将返回 true，而getProceres 方法将返回对已储存过程的描述。CallableStatement 继承 Statement 的方法（它们用于处理一般的 SQL 语句），还继承了 PreparedStatement 的方法（它们用于处理 IN 参）。 CallableStatement 中定义的所有方法都用于处理 OUT 参数或 INOUT 参数的输出部分：注册 OUT 参数的 JDBC 类型（一般 SQL 类型）、从这些参数中检索结果，或者检查所返回的值是否为 JDBC NULL。 1、创建 CallableStatement 对象 CallableStatement 对象是用 Connection 方法 prepareCall 创建的。下例创建 CallableStatement 的实例，其中含有对已储存过程 getTestData 调用。该过程有两个变量，但不含结果参数：CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}"); 其中?占位符为IN、OUT还是INOUT参数，取决于已储存过程getTestData。 2、IN和OUT参数 将IN参数传给 CallableStatement 对象是通过 setXXX 方法完成的。该方法继承自 PreparedStatement。所传入参数的类型决定了所用的setXXX方法（例如，用 setFloat 来传入 float 值等）。 如果已储存过程返回 OUT 参数，则在执行 CallableStatement 对象以前必须先注册每个 OUT 参数的 JDBC 类型（这是必需的，因为某些 DBMS 要求 JDBC 类型）。注册 JDBC 类型是用 registerOutParameter 方法来完成的。语句执行完后，CallableStatement 的 getXXX 方法将取回参数值。正确的 getXXX 方法是为各参数所注册的 JDBC 类型所对应的 Java 类型。换言之， registerOutParameter 使用的是 JDBC 类型（因此它与数据库返回的 JDBC 类型匹配），而 getXXX 将之转换为 Java 类型。 作为示例，下述代码先注册 OUT 参数，执行由 cstmt 所调用的已储存过程，然后检索在 OUT 参数中返回的值。方法 getByte 从第一个 OUT 参数中取出一个 Java 字节，而 getBigDecimal 从第二个 OUT 参数中取出一个 BigDecimal 对象（小数点后面带三位数）：CallableStatement cstmt = con.prepareCall("{call getTestData(?, ?)}");
cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.registerOutParameter(2, java.sql.Types.DECIMAL, 3);
cstmt.executeQuery();
byte x = cstmt.getByte(1);
java.math.BigDecimal n = cstmt.getBigDecimal(2, 3); CallableStatement 与 ResultSet 不同，它不提供用增量方式检索大 OUT 值的特殊机制。3、INOUT参数 既支持输入又接受输出的参数（INOUT 参数）除了调用 registerOutParameter 方法外，还要求调用适当的 setXXX 方法（该方法是从 PreparedStatement 继承来的）。setXXX 方法将参数值设置为输入参数，而 registerOutParameter 方法将它的 JDBC 类型注册为输出参数。setXXX 方法提供一个 Java 值，而驱动程序先把这个值转换为 JDBC 值，然后将它送到数据库中。这种 IN 值的 JDBC 类型和提供给 registerOutParameter 方法的 JDBC 类型应该相同。然后，要检索输出值，就要用对应的 getXXX 方法。例如，Java 类型为byte 的参数应该使用方法 setByte 来赋输入值。应该给registerOutParameter 提供类型为 TINYINT 的 JDBC 类型，同时应使用 getByte 来检索输出值。 下例假设有一个已储存过程 reviseTotal，其唯一参数是 INOUT 参数。方法setByte 把此参数设为 25，驱动程序将把它作为 JDBC TINYINT 类型送到数据库中。接着，registerOutParameter 将该参数注册为 JDBC TINYINT。执行完该已储存过程后，将返回一个新的 JDBC TINYINT 值。方法 getByte 将把这个新值作为 Java byte 类型检索。CallableStatement cstmt = con.prepareCall("{call reviseTotal(?)}");
cstmt.setByte(1, 25);
cstmt.registerOutParameter(1, java.sql.Types.TINYINT);
cstmt.executeUpdate();
byte x = cstmt.getByte(1); 4、先检索结果，再检索 OUT 参数 由于某些 DBMS 的限制，为了实现最大的可移植性，建议先检索由执行CallableStatement 对象所产生的结果，然后再用 CallableStatement.getXXX 方法来检索 OUT 参数。如果 CallableStatement 对象返回多个 ResultSet 对象（通过调用 execute 方法），在检索 OUT 参数前应先检索所有的结果。这种情况下，为确保对所有的结果都进行了访问，必须对 Statement 方法 getResultSet、getUpdateCount 和getMoreResults 进行调用，直到不再有结果为止。 检索完所有的结果后，就可用 CallableStatement.getXXX 方法来检索 OUT 参数中的值。 5、检索作为OUT参数的NULL值 返回到 OUT 参数中的值可能会是JDBC NULL。当出现这种情形时，将对 JDBC NULL 值进行转换以使 getXXX 方法所返回的值为 null、0 或 false，这取决于getXXX 方法类型。对于 ResultSet 对象，要知道0或false是否源于JDBCNULL的唯一方法，是用方法wasNull进行检测。如果 getXXX 方法读取的最后一个值是 JDBC NULL，则该方法返回 true，否则返回 flase。
复杂的返回值 关于存储过程的知识，很多人好像就熟悉我们所讨论的这些。如果这是存储过程的全部功能，那么存储过程就不是其它远程执行机制的替换方案了。存储过程的功能比这强大得多。
某些DBMS允许从存储过程中返回游标的一个引用。JDBC并不支持这个功能，但是Oracle、PostgreSQL和DB2的JDBC驱动器都支持在ResultSet上打开到游标的指针（pointer）。
设想列出所有没有活到退休年龄的诗人，下面是完成这个功能的存储过程，返回一个打开的游标，同样也使用PostgreSQL的pl/pgsql语言： create procere list_early_deaths () return refcursor as 'declare toesup refcursor;begin open toesup for SELECT poets.name, deaths.age FROM poets, deaths -- all entries in deaths are for poets. -- but the table might become generic. WHERE poets.id = deaths.mort_id AND deaths.age < 60; return toesup;end;' language 'plpgsql'; 下面是调用该存储过程的Java方法，将结果输出到PrintWriter：
PrintWriter: static void sendEarlyDeaths(PrintWriter out){ Connection con = null; CallableStatement toesUp = null; try { con = ConnectionPool.getConnection(); // PostgreSQL needs a transaction to do this... con. setAutoCommit(false); // Setup the call. CallableStatement toesUp = connection.prepareCall("{ ? = call list_early_deaths () }"); toesUp.registerOutParameter(1, Types.OTHER); toesUp.execute(); ResultSet rs = (ResultSet) toesUp.getObject(1); while (rs.next()) { String name = rs.getString(1); int age = rs.getInt(2); out.println(name + " was " + age + " years old."); } rs.close(); } catch (SQLException e) { // We should protect these calls. toesUp.close(); con.close(); }} 因为JDBC并不直接支持从存储过程中返回游标，我们使用Types.OTHER来指示存储过程的返回类型，然后调用getObject()方法并对返回值进行强制类型转换。
这个调用存储过程的Java方法是mapping的一个好例子。Mapping是对一个集上的操作进行抽象的方法。不是在这个过程上返回一个集，我们可以把操作传送进去执行。本例中，操作就是把ResultSet打印到一个输出流。这是一个值得举例的很常用的例子，下面是调用同一个存储过程的另外一个方法实现： public class ProcessPoetDeaths{ public abstract void sendDeath(String name, int age);} static void mapEarlyDeaths(ProcessPoetDeaths mapper){ Connection con = null; CallableStatement toesUp = null; try { con = ConnectionPool.getConnection(); con.setAutoCommit(false); CallableStatement toesUp = connection.prepareCall("{ ? = call list_early_deaths () }"); toesUp.registerOutParameter(1, Types.OTHER); toesUp.execute(); ResultSet rs = (ResultSet) toesUp.getObject(1); while (rs.next()) { String name = rs.getString(1); int age = rs.getInt(2); mapper.sendDeath(name, age); } rs.close(); } catch (SQLException e) { // We should protect these calls. toesUp.close(); con.close(); }} 这允许在ResultSet数据上执行任意的处理，而不需要改变或者复制获取ResultSet的方法： static void sendEarlyDeaths(final PrintWriter out){ ProcessPoetDeaths myMapper = new ProcessPoetDeaths() { public void sendDeath(String name, int age) { out.println(name + " was " + age + " years old."); } }; mapEarlyDeaths(myMapper);} 这个方法使用ProcessPoetDeaths的一个匿名实例调用mapEarlyDeaths。该实例拥有sendDeath方法的一个实现，和我们上面的例子一样的方式把结果写入到输出流。当然，这个技巧并不是存储过程特有的，但是和存储过程中返回的ResultSet结合使用，是一个非常强大的工具。 结论存储过程可以帮助你在代码中分离逻辑，这基本上总是有益的。这个分离的好处有：
快速创建应用，使用和应用一起改变和改善的数据库模式。
数据库模式可以在以后改变而不影响Java对象，当我们完成应用后，可以重新设计更好的模式。
存储过程通过更好的SQL嵌入使得复杂的SQL更容易理解。
编写存储过程比在Java中编写嵌入的SQL拥有更好的工具－－大部分编辑器都提供语法高亮！
存储过程可以在任何SQL命令行中测试，这使得调试更加容易。 并不是所有的数据库都支持存储过程，但是存在许多很棒的实现，包括免费/开源的和非免费的，所以移植并不是一个问题。Oracle、PostgreSQL和DB2都有类似的存储过程语言，并且有在线的社区很好地支持。
存储过程工具很多，有像TOAD或TORA这样的编辑器、调试器和IDE，提供了编写、维护PL/SQL或pl/pgsql的强大的环境。
存储过程确实增加了你的代码的开销，但是它们和大多数的应用服务器相比，开销小得多。
㈣ oracle 存储过程 如何把参数传入到指针中
DECLARE
-- step 1: declare the variables
v_proct_id procts.proct_id%TYPE;
v_name procts.name%TYPE;
v_price procts.price%TYPE;
-- step 2: declare the cursor
CURSOR cv_proct_cursor IS
SELECT proct_id, name, price
FROM procts
ORDER BY proct_id;
BEGIN
-- step 3: open the cursor
OPEN cv_proct_cursor;
LOOP
-- step 4: fetch the rows from the cursor
FETCH cv_proct_cursor
INTO v_proct_id, v_name, v_price;
-- exit the loop when there are no more rows, as indicated by
-- the Boolean variable cv_proct_cursor%NOTFOUND (= true when
-- there are no more rows)
EXIT WHEN cv_proct_cursor%NOTFOUND;
-- use DBMS_OUTPUT.PUT_LINE() to display the variables
DBMS_OUTPUT.PUT_LINE(
'v_proct_id = ' || v_proct_id || ', v_name = ' || v_name ||
', v_price = ' || v_price
);
END LOOP;
-- step 5: close the cursor
CLOSE cv_proct_cursor;
END;
这个例子比较好
㈤ c++/java/c# 几种编程语言的指针、引用比较
Java 引用可以赋值 null, 而 c++ 引用 (见 fun2) 不能赋值 null，c++ 指针可以赋值 null(fun3).Java 中，无 c++ 引用(fun2)对应的语法。 结果引起不必要的质疑，特此，写博客，对c++/java/c# 几种编程语言的指针、引用，进行比较，期望引起更多的人，对此有所关注。 从语法上看，三种开发语言中，C++ 的指针、引用，最为复杂，因此，下面的举例，都从 C++ 代码开始，然后与 java/c# 的语法进行比较。 1) C++ 简单类型变量，有直接变量定义、指针定义、引用定义。int aa = 10;//c++ int &bb = aa;//c++int *cc = &aa;//c++上述三行代码，最后三个变量指向同一个数据。相比较而言，java/c# 都只有变量定义，无引用定义、指针定义。 2) C++ 函数调用参数，简单类型变量，有直接变量定义、指针定义、引用定义，后两个，在函数内部改变数据，退出函数，能看到改变后的数据。void simple_by_val(int a, constint b){ a=15; //b=13; //error C2166: l-value specifies const object //a=NULL; //good //b=NULL; //error C2166: l-value specifies const object}void simple_by_ref(int &a, constint &b){ a=25; //b=23; //error C2166: l-value specifies const object //a=NULL; //good //b=NULL; //error C2166: l-value specifies const object}void simple_by_pointer(int *a, constint *b){ *a = 35; //*b = 33; //error C2166: l-value specifies const object a = NULL; //ok b = NULL; //ok}java 没有这么多名堂，只有直接变量定义。C# 略为复杂一点，有引用，有 out 参数。staticvoid M(int a, refint b, outint c) { c = 13; }相比较而言，C# 的函数参数( refint b), 类似于C++的函数参数( int &a)，都是调用函数前要赋初值，在函数内部改变数据，退出函数，能看到改变后的数据。而C# 的 (outint c)，在 C++/Java 中，无对应的语法。这个可以调用函数前，不赋初值。在 C# 之前，也很少见到这种语法，只在一些数据库的存储过程、函数定义中，见过类似语法。估计是从数据库编程语法中抄袭过来的语法。特别注明：C# 的引用，只是用在函数参数变量定义上，不能用在函数内部的局部变量中。C++ 中的引用，可以用在函数内部的局部变量中。 3) C++ 的类对象变量定义语法，较为复杂，可以定义在stack 上（不用 new），可以定义在 heap(用 new)。 CMyClass obj; //stack CMyClass *p2 = new CMyClass(); //heapjava/C# 中，没有这么复杂，可以认为是上述两种“综合+简化”了。 4) 在 java/C# 中，如下用法是错误的，会报空指针异常；但是在 C++ 里是合法的。 CMyClass obj; obj.run();在C++ 中，CMyClass obj;以上一行代码已经调用了构造函数，完成了变量初始化。而在 java/C# 中，这一行代码相当于： CMyClass obj = null; 5) C++ 中，stack 变量出了作用范围，内存自动回收；heap 变量，需要手工 delete。 java/C# 中，变量是空闲时自动回收的(理论上的)，不是变量出了作用范围，就内存回收。 6) 以下代码在 C++ 中是正确的，在 java/C# 是错误的。在 java/C# 语法中，没有定义变量加 * 的。CMyClass *p1 = null;CMyClass *p2 = new CMyClass(); 7) 以下代码，在java/C# 语法中，是正确的，在 C++ 是错误的。CMyClass p1 = null;CMyClass p2 = new CMyClass(); 8) 以下代码，在 C++ 代码中，会调用“拷贝构造函数”、"等于号重载函数"。这两个函数，在 C++ 中，默认会由编译器自动生成。 //C++ CMyClass obj; //调用构造函数 CMyClass obj2 = obj; //调用拷贝构造函数 obj2 = obj; //调用= 重载函数以上代码，大致相当于 java/C# 中的 克隆"clone"。但更隐蔽、更复杂。//C# CMyClass obj = new CMyClass(); CMyClass obj2 = (CMyClass)obj.Clone();而在C# 中，Clone 函数并不会自动生成。在 Java 中，可以调用 super.clone() ---- Java 基类 Object 默认有一个 clone 函数。在C++ 中，默认会由编译器自动生成“拷贝构造函数”、"等于号重载函数"，这一点，很多时候会造成问题，要特别注意。在C++ 中，函数返回值不要用 CMyClass ，这会造成不必要地调用“拷贝构造函数”、"等于号重载函数"；也不要返回引用 CMyClass&, 对函数内局部变量的引用，退出函数后无法继续使用。而要返回指针 CMyClass *。这一点很多初学者不明白。但是C++ 的 std:string 除外。std:string 的“拷贝构造函数”、"等于号重载函数"经过优化，拷贝后的变量，与拷贝之前的变量，内部使用相同的 char[] 数组，只有当一个 string 变量改变时，才会把 char[] 数组复制成两份。std:string 的“拷贝构造函数” 没有性能上损失，又比 string 指针减少了内存泄露，因此，对 std:string ，使用时尽量用 对象变量、对象引用、对象拷贝构造，避免使用 std:string 指针。 9) C++ 引用语法，有一些是 Java/C# 程序员不知道的语法//C++CMyClass &a1; //错误，C++ 引用变量定义的时候就要初始化;//Java/C# 对象变量，没有要求，变量定义的时候就要初始化CMyClass &a1 = NULL; //错误，C++ 引用变量不能赋值 nullCMyClass &a1 = new CMyClass(); //错误，C++ 引用变量不能赋值给一个 new 对象，这种情况，要用 C++ 指针。//以下C++ 代码是正确的：CMyClass a;CMyClass &a1 = a;CMyClass *b =new CMyClass();CMyClass &b1 = *b; //这种写法不常用。 10) Sun 自称 java 中消灭了 C++ 中万恶的指针，只有自己的对象变量都是引用。做个比较：C++ 引用不能赋值 null, 不能赋值 new XXX()；C++ 指针可以赋值 null, 可以赋值 new XXX()。C++ 引用对象通常在 stack 中，而C++ 指针 new 出来的对象则在 heap 中。 java/C# 中的对象变量，可以赋值 null, 可以赋值 new XXX()。java/C# 中的对象变量在 heap 中。 因此，java/C# 中的对象变量，更像是 C++ 中的指针，而不是 C++ 中的引用。 11) C++ 中，指针变量是一个 long 型整数，可以乱指的：CMyClass *obj = (CMyClass *) 99; //compile/run good, should not use 如果我知道一个内存地址，就可以定义一个C++指针变量，指向这个内存地址。C++ 的“引用”没有这个功能。C#/Java 的对象变量更没有这个功能。“指针乱指” 是 C++ 指针功能强大、灵活的体现，也是最容易出问题的地方。估计是因为这个原因，所以C#/Java 都去掉了这个功能。所谓“万恶的C++指针”，多半，也是指的是“指针乱指”。 12） C++ 有野指针，即已经删除对象，但指针还是指向删除对象，还可以继续操作，但运行结果不保证正确。CMyClass *p = new CMyClass();...//给p 指向的内存赋值delete p;//这时p 仍然指向之前的内存地址，该内存地址数据，短时间并没有被清空或者覆盖，仍然可以读/写。这就是“野指针”。p->run(); //运行很可能不出错，但很可能与实际期望的结果不一样。//但此时指针 p 对应的内存，可能被下一个 new XXX() 代码，用了这个内存，因此，理论上讲，delete 之后的指针，不应再用来操作对象。p= NULL; //将指针指向“空”，可以避免“野指针”问题。p->run(); //这里会报运行时错误。也就是空指针异常。空指针异常在 java/c# 中都有。C++ 中，delete 与将变量赋值 null ， 理应放在一起。其实，由于 delete 关键字，是由 C++ 标准定义的，标准中，完全可以要求， delete 一行代码，执行之后，把指针变量变成 null(C++ 标准，很多都是规定编译器做什么，因此可以加这个规定)。这样可以避免野指针问题。可惜，C++ 标准，在这方面没有考虑周全。
㈥ 请问，我如果需要把一个游标的当前指针，作为传入参数从一个存储过程传给另一存储过程，要如何处理。最好
设置一个全局的指针，将游标地址赋给指针，就可以用指针当做参数多次传递了
㈦ C++指针、数组、引用、变量作函数参数的问题
1, 变量作为参数，这是单向值传递。即将数据传给被调函数后，与调用函数就不相关了，必须通过函数值返回操作结果。
如有函数声明：void swap(int a,int b); //功能是交换a,b值，但事实上对调用函数没有影响，因为swap函数的局部变量a,b在该函数执行完释放掉了，其值也就丢失了。
2. 指针、数组作为参数，这是地址传递，指针和数组可以看成是指向一个或一片连续空间的指针（区别是：一个为变量地址，一个常量地址），它们传递的是所指数据或数据区的地址，这使得函数直接操作的就是原数据区的数据。好处是可以直接通过函数改变调用函数中的多个数据。
如有函数声明：void swap(int *a,int *b); 传递是指向所指空间的地址，执行后，直接交换了调用函数中的数据；
再如: void max(int a[],n),求数组a中的最大值。也是传递数组的地址，操作的是调用函数的数组元素。
3.引用作为参数，引用就是别名，其实也是地址传递,但它是常量地址
㈧ Sql server 存储过程中怎么将变量赋值
/*
Sql server 存储过程中怎么将变量赋值
*/
--SQL赋值语句
DECLARE @test1 INT
SELECT @test1 = 111
SET @test1 = 222
--SQL函数赋值，假定count()是自定义函数
DECLARE @test2 INT
SELECT @test2 = COUNT(*) FROM sys.sysobjects
--SQL存储过程赋值，直接传参处理（类似C语言中的指针吗）
IF OBJECT_ID('sp_test') IS NOT NULL DROP PROCEDURE sp_test
GO
CREATE PROCEDURE sp_test(@test INT OUTPUT)
AS
BEGIN
SELECT @test = 999
END
GO
DECLARE @test3 INT
EXEC sp_test @test3 OUTPUT
SELECT @test3
DROP PROCEDURE sp_test
GO
㈨ 6、什么是存储过程什么是游标，何时使用、何时不用游标
存储过程是一组命名了的SQL语句集合，是为了完成特定功能汇集而成的。该集合编译后存放在数据库中，可根据实际情况重新编译，可直接运行，也可远程运行且存储过程直接在服务器端运行。
游标实际上是一种能从包括多条数据记录的结果集（结果集是select查询之后返回的所有行数据的集合）中每次提取一条记录的机制充当指针的作用，遍历结果中的所有行，但他一次只指向一行。
游标在循环处理字段的时候使用
建议：尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写；使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效；与临时表一样，游标并不是不可使用。
㈩ mybatits调用存储过程输入参数为指针怎么处理
DECLARE
--step1:declarethevariables
v_proct_idprocts.proct_id%TYPE;
v_nameprocts.name%TYPE;
v_priceprocts.price%TYPE;
--step2:declarethecursor
CURSORcv_proct_cursorIS
SELECTproct_id,name,price
FROMprocts
ORDERBYproct_id;
BEGIN
--step3:openthecursor
OPENcv_proct_cursor;
LOOP
--step4:fetchtherowsfromthecursor
FETCHcv_proct_cursor
INTOv_proct_id,v_name,v_price;
--,asindicatedby
--theBooleanvariablecv_proct_cursor%NOTFOUND(=truewhen
--therearenomorerows)
EXITWHENcv_proct_cursor%NOTFOUND;
--useDBMS_OUTPUT.PUT_LINE()todisplaythevariables
DBMS_OUTPUT.PUT_LINE(
'v_proct_id='||v_proct_id||',v_name='||v_name||
',v_price='||v_price
);
ENDLOOP;
--step5:closethecursor
CLOSEcv_proct_cursor;
END;
这个例子比较好