ORACLE--预编译与共享池--SGA基本介绍

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/xieyuooo/archive/2010/04/08/5463838.aspx

我们暂时先不说其他的，我们先做一个简单的实验来证明来看出一些问题，最后通过为什么来说明实验的结论，并介绍原理和常规查看方式，好了，我们先看看下面三段代码分别执行的结果。

首先为了测试，我们需要创建一张表：

CREATE TABLE PRE_TEST_TABLE(
   C1  NUMBER,
   C2  VARCHAR2(100)
);

好了，我们做一个插入操作的对比：

代码段1：

BEGIN

      FOR I IN 1..20000 LOOP

           EXECUTE IMMEDIATE 'INSERT INTO PRE_TEST_TABLE VALUES('||i||',''test'')';

      END LOOP;

      COMMIT;

END;

 

代码片段2：

BEGIN

      FOR I IN 1..20000 LOOP

           EXECUTE IMMEDIATE 'INSERT INTO PRE_TEST_TABLE VALUES(:V1,:V2)' USING I,'test';

      END LOOP;

      COMMIT;

END;

 

代码片段3：

BEGIN

      FOR I IN 1..20000 LOOP

           INSERT INTO PRE_TEST_TABLE VALUES(I,'TEST');

      END LOOP;

      COMMIT;

END;

 

三段代码执行效率你可以清晰的对比出来，代码段1是最慢的，而且比后两者慢很多倍，而代码片段2和代码片段3执行效率基本是一样的，为什么会有这样的效果呢？看了下面的推敲，我们就清楚了，我们先把数据清理掉，共享池清理一下（下面我们再说），在做操作比较好。

 

现在我需要做的SQL语句操作是对表的插入PRE_TEST_TABLE VALUES表的操作：

INSERT INTO PRE_TEST_TABLE VALUES....

 

至于参数如何，我们不一定，首先查询一下共享池内部做此操作的记录：

SELECT * FROM V$SQLAREA
WHERE SQL_TEXT LIKE 'INSERT INTO PRE_TEST_TABLE VALUES%';

 

发现数据太多，有多少不好说了,暂时不数了，因为对得出结论没有意义，需要清理下共享池方便试验。

 

TRUNCATE TABLE PRE_TEST_TABLE;//清空表

 

ALTER SYSTEM FLUSH SHARED_POOL;//清空缓冲区

 

查询共享池:

SELECT * FROM V$SQLAREA
WHERE SQL_TEXT LIKE 'INSERT INTO PRE_TEST_TABLE VALUES%';

发现没有任何数据。。。。我们开始比较干净的做实验了。。。

 

开始试验：

我们将上述试验的循环次数降低为3次

首先执行代码段1：

BEGIN

      FOR I IN 1..3 LOOP

           EXECUTE IMMEDIATE 'INSERT INTO PRE_TEST_TABLE VALUES('||i||',''test'')';

      END LOOP;

      COMMIT;

END;

 

查询共享池（发现多了3条记录）：

SQL> SELECT SQL_TEXT,HASH_VALUE,PARSE_CALLS FROM V$SQLAREA
  2  WHERE SQL_TEXT LIKE 'INSERT INTO PRE_TEST_TABLE VALUES%';

SQL_TEXT                                                            HASH_VALUE      PARSE_CALLS
--------------------------------------------------------------- -------------- ---------------------
INSERT INTO PRE_TEST_TABLE VALUES(1,'test')        2868385396       1
INSERT INTO PRE_TEST_TABLE VALUES(2,'test')        2513099158       1
INSERT INTO PRE_TEST_TABLE VALUES(3,'test')        455953479         1

 

再执行第二段代码：

BEGIN

      FOR I IN 1..3 LOOP

           EXECUTE IMMEDIATE 'INSERT INTO PRE_TEST_TABLE VALUES(:V1,:V2)' USING I,'test';

      END LOOP;

      COMMIT;

END;

 

再查询共享池（发现只多了一条SQL）：

SQL> SELECT SQL_TEXT,HASH_VALUE,PARSE_CALLS FROM V$SQLAREA
  2  WHERE SQL_TEXT LIKE 'INSERT INTO PRE_TEST_TABLE VALUES%';

SQL_TEXT                                                              HASH_VALUE  PARSE_CALLS
--------------------------------------------------------------- ---------------- ------------
INSERT INTO PRE_TEST_TABLE VALUES(1,'test')         2868385396    1
INSERT INTO PRE_TEST_TABLE VALUES(:V1,:V2)        357326048      3
INSERT INTO PRE_TEST_TABLE VALUES(2,'test')         2513099158    1
INSERT INTO PRE_TEST_TABLE VALUES(3,'test')         455953479      1

 

再执行第三段代码：

BEGIN

      FOR I IN 1..3 LOOP

           INSERT INTO PRE_TEST_TABLE VALUES(I,'TEST');

      END LOOP;

      COMMIT;

END;

 

再查询共享池（发现也只多了一条SQL）：

SQL> SELECT SQL_TEXT,HASH_VALUE,PARSE_CALLS FROM V$SQLAREA
  2  WHERE SQL_TEXT LIKE 'INSERT INTO PRE_TEST_TABLE VALUES%';

SQL_TEXT                                                             HASH_VALUE   PARSE_CALLS
------------------------------------------------------------- ------------------  ------------
INSERT INTO PRE_TEST_TABLE VALUES(1,'test')          2868385396    1
INSERT INTO PRE_TEST_TABLE VALUES(:B1 ,'TEST')     2239119514    3
INSERT INTO PRE_TEST_TABLE VALUES(:V1,:V2)         357326048      3
INSERT INTO PRE_TEST_TABLE VALUES(2,'test')          2513099158    1
INSERT INTO PRE_TEST_TABLE VALUES(3,'test')          455953479      1

 

从这里可能大家基本可以得出初步的结论，就是第一段代码每条SQL都会占用共享池，并征用共享池，而且用过一次后就不会在使用了，这个答案是正确的，我首先给出预编译和拼SQL对ORACLE的四个不同影响进行定义，下面再说明为什么：

1、拼SQL会导致共享池的长期征用状态

2、拼SQL会导致共享池中存在一堆的垃圾SQL。

3、拼SQL会硬解析（Hard parse），而预编译可以充分利用软解析。

4、拼SQL会导致注入型错误。

 

疑问：

为什么第二段代码和第三段代码是一个效果呢，这里说明一下，在存储过程提高效率的基本因素就是你如果按照过程化去写SQL，存储过程默认就会按照预编译方式去执行，因为这是ORACLE优化的基本原则，而即使在过程中使用EXECUTE IMMEDIATE SQL_STR去执行，请注意，EXECUTE IMMEDIATE不是SQL语句，而是ORACLE在过程中支持的命令，即直接发送执行命令给ORACLE的分析器，所以这个是否进行编译完全看你的SQL是什么样的了，而不是ORACLE自己能决定的。

 

过程说明：

SQL从终端通过1521 TCP服务端口以字符串方式传送至ORACLE后（包含JAVA程序也是这样，其他应用程序，如出现String sql = "SELECT * FROM A WHERE ID="+id;也会出现和代码段1一样的结果），ORACLE通过HASH算法对其SQL转换，并在共享池中查找是否存在同样HASH值的SQL（即：SQL即使是参数或者大小写不同，也会导致找不到一样的HASH值），如果找到了，直接执行已经编译完的SQL，并修改使用率（这个有用）；若没有，则首先通过硬解析工具对其进行各项语法分析和性能指标分析等等，然后开始征用共享池（此为共享资源），并注册到共享池中，标志调用次数为1，然后再执行，当在大量征用共享资源时候，并且在硬解析过程中，高并发将导致阻塞。可以将上述第一段代码的循环次数增加为10万，基本机器可以弄死，呵呵。。。。

 

共享池的大小肯定是有限制的，所以ORACLE在共享池不够用的时候，采用基于LRU为核心的算法进行替换(上述的PARSE_CALLS字段可以基本看出SQL被调用的次数，但是不完全依赖于它)，我们最希望的就是不要做这样的操作，因为这样的操作必然面临磁盘读取，在内存中获取我们称为命中，命中率高才能提高利用率，系统的整体性能才能得到保证。

 

第四点中提到的至于注入型错误或攻击就是传送特殊字符串，导致SQL执行SQL的修改，为什么，因为你的SQL是拼出来的，我举个简单例子：

你的程序中：

String sql = "SELECT * FROM A WHERE A.NAME = '"+name+"'";

此name假如为查询条件传入，那么此时我在查询条件文本框中这样输入：

第一种输入：

' OR 1=1--

此时你的SQL变成：

SELECT * FROM A WHERE A.NAME ='' OR 1=1 --'

后面两杠是屏蔽你后面的SQL，用一个OR 1=1前面的东东不论是啥就永远成立了(注意：ORACLE的SQL执行，优先级是AND 大于 OR的，所以只要OR 1=1，无论有多少个AND，最后会和这个OR 1=1去匹配，所有的数据都会提取出来)，此时分页或者说导出控制天数或者数据量，都控制不了，有多少数据就会出来多少数据，首先数据权限没有了，然后开几个浏览器系统就能挂掉，呵呵！

 

另一种更加损的输入招数是：

';DROP TABLE DUAL--

在我以前用SQL SERVER的JDBC时，这种方式是支持的，这样是很损的一种办法。其实输入的方式有些通过URL有些通过条件，不一定，而且千奇百怪，有些想都想不到，至少他可能会导致你的SQL执行不是那么顺利篡改了SQL执行的原有意义。

 

所以OLTP系统使用这样的SQL，尤其对于ORACLE数据库（其余数据库请自己研究下），是非常恶心的，所以我们在OLTP系统是封杀这样的SQL存在。

 

 

简要共享池的使用介绍：

谈到共享池我们大致介绍一些SGA的内容，ORACLE数据库我们操作主要对象是实例，而非数据库本身，主要原因为：性能、安全性。而实例大致分：SGA、PGA，本文只是由共享池介绍一下SGA，细节说下其共享池部分，而PGA后续讨论。

 

SGA内部主要包含：数据缓冲区、共享池、JAVA池、大池、Stream池、重做日志缓冲区；

 

PGA内部包含：用户Session信息、排序信息、Hash area、堆栈。这些信息被后台进程所控制，版本递增的后台进程也在不断增加，细节的信息后续讨论。

 

其实今天所谓查询共享池，也是查询共享池内部的Library cache。我们在SQLPLUS中最常用的命令就是：

SQL> show sga;

Total System Global Area 1.7062E+10 bytes
Fixed Size                      2102776 bytes
Variable Size                  4613736968 bytes
Database Buffers            1.2432E+10 bytes
Redo Buffers                  14671872 bytes

也可以使用一下方式查询和上述一样的SGA信息：

 

 

SQL> SELECT * FROM V$SGA;

NAME                      VALUE
-------------------- ----------
Fixed Size               2102776
Variable Size           4613736968
Database Buffers     1.2432E+10
Redo Buffers           14671872

 

分别解释下几个字段的意义：

Total System Global Area：代表SGA的总体大小，包含下面几者之和，都是以byte为单位，即字节；

Fixed Size：字典信息、控制信息、状态信息。

Variable Size：共享池（shared pool）、Java池(Java Pool)、大池(Large Pool)、Stream pool；

Database Buffers：为数据缓冲区，OLTP系统要求这块设置较大。

Redo Buffer：重做日志缓冲区，适当提高缓冲区，减少文件组切换，可以提高效率。

 

通过一下SQL可以得到SGA内部详细的组件分配情况：

 

SQL> SELECT * FROM V$SGASTAT;

POOL         NAME                            BYTES
------------ -------------------------- ----------
                  fixed_sga                     2102776
                  buffer_cache               1.2432E+10
                  log_buffer                   14671872
shared pool  transaction                   8062512
shared pool  table definiti                  80336
shared pool  KGSKI scheduler heap 2 de         232
shared pool  kspd run-time context              16
shared pool  PX subheap                      61344
shared pool  partitioning d                 455480
shared pool  message pool freequeue         757568
shared pool  qesblGF:bfm                       728

POOL         NAME                            BYTES
------------ -------------------------- ----------

等等数据。。。。。。。自己查看一下即可，我这由于篇幅所限，就输出这么多了。

 

 

 

--下面SQL用于查看SGA中可进行手工调配参数的列表：

SQL> SELECT * FROM V$SGA_DYNAMIC_COMPONENTS;

COMPONENT                                                        CURRENT_SIZE   MIN_SIZE   MAX_SIZE USER_SPECIFIED_SIZE OPER_COUNT LAST_OPER_TYP LAST_
---------------------------------------------------------------- ------------ ---------- ----------
shared pool                                                        4194304000 4194304000          0          4194304000          0 STATIC                              
large pool                                                          134217728  134217728          0           134217728          0 STATIC                              
java pool                                                           134217728  134217728          0           134217728          0 STATIC                              
streams pool                                                        117440512  117440512          0           117440512          0 STATIC                              
DEFAULT buffer cache                                               1.2264E+10 1.2264E+10          0          1.2264E+10          2 SHRINK        MANUAL    07-4月
KEEP buffer cache                                                   100663296          0          0           100663296          8 GROW          MANUAL    07-4月 -10
RECYCLE buffer cache                                                 67108864          0          0            67108864          1 GROW          MANUAL    07-4月 -10
DEFAULT 2K buffer cache                                                     0          0          0                   0          0 STATIC                              
DEFAULT 4K buffer cache                                                     0          0          0                   0          0 STATIC                              
DEFAULT 8K buffer cache                                                     0          0          0                   0          0 STATIC                              
DEFAULT 16K buffer cache                                                    0          0          0                   0          0 STATIC                              

COMPONENT                                                        CURRENT_SIZE   MIN_SIZE   MAX_SIZE USER_SPECIFIED_SIZE OPER_COUNT LAST_OPER_TYP LAST_
---------------------------------------------------------------- ------------ ---------- ----------
DEFAULT 32K buffer cache                                                    0          0          0                   0          0 STATIC                              
ASM Buffer Cache                                                            0          0          0          1.2465E+10          0 STATIC                 

 

 

查询共享池大小：

SQL> show parameter shared_pool_size;

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
shared_pool_size                     big integer 4000M

 

SQL> SELECT NAME,TYPE,VALUE
  2      FROM V$PARAMETER A
  3      WHERE A.NAME='shared_pool_size';

NAME                                       TYPE          VALUE
-------------------- ----------------------------- ----------------------------
shared_pool_size                       6               4194304000

 

 

这里顺便说下，很多时候大家不知道数据字典是什么，很多时候数据字典的名字很长，而且有些后面又s，有些后面没有S，大家记录不下来，此时大家只需要知道大致是什么就OK了，然后用下面的基于视图的总视图去查询视图的实际名称（我们以不知道共享池的视图是什么）：

SQL> SELECT * FROM DICT T
  2  WHERE T.TABLE_NAME LIKE '%V$SHARED%';

 

TABLE_NAME                                COMMENTS
------------------------------ -------------------------------------------------------------------
V$SHARED_SERVER_MONITOR        Synonym for V_$SHARED_SERVER_MONITOR
V$SHARED_SERVER                       Synonym for V_$SHARED_SERVER
V$SHARED_POOL_RESERVED          Synonym for V_$SHARED_POOL_RESERVED
V$SHARED_POOL_ADVICE              Synonym for V_$SHARED_POOL_ADVICE
GV$SHARED_SERVER_MONITOR      Synonym for GV_$SHARED_SERVER_MONITOR
GV$SHARED_SERVER                     Synonym for GV_$SHARED_SERVER
GV$SHARED_POOL_RESERVED        Synonym for GV_$SHARED_POOL_RESERVED
GV$SHARED_POOL_ADVICE            Synonym for GV_$SHARED_POOL_ADVICE

 

其中GV$开头的视图是用于集群中的，我们一般只关心V$开头的信息；可能你连表的大致意思都不清楚，你只大致记得有一个字段大致的名称，如我们知道一个视图内部字段的名称有一个以SCN开头的列，那么我们这样也可以反向给它定位：

SQL> SELECT T.TABLE_NAME, T.COLUMN_NAME
  2    FROM DICT_COLUMNS T
  3   WHERE T.COLUMN_NAME LIKE 'SCN%';

 

TABLE_NAME                     COLUMN_NAME
------------------------------ ------------------------------
ALL_SUMDELTA                   SCN
DBA_AUDIT_TRAIL                SCN
USER_AUDIT_TRAIL               SCN
DBA_AUDIT_STATEMENT            SCN
USER_AUDIT_STATEMENT           SCN
DBA_AUDIT_OBJECT               SCN
USER_AUDIT_OBJECT              SCN
DBA_AUDIT_EXISTS               SCN
DBA_FGA_AUDIT_TRAIL            SCN
DBA_COMMON_AUDIT_TRAIL         SCN
DBA_CAPTURE_PREPARED_TABLES    SCN
ALL_CAPTURE_PREPARED_TABLES    SCN
DBA_FILE_GROUP_TABLES          SCN
ALL_FILE_GROUP_TABLES          SCN
USER_FILE_GROUP_TABLES         SCN
V$RESTORE_POINT                SCN
V$RECOVERY_STATUS              SCN_NEEDED
V$LOGMNR_CONTENTS              SCN
V$XML_AUDIT_TRAIL              SCN
GV$RESTORE_POINT               SCN

 

         

 

这里回到正题：清空共享池(OLTP系统运行时不要去操作，这个过程很影响整体运行)：

SQL>ALTER SYSTEM FLUSH SHARED_POOL;

 

如果要查询某过程或包的源码，可以看一下系统的资源包：

SQL>SELECT * FROM USER_SOURCE t WHERE t.name = '过程或包的名字' ORDER BY LINE;

 

 

这些源码信息在首次是不会装入内存的，因为共享池的大小有限，调用时再装入内存，而且也不会逃脱LRU的命运，若一些写的很烂的SQL，就有可能把它替换出去，这个时候我们想做到的是启动时直接装入内存并不会被替换，ORACLE给我们一个KEEP方法，但是并非默认的，也就是安装ORACLE后并不是默认就提供的这个包，如果你用具有DBA权限的人进去，不能使用DBMS_SHARED_POOL这个包（报：这个包不存在），说明还没有创建，此时需要做一下操作，才能创建：

 

 

1、首先定位ORACLE_HOME的位置，我们没有直接定位ORACLE_HOME的方式，除非是你自己安装的，如果不知道，用下面一个办法：

SELECT * FROM V$PARAMETER P1
WHERE P1.NAME = 'spfile';

 

2、若没有该目录，使用CREATE SPFILE FROM PFILE;执行一下重启OK就有了，得到该目录后，假如得到如下：

D:\ORACLE10\PRODUCT\10.2.0\DB_1\DATABASE\SPFILEORCL102.ORA

那么ORACLE_HOME上相推两层得到：

D:\ORACLE10\PRODUCT\10.2.0\DB_1\

那么要得到那个包的创建脚本就在：

D:\oracle10\product\10.2.0\db_1\RDBMS\ADMIN\DBMSPOOL.SQL

此时需要到安装数据库的机器上去执行，如果你本地有脚本当然也可以执行，但是注意：这个执行必须是在SQLPLUS中，PL/SQL中执行该脚本不好用。

 

3、执行方式：进入到安装该数据库的SQLPLUS下用SYS用户登录，该包需要创建在SYS用户下。

SQL> @D:\oracle10\product\10.2.0\db_1\RDBMS\ADMIN\DBMSPOOL.SQL

程序包已创建。

授权成功。

视图已创建。

程序包体已创建。

 

 

 

4、对于系统的大过程，可能第一次装载比较缓慢，而且如果使用频率较高，可以将其脱离LRU算法，并直接装入内存，如果可以的话，做ORACLE启动时触发器，如果不行，就手动执行一下代码：

BEGIN

   SYS.DBMS_SHARED_POOL.KEEP('存储过程或包的名字');

END;

 

 

若想将某过程从内存中去除掉：

BEGIN

   SYS.DBMS_SHARED_POOL.UNKEEP('存储过程或包的名字');

END;

 

 

5、此时查看缓冲池中是否装载改对象：

SELECT name,owner,type
FROM v$db_object_cache where kept = 'YES'
AND NAME ='过程或包的名字';//这个地方也可以用SQL片段来LIKE

 

 

查看共享池中执行的一些SQL包头：

SELECT * FROM V$SQLAREA;

 

 

通不过上述的SQL得到HASH_VALUE或者ADDREDSS或者SQL_ID都可以通过以下视图得到对应执行SQL的全部内容（当SQL较长的时候，V$SQLAREA只保存前面一部分，全部内容在该视图中）：

SELECT * FROM V$SQLTEXT_WITH_NEWLINES;

 

 

得到SQL的执行计划:

SELECT * FROM V$SQL_PLAN;

 

 

得到对共享池设置的建议值，ORACLE根据实际运行情况，推荐值：

SELECT * FROM V$SHARED_POOL_ADVANCE;

 

 

还有些不是很常用的：

得到SQL绑定变量信息：

SELECT * FROM V$SQL_BIND_CAPTURE;

 

 

SQL占用共享池内存：

SELECT * FROM V$SQL_SHARED_MEMORY;

 

 

SQL消耗调用的统计信息：

SELECT * FROM V$SQLSTATS;

 

 

这里只是由预编译->共享池->SGA的过程，对于SGA的内核只是阐述了共享池的部分，下次说明SGA的另一大块，Data Buffer，数据缓冲区，该区域在OLTP系统中非常重要。

 

最后补充话题，本来这个想在后面说的，因为涉及一些其他内容，不过既然说到，就提一下吧，我们在OLTP要求使用绑定参数方式执行SQL如：

用应用程序的SQL应当是：

String sql = “SELECT * FROM A WHERE ID=?”;

而不是：

String sql = “SELECT * FROM A WHERE ID=”+id;

 

那么这样的情况我们该怎么办呢？当要查询多个ID，使用IN的情况，或者同时修改多条记录的操作，我们无疑想出最常规的三种办法(我们先介绍常规方法，再介绍解决问题的方法)：

 

方法1（拼串，放弃预编译）：

String sql = “SELECT * FROM A WHERE ID IN(”+keys+”)”;

付：该方法放弃预编译，但是也是常规方法中的无奈之举。

 

方法2(将参数个数动态化去预编译)

StringBuffer sql = new StringBuffer(256);

sql.append(“SEELCT * FROM A WHERE ID IN(”);

for(….) {

   sql.append(“?”).append(“,”);

}

sql.deleteCharAt(sql.length()-1);

付：该方法比上一种稍微好一点，OLTP下一般情况下，我们常规方法中最少要这样去完成，大家可以把ibatis的执行SQL日志拿出来看下即可发现，ibatis对于动态参数个数也是这样去完成的，对于并发度不算高的代码段我们可以这样使用，如果并发度高的代码段，这样使用我们也不会考虑。

 

方法3（循环提取。循环修改）

for(….) {

    ptmt.setInt(1,ID[i]);

    ptmt.executeQuery(“SELECT * FROM A WHERE ID=?”);

}

付:这在执行过程中往往是最“不应该使用”的办法了;如果执行插入操作，我们会适当考虑携带批处理这样去完成也是可以的，不过对于UPDATE和SELECT这类操作我们不该这样使用的。

 

在这里上述三种办法，只有第二种方法在OLTP中并发量不大的情况下可以使用，若并发量较大，且参数个数的动态性比较大，也应该考虑使用其他方法去实现，因为大家通过上述试验和反向查询后发现，问号个数的变化也会产生不同的SQL，共享池中仍然会造成很多的垃圾，只是相对第一种方法概率降低了很多，而第三种方法基本是我们不考虑的。

 

我们说一下如果对于这样的情况，批量执行过程中，我们该如何转换，利用ORACLE的数组进行转换，为此我们先在ORACLE内部提供一个函数，和数组类型，前序工作:

步骤1：

创建数据类型（表格类型，也类似数组）：

CREATE OR REPLACE TYPE MY_TABLE_TYPE IS TABLE OF VARCHAR2(8000);

 

步骤2：

创建转换函数（在网上很多地方可以找到类似代码，我这只是一个参考）：

CREATE OR REPLACE FUNCTION SPLIT(SRC_STR IN VARCHAR2,

SPLIT_STR VARCHAR2) RETURN MY_TABLE_TYPE IS
  V_TABLE_STR MY_TABLE_TYPE := MY_TABLE_TYPE();
  V_TEMP_STR  VARCHAR2(8000) := SRC_STR;
  V_SPLIT_STR VARCHAR2(20) := SPLIT_STR;
  I           NUMBER := 1;
  J           NUMBER := 1;
BEGIN

  IF V_SPLIT_STR IS NULL THEN
      V_SPLIT_STR := ',';--我们默认用逗号分隔 
  END IF;

  IF SRC_STR IS NULL OR SRC_STR = V_SPLIT_STR THEN
       RETURN V_TABLE_STR;
  END IF;

  V_TEMP_STR := LTRIM(V_TEMP_STR, V_SPLIT_STR);

  LOOP
        I := INSTR(V_TEMP_STR, V_SPLIT_STR, J);
        EXIT WHEN I = 0 OR J > LENGTH(V_TEMP_STR);
        V_TABLE_STR.EXTEND;
        V_TABLE_STR(V_TABLE_STR.COUNT) := SUBSTR(V_TEMP_STR, J, I - J);
        J := I + LENGTH(V_SPLIT_STR);
  END LOOP;

  IF J < LENGTH(V_TEMP_STR) THEN
        V_TABLE_STR.EXTEND;
        V_TABLE_STR(V_TABLE_STR.COUNT) := SUBSTR(V_TEMP_STR, J, LENGTH(V_TEMP_STR) - J + 1);
  END IF;

  RETURN V_TABLE_STR;

END SPLIT;

 

 

步骤3：（测试可用性,这里假如数据都是按照逗号分隔的）

较高版本支持这样的写法：

SQL> SELECT * FROM TABLE(SPLIT('123,321',','));

 

COLUMN_VALUE

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

123

321

较低版本可以这样写：

SQL> SELECT * FROM TABLE(CAST(SPLIT('123,321,456', ',') AS MY_TABLE_TYPE));

 

COLUMN_VALUE

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

123

321

456

 

步骤4（程序应用）：

String sql = “SELECT * FROM A WHERE ID IN(SELECT * FROM TABLE(SPLIT(?,',')))”;//当然对于低版本的数据库，相应修改即可。

但是ORACLE有些时候会很傻的去使用HASH JOIN，因为他们他不知道你里面返回多少数据，而我们通过转换回来的ID往往数据量很少，最多就是几十行上百行，若目标表为一个大表，使用HASH JOIN的确是一件很浪费的事情，此时我们不愿意这样去做，因为很浪费CPU和临时表空间（这其实是后面要说的），我们一般需要强制指定查询的方式来控制他走嵌套循环，让大表根据小表去走索引，使用ORACLE的Hint来强制告诉它应该由小表引导大表执行，来保证SQL执行计划的稳定性：

String sql = “SELECT /*+ordered use_nl(a2,a1)*/a2.* FROM A a1,(SELECT COLUMN_VALUE FROM TABLE(SPLIT(?,',')) a2 WHERE a1.ID = A2.COLUMN_VALUE”;

 

此时可能会问，这样转一次会不会很慢，是的，这不难会想想一个拆开字符串的过程，我们必然会消耗一点，不过要想到一次执行就是拆开一个字符串而已，而且我们传入的字符串也不会太长，这个解析过程对于ORACLE来说还是没啥问题的，不必担心这个，而更加重要的提高了共享池的应用。