常用方法有以下几种：

　　一、通过PL/SQL Dev工具

　　1、直接File->New->Explain Plan Window，在窗口中执行sql可以查看计划结果。其中，Cost表示cpu的消耗，单位为n%，Cardinality表示执行的行数，等价Rows。

　　2、先执行 EXPLAIN PLAN FOR　　 select * from tableA　where paraA=1，再 select * from table(DBMS_XPLAN.DISPLAY)便可以看到oracle的执行计划了，看到的结果和1中的一样，所以使用工具的时候推荐使用1方法。

　　注意：PL/SQL Dev工具的Command window中不支持set autotrance on的命令。还有使用工具方法查看计划看到的信息不全，有些时候我们需要sqlplus的支持。

　　二、通过sqlplus

　　1、一般情况都是本机链接远程服务器，所以命令如下：

　　sqlplus user/pwd@serviceName

　　此处的serviceName为tnsnames.ora中定义的命名空间。

　　2、执行set autotrace on，然后执行sql语句，会列出以下信息：

　　。。。（省略一些信息）

　　统计信息

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

　　　　　　　　　　1　　recursive　calls　（归调用次数）
　　　　　　　　　　0　　db　block　gets　　
　　　　　　　　　　2　　consistent　gets
　　　　　　　　　　0　　physical　reads　（物理读——执行SQL的过程中，从硬盘上读取的数据块个数）
　　　　　　　　　　0　　redo　size　(重做数——执行SQL的过程中，产生的重做日志的大小)
　　　　　　　　358　　bytes　sent　via　SQL*Net　to　client
　　　　　　　　366　　bytes　received　via　SQL*Net　from　client
　　　　　　　　　　1　　SQL*Net　roundtrips　to/from　client
　　　　　　　　　　0　　sorts　(memory)　　　　　在内存中发生的排序
　　　　　　　　　　0　　sorts　(disk)　　　　　在硬盘中发生的排序
　　　　　　　　　　1　　rows　processed

　　省略部分信息和通过PL/SQL Dev工具查看执行计划的信息一样，下面的统计信息是更详细的。

　　判断SQL效率高低不关通过时间来衡量，还应该通过执行SQL执行状态里面的逻辑读的数量

　　逻辑读=（db block gets+ consistent gets）

FengFly.Com
ＷWＷ.ＦENGＦLy.ＣOM FengFly.Com

原文来自：雨枫技术教程网 http://www.fengfly.com
原文网址：http://www.fengfly.com/plus/view-161902-1.html

Rowid的概念：rowid是一个伪列，既然是伪列，那么这个列就不是用户定义，而是系统自己给加上的。对每个表都有一个rowid的伪列，但是表中并不物理存储ROWID列的值。不过你可以像使用其它列那样使用它，但是不能删除改列，也不能对该列的值进行修改、插入。一旦一行数据插入数据库，则rowid在该行的生命周期内是唯一的，即即使该行产生行迁移，行的rowid也不会改变。

Recursive SQL概念：有时为了执行用户发出的一个sql语句，Oracle必须执行一些额外的语句，我们将这些额外的语句称之为'recursive calls'或'recursive SQL statements'。如当一个DDL语句发出后，ORACLE总是隐含的发出一些recursive SQL语句，来修改数据字典信息，以便用户可以成功的执行该DDL语句。当需要的数据字典信息没有在共享内存中时，经常会发生Recursive calls，这些Recursive calls会将数据字典信息从硬盘读入内存中。用户不比关心这些recursive SQL语句的执行情况，在需要的时候，ORACLE会自动的在内部执行这些语句。当然DML语句与SELECT都可能引起recursive SQL。简单的说，我们可以将触发器视为recursive SQL。

Row Source(行源)：用在查询中，由上一操作返回的符合条件的行的集合，即可以是表的全部行数据的集合；也可以是表的部分行数据的集合；也可以为对上2个row source进行连接操作(如join连接)后得到的行数据集合。

Predicate(谓词)：一个查询中的WHERE限制条件

Driving Table(驱动表)：该表又称为外层表(OUTER TABLE)。这个概念用于嵌套与HASH连接中。如果该row source返回较多的行数据，则对所有的后续操作有负面影响。注意此处虽然翻译为驱动表，但实际上翻译为驱动行源(driving row source)更为确切。一般说来，是应用查询的限制条件后，返回较少行源的表作为驱动表，所以如果一个大表在WHERE条件有有限制条件(如等值限制)，则该大表作为驱动表也是合适的，所以并不是只有较小的表可以作为驱动表，正确说法应该为应用查询的限制条件后，返回较少行源的表作为驱动表。在执行计划中，应该为靠上的那个row source，后面会给出具体说明。在我们后面的描述中，一般将该表称为连接操作的row source 1。

Probed Table(被探查表)：该表又称为内层表(INNER TABLE)。在我们从驱动表中得到具体一行的数据后，在该表中寻找符合连接条件的行。所以该表应当为大表(实际上应该为返回较大row source的表)且相应的列上应该有索引。在我们后面的描述中，一般将该表称为连接操作的row source 2。

组合索引(concatenated index)：由多个列构成的索引，如create index idx_emp on emp(col1, col2, col3, ……)，则我们称idx_emp索引为组合索引。在组合索引中有一个重要的概念：引导列(leading column)，在上面的例子中，col1列为引导列。当我们进行查询时可以使用”where col1 = ? ”，也可以使用”where col1 = ? and col2 = ?”，这样的限制条件都会使用索引，但是”where col2 = ? ”查询就不会使用该索引。所以限制条件中包含先导列时，该限制条件才会使用该组合索引。

可选择性(selectivity)：比较一下列中唯一键的数量和表中的行数，就可以判断该列的可选择性。如果该列的”唯一键的数量/表中的行数”的比值越接近1，则该列的可选择性越高，该列就越适合创建索引，同样索引的可选择性也越高。在可选择性高的列上进行查询时，返回的数据就较少，比较适合使用索引查询。
二．oracle访问数据的存取方法

1) 全表扫描（Full Table Scans, FTS）

为实现全表扫描，Oracle读取表中所有的行，并检查每一行是否满足语句的WHERE限制条件一个多块读操作可以使一次I/O能读取多块数据块(db_block_multiblock_read_count参数设定)，而不是只读取一个数据块，这极大的减少了I/O总次数，提高了系统的吞吐量，所以利用多块读的方法可以十分高效地实现全表扫描，而且只有在全表扫描的情况下才能使用多块读操作。在这种访问模式下，每个数据块只被读一次。
使用FTS的前提条件：在较大的表上不建议使用全表扫描，除非取出数据的比较多，超过总量的5% -- 10%，或你想使用并行查询功能时。
使用全表扫描的例子：
~~~~~~~~~~~~~~~~~~~~~~~~

SQL> explain plan for select * from dual; Query Plan ----------------------------------------- SELECT STATEMENT[CHOOSE] Cost= TABLE ACCESS FULL DUAL

2) 通过ROWID的表存取（Table Access by ROWID或rowid lookup）

行的ROWID指出了该行所在的数据文件、数据块以及行在该块中的位置，所以通过ROWID来存取数据可以快速定位到目标数据上，是Oracle存取单行数据的最快方法。
这种存取方法不会用到多块读操作，一次I/O只能读取一个数据块。我们会经常在执行计划中看到该存取方法，如通过索引查询数据。

使用ROWID存取的方法：

SQL> explain plan for select * from dept where rowid = 'AAAAyGAADAAAAATAAF'; Query Plan ------------------------------------ SELECT STATEMENT [CHOOSE] Cost=1 TABLE ACCESS BY ROWID DEPT [ANALYZED]

3）索引扫描（Index Scan或index lookup）

我们先通过index查找到数据对应的rowid值(对于非唯一索引可能返回多个rowid值)，然后根据rowid直接从表中得到具体的数据，这种查找方式称为索引扫描或索引查找(index lookup)。一个rowid唯一的表示一行数据，该行对应的数据块是通过一次i/o得到的，在此情况下该次i/o只会读取一个数据库块。

在索引中，除了存储每个索引的值外，索引还存储具有此值的行对应的ROWID值。索引扫描可以由2步组成：(1) 扫描索引得到对应的rowid值。 (2) 通过找到的rowid从表中读出具体的数据。每步都是单独的一次I/O，但是对于索引，由于经常使用，绝大多数都已经CACHE到内存中，所以第1步的I/O经常是逻辑I/O，即数据可以从内存中得到。但是对于第2步来说，如果表比较大，则其数据不可能全在内存中，所以其I/O很有可能是物理I/O，这是一个机械操作，相对逻辑I/O来说，是极其费时间的。所以如果多大表进行索引扫描，取出的数据如果大于总量的5% -- 10%，使用索引扫描会效率下降很多。如下列所示：

            
SQL> explain plan for select empno, ename from emp where empno=10;

            Query Plan

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

            SELECT STATEMENT [CHOOSE] Cost=1

            TABLE ACCESS BY ROWID EMP [ANALYZED] 

            INDEX UNIQUE SCAN EMP_I1
            

但是如果查询的数据能全在索引中找到，就可以避免进行第2步操作，避免了不必要的I/O，此时即使通过索引扫描取出的数据比较多，效率还是很高的

SQL> explain plan for select empno from emp where empno=10;-- 只查询empno列值 Query Plan ------------------------------------ SELECT STATEMENT [CHOOSE] Cost=1 INDEX UNIQUE SCAN EMP_I1

进一步讲，如果sql语句中对索引列进行排序，因为索引已经预先排序好了，所以在执行计划中不需要再对索引列进行排序

            
SQL> explain plan for select empno, ename from emp

            where empno > 7876 order by empno;

            Query Plan

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

            SELECT STATEMENT[CHOOSE] Cost=1

            TABLE ACCESS BY ROWID EMP [ANALYZED] 

            INDEX RANGE SCAN EMP_I1 [ANALYZED] 
            

从这个例子中可以看到：因为索引是已经排序了的，所以将按照索引的顺序查询出符合条件的行，因此避免了进一步排序操作。

根据索引的类型与where限制条件的不同，有4种类型的索引扫描：
索引唯一扫描(index unique scan)
索引范围扫描(index range scan)
索引全扫描(index full scan)
索引快速扫描(index fast full scan)
(1) 索引唯一扫描(index unique scan)

通过唯一索引查找一个数值经常返回单个ROWID。如果存在UNIQUE 或PRIMARY KEY 约束（它保证了语句只存取单行）的话，Oracle经常实现唯一性扫描。
使用唯一性约束的例子：

SQL> explain plan for
select empno,ename from emp where empno=10;
Query Plan
------------------------------------
SELECT STATEMENT [CHOOSE] Cost=1
TABLE ACCESS BY ROWID EMP [ANALYZED]
INDEX UNIQUE SCAN EMP_I1
(2) 索引范围扫描(index range scan)

使用一个索引存取多行数据，在唯一索引上使用索引范围扫描的典型情况下是在谓词(where限制条件)中使用了范围操作符(如>、<、<>、>=、<=、between)
使用索引范围扫描的例子：

SQL> explain plan for select empno,ename from emp where empno > 7876 order by empno; Query Plan -------------------------------------------------------------------------------- SELECT STATEMENT[CHOOSE] Cost=1 TABLE ACCESS BY ROWID EMP [ANALYZED] INDEX RANGE SCAN EMP_I1 [ANALYZED]

在非唯一索引上，谓词col = 5可能返回多行数据，所以在非唯一索引上都使用索引范围扫描。
使用index rang scan的3种情况：

(a) 在唯一索引列上使用了range操作符(> < <> >= <= between)
(b) 在组合索引上，只使用部分列进行查询，导致查询出多行
(c) 对非唯一索引列上进行的任何查询。
(3) 索引全扫描(index full scan)

与全表扫描对应，也有相应的全索引扫描。而且此时查询出的数据都必须从索引中可以直接得到。
全索引扫描的例子：

            An Index full scan will not perform single block i/o's and so it may prove to be inefficient.
            
e.g.

            Index BE_IX is a concatenated index on big_emp (empno, ename)
            
SQL> explain plan for select empno, ename from big_emp order by empno,ename;

            Query Plan

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

            SELECT STATEMENT[CHOOSE] Cost=26

            INDEX FULL SCAN BE_IX [ANALYZED]
            

(4) 索引快速扫描(index fast full scan)

扫描索引中的所有的数据块，与 index full scan很类似，但是一个显著的区别就是它不对查询出的数据进行排序，即数据不是以排序顺序被返回。在这种存取方法中，可以使用多块读功能，也可以使用并行读入，以便获得最大吞吐量与缩短执行时间。

索引快速扫描的例子：

BE_IX索引是一个多列索引：

big_emp (empno,ename)
            
 
            
SQL> explain plan for select empno,ename from big_emp;

            Query Plan

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

            SELECT STATEMENT[CHOOSE] Cost=1

            INDEX FAST FULL SCAN BE_IX [ANALYZED]
            

只选择多列索引的第2列：

SQL> explain plan for select ename from big_emp; Query Plan ------------------------------------------ SELECT STATEMENT[CHOOSE] Cost=1 INDEX FAST FULL SCAN BE_IX [ANALYZED]

ORACLE执行计划的一些基本概念(2)
三.表之间的连接

Join是一种试图将两个表结合在一起的谓词，一次只能连接2个表，表连接也可以被称为表关联。在后面的叙述中，我们将会使用”row source”来代替”表”，因为使用row source更严谨一些，并且将参与连接的2个row source分别称为row source1和row source 2。Join过程的各个步骤经常是串行操作，即使相关的row source可以被并行访问，即可以并行的读取做join连接的两个row source的数据，但是在将表中符合限制条件的数据读入到内存形成row source后，join的其它步骤一般是串行的。有多种方法可以将2个表连接起来，当然每种方法都有自己的优缺点，每种连接类型只有在特定的条件下才会发挥出其最大优势。

row source(表)之间的连接顺序对于查询的效率有非常大的影响。通过首先存取特定的表，即将该表作为驱动表，这样可以先应用某些限制条件，从而得到一个较小的row source，使连接的效率较高，这也就是我们常说的要先执行限制条件的原因。一般是在将表读入内存时，应用where子句中对该表的限制条件。
根据2个row source的连接条件的中操作符的不同，可以将连接分为等值连接(如WHERE A.COL3 = B.COL4)、非等值连接(WHERE A.COL3 > B.COL4)、外连接(WHERE A.COL3 = B.COL4(+))。上面的各个连接的连接原理都基本一样，所以为了简单期间，下面以等值连接为例进行介绍。

在后面的介绍中，都已：
SELECT A.COL1, B.COL2
FROM A, B
WHERE A.COL3 = B.COL4;
为例进行说明，假设A表为Row Soruce1，则其对应的连接操作关联列为COL 3；B表为Row Soruce2，则其对应的连接操作关联列为COL 4；

连接类型：
目前为止，无论连接操作符如何，典型的连接类型共有3种：
排序 - - 合并连接(Sort Merge Join (SMJ) )
嵌套循环(Nested Loops (NL) )
哈希连接(Hash Join)

排序 - - 合并连接(Sort Merge Join, SMJ)
内部连接过程：
1) 首先生成row source1需要的数据，然后对这些数据按照连接操作关联列(如A.col3)进行排序。
2) 随后生成row source2需要的数据，然后对这些数据按照与sort source1对应的连接操作关联列(如B.col4)进行排序。
3) 最后两边已排序的行被放在一起执行合并操作，即将2个row source按照连接条件连接起来
下面是连接步骤的图形表示：
MERGE
/\
SORTSORT
||
Row Source 1Row Source 2

如果row source已经在连接关联列上被排序，则该连接操作就不需要再进行sort操作，这样可以大大提高这种连接操作的连接速度，因为排序是个极其费资源的操作，特别是对于较大的表。预先排序的row source包括已经被索引的列(如a.col3或b.col4上有索引)或row source已经在前面的步骤中被排序了。尽管合并两个row source的过程是串行的，但是可以并行访问这两个row source(如并行读入数据，并行排序).

SMJ连接的例子：

SQL> explain plan for select /*+ ordered */ e.deptno, d.deptno from emp e, dept d where e.deptno = d.deptno order by e.deptno, d.deptno; Query Plan ------------------------------------- SELECT STATEMENT [CHOOSE] Cost=17 MERGE JOIN SORT JOIN TABLE ACCESS FULL EMP [ANALYZED] SORT JOIN TABLE ACCESS FULL DEPT [ANALYZED]

排序是一个费时、费资源的操作，特别对于大表。基于这个原因，SMJ经常不是一个特别有效的连接方法，但是如果2个row source都已经预先排序，则这种连接方法的效率也是蛮高的。

嵌套循环(Nested Loops, NL)
这个连接方法有驱动表(外部表)的概念。其实，该连接过程就是一个2层嵌套循环，所以外层循环的次数越少越好，这也就是我们为什么将小表或返回较小row source的表作为驱动表(用于外层循环)的理论依据。但是这个理论只是一般指导原则，因为遵循这个理论并不能总保证使语句产生的I/O次数最少。有时不遵守这个理论依据，反而会获得更好的效率。如果使用这种方法，决定使用哪个表作为驱动表很重要。有时如果驱动表选择不正确，将会导致语句的性能很差、很差。

内部连接过程：
Row source1的Row 1 ---------------- Probe ->Row source 2
Row source1的Row 2 ---------------- Probe ->Row source 2
Row source1的Row 3 ---------------- Probe ->Row source 2
…….
Row source1的Row n ---------------- Probe ->Row source 2
从内部连接过程来看，需要用row source1中的每一行，去匹配row source2中的所有行，所以此时保持row source1尽可能的小与高效的访问row source2(一般通过索引实现)是影响这个连接效率的关键问题。这只是理论指导原则，目的是使整个连接操作产生最少的物理I/O次数，而且如果遵守这个原则，一般也会使总的物理I/O数最少。但是如果不遵从这个指导原则，反而能用更少的物理I/O实现连接操作，那尽管违反指导原则吧！因为最少的物理I/O次数才是我们应该遵从的真正的指导原则，在后面的具体案例分析中就给出这样的例子。

在上面的连接过程中，我们称Row source1为驱动表或外部表。Row Source2被称为被探查表或内部表。

在NESTED LOOPS连接中，Oracle读取row source1中的每一行，然后在row sourc2中检查是否有匹配的行，所有被匹配的行都被放到结果集中，然后处理row source1中的下一行。这个过程一直继续，直到row source1中的所有行都被处理。这是从连接操作中可以得到第一个匹配行的最快的方法之一，这种类型的连接可以用在需要快速响应的语句中，以响应速度为主要目标。

如果driving row source(外部表)比较小，并且在inner row source(内部表)上有唯一索引，或有高选择性非唯一索引时，使用这种方法可以得到较好的效率。NESTED LOOPS有其它连接方法没有的的一个优点是：可以先返回已经连接的行，而不必等待所有的连接操作处理完才返回数据，这可以实现快速的响应时间。

如果不使用并行操作，最好的驱动表是那些应用了where 限制条件后，可以返回较少行数据的的表，所以大表也可能称为驱动表，关键看限制条件。对于并行查询，我们经常选择大表作为驱动表，因为大表可以充分利用并行功能。当然，有时对查询使用并行操作并不一定会比查询不使用并行操作效率高，因为最后可能每个表只有很少的行符合限制条件，而且还要看你的硬件配置是否可以支持并行(如是否有多个CPU，多个硬盘控制器)，所以要具体问题具体对待。

NL连接的例子：

SQL> explain plan for select a.dname,b.sql from dept a,emp b where a.deptno = b.deptno; Query Plan ------------------------- SELECT STATEMENT [CHOOSE] Cost=5 NESTED LOOPS TABLE ACCESS FULL DEPT [ANALYZED] TABLE ACCESS FULL EMP [ANALYZED]

哈希连接(Hash Join, HJ)

这种连接是在oracle 7.3以后引入的，从理论上来说比NL与SMJ更高效，而且只用在CBO优化器中。
较小的row source被用来构建hash table与bitmap，第2个row source被用来被hansed，并与第一个row source生成的hash table进行匹配，以便进行进一步的连接。Bitmap被用来作为一种比较快的查找方法，来检查在hash table中是否有匹配的行。特别的，当hash table比较大而不能全部容纳在内存中时，这种查找方法更为有用。这种连接方法也有NL连接中所谓的驱动表的概念，被构建为hash table与bitmap的表为驱动表，当被构建的hash table与bitmap能被容纳在内存中时，这种连接方式的效率极高。

HASH连接的例子：

SQL> explain plan for select /*+ use_hash(emp) */ empno from emp, dept where emp.deptno = dept.deptno; Query Plan ---------------------------- SELECT STATEMENT[CHOOSE] Cost=3 HASH JOIN TABLE ACCESS FULL DEPT TABLE ACCESS FULL EMP

要使哈希连接有效，需要设置HASH_JOIN_ENABLED=TRUE，缺省情况下该参数为TRUE，另外，不要忘了还要设置hash_area_size参数，以使哈希连接高效运行，因为哈希连接会在该参数指定大小的内存中运行，过小的参数会使哈希连接的性能比其他连接方式还要低。

总结一下，在哪种情况下用哪种连接方法比较好：

排序 - - 合并连接(Sort Merge Join, SMJ)：
a) 对于非等值连接，这种连接方式的效率是比较高的。
b) 如果在关联的列上都有索引，效果更好。
c) 对于将2个较大的row source做连接，该连接方法比NL连接要好一些。
d) 但是如果sort merge返回的row source过大，则又会导致使用过多的rowid在表中查询数据时，数据库性能下降，因为过多的I/O。

嵌套循环(Nested Loops, NL)：
a) 如果driving row source(外部表)比较小，并且在inner row source(内部表)上有唯一索引，或有高选择性非唯一索引时，使用这种方法可以得到较好的效率。
b) NESTED LOOPS有其它连接方法没有的的一个优点是：可以先返回已经连接的行，而不必等待所有的连接操作处理完才返回数据，这可以实现快速的响应时间。

哈希连接(Hash Join, HJ)：
a) 这种方法是在oracle7后来引入的，使用了比较先进的连接理论，一般来说，其效率应该好于其它2种连接，但是这种连接只能用在CBO优化器中，而且需要设置合适的hash_area_size参数，才能取得较好的性能。
b) 在2个较大的row source之间连接时会取得相对较好的效率，在一个row source较小时则能取得更好的效率。
c) 只能用于等值连接中

笛卡儿乘积(Cartesian Product)

当两个row source做连接，但是它们之间没有关联条件时，就会在两个row source中做笛卡儿乘积，这通常由编写代码疏漏造成(即程序员忘了写关联条件)。笛卡尔乘积是一个表的每一行依次与另一个表中的所有行匹配。在特殊情况下我们可以使用笛卡儿乘积，如在星形连接中，除此之外，我们要尽量使用笛卡儿乘积，否则，自己想结果是什么吧！

注意在下面的语句中，在2个表之间没有连接。

SQL> explain plan for select emp.deptno,dept,deptno from emp,dept Query Plan ------------------------ SLECT STATEMENT [CHOOSE] Cost=5 MERGE JOIN CARTESIAN TABLE ACCESS FULL DEPT SORT JOIN TABLE ACCESS FULL EMP

CARTESIAN关键字指出了在2个表之间做笛卡尔乘积。假如表emp有n行，dept表有m行，笛卡尔乘积的结果就是得到n * m行结果。

2.取得指定用户的所有视图名称：
SELECT OWNER  AS "对象所有者",VIEW_NAME AS "视图名称" from DBA_VIEWS  where owner = 'RAXNYB'  ORDER BY OWNER,VIEW_NAME; 

Oracle系统表查询
数据字典dict总是属于Oracle用户sys的。
1、用户：
　select username from dba_users;
改口令
　alter user spgroup identified by spgtest;
2、表空间：
　select * from dba_data_files;
　select * from dba_tablespaces;//表空间
　select tablespace_name,sum(bytes), sum(blocks)
from dba_free_space group by tablespace_name;//空闲表空间
　select * from dba_data_files
where tablespace_name='RBS';//表空间对应的数据文件
　select * from dba_segments
where tablespace_name='INDEXS';
3、数据库对象：
　select * from dba_objects;
　CLUSTER、DATABASE LINK、FUNCTION、INDEX、LIBRARY、PACKAGE、PACKAGE BODY、
　PROCEDURE、SEQUENCE、SYNONYM、TABLE、TRIGGER、TYPE、UNDEFINED、VIEW。
4、表：
　select * from dba_tables;
　analyze my_table compute statistics;->dba_tables后6列
　select extent_id,bytes from dba_extents
　where segment_name='CUSTOMERS' and segment_type='TABLE'
　order by extent_id;//表使用的extent的信息。segment_type='ROLLBACK'查看回滚段的空间分配信息
　列信息：
select distinct table_name
from user_tab_columns
where column_name='SO_TYPE_ID';
5、索引：　
　select * from dba_indexes;//索引，包括主键索引
　select * from dba_ind_columns;//索引列
　select i.index_name,i.uniqueness,c.column_name
from user_indexes i,user_ind_columns c
　where i.index_name=c.index_name
　and i.table_name ='ACC_NBR';//联接使用
6、序列：
　select * from dba_sequences;
7、视图：
　select * from dba_views;
　select * from all_views;
text 可用于查询视图生成的脚本
8、聚簇：
　select * from dba_clusters;
9、快照：
　select * from dba_snapshots;
快照、分区应存在相应的表空间。
10、同义词：
　select * from dba_synonyms
where table_owner='SPGROUP';
//if owner is PUBLIC,then the synonyms is a public synonym.
　if owner is one of users,then the synonyms is a private synonym.
11、数据库链：
　select * from dba_db_links;
在spbase下建数据库链
　create database link dbl_spnew
　connect to spnew identified by spnew using 'jhhx';
　insert into acc_nbr@dbl_spnew
　select * from acc_nbr where nxx_nbr='237' and line_nbr='8888';
12、触发器：
　select * from dba_trigers;
存储过程，函数从dba_objects查找。
其文本：select text from user_source where name='BOOK_SP_EXAMPLE';
建立出错：select * from user_errors;
oracle总是将存储过程，函数等软件放在SYSTEM表空间。
13、约束：
（1）约束是和表关联的，可在create table或alter table table_name add/drop/modify来建立、修改、删除约束。
可以临时禁止约束，如：
　alter table book_example
　disable constraint book_example_1;
　alter table book_example
　enable constraint book_example_1;
（2）主键和外键被称为表约束，而not null和unique之类的约束被称为列约束。通常将主键和外键作为单独的命名约束放在字段列表下面，而列约束可放在列定义的同一行，这样更具有可读性。
（3）列约束可从表定义看出，即describe;表约束即主键和外键，可从dba_constraints和dba_cons_columns 查。
　select * from user_constraints
　where table_name='BOOK_EXAMPLE';
　select owner,CONSTRAINT_NAME,TABLE_NAME
from user_constraints
where constraint_type='R'
order by table_name;
（4）定义约束可以无名（系统自动生成约束名）和自己定义约束名（特别是主键、外键）
如：create table book_example
(identifier number not null);
create table book_example
(identifier number constranit book_example_1 not null);
14、回滚段：
在所有的修改结果存入磁盘前，回滚段中保持恢复该事务所需的全部信息，必须以数据库发生的事务来相应确定其大小（DML语句才可回滚，create,drop,truncate等DDL不能回滚）。
回滚段数量=并发事务/4，但不能超过50；使每个回滚段大小足够处理一个完整的事务；
　create rollback segment r05
　tablespace rbs;
　create rollback segment rbs_cvt
　tablespace rbs
　storage(initial 1M next 500k);
使回滚段在线
　alter rollback segment r04 online;
用dba_extents,v$rollback_segs监测回滚段的大小和动态增长。
回滚段的区间信息
　select * from dba_extents
　where segment_type='ROLLBACK' and segment_name='RB1';
回滚段的段信息,其中bytes显示目前回滚段的字节数
　select * from dba_segments
where segment_type='ROLLBACK' and segment_name='RB1';
为事物指定回归段
　set transaction use rollback segment rbs_cvt
针对bytes可以使用回滚段回缩。
　alter rollback segment rbs_cvt shrink;
　select bytes,extents,max_extents from dba_segments
where segment_type='ROLLBACK' and segment_name='RBS_CVT';
回滚段的当前状态信息：
　select * from dba_rollback_segs
where segment_name='RB1';
比多回滚段状态status，回滚段所属实例instance_num
查优化值optimal
　select n.name,s.optsize
from v$rollname n,v$rollstat s
　where n.usn=s.usn;
回滚段中的数据
　set transaction use rollback segment rb1;/*回滚段名*/
　select n.name,s.writes
from v$rollname n,v$rollstat s
　where n.usn=s.usn;
当事务处理完毕，再次查询$rollstat，比较writes(回滚段条目字节数)差值，可确定事务的大小。
查询回滚段中的事务
　column rr heading 'RB Segment' format a18
　column us heading 'Username' format a15
　column os heading 'Os User' format a10
　column te heading 'Terminal' format a10
　select r.name rr,nvl(s.username,'no transaction') us,s.osuser os,s.terminal te
from v$lock l,v$session s,v$rollname r
　where l.sid=s.sid(+)
　and trunc(l.id1/65536)=R.USN
　and l.type='TX'
　and l.lmode=6
　order by r.name;
15、作业
查询作业信息
　select job,broken,next_date,interval,what from user_jobs;
　select job,broken,next_date,interval,what from dba_jobs;
查询正在运行的作业
　select * from dba_jobs_running;
使用包exec dbms_job.submit(:v_num,'a;',sysdate,'sysdate + (10/(24*60*60))')加入作业。间隔10秒钟
exec dbms_job.submit(:v_num,'a;',sysdate,'sysdate + (11/(24*60))')加入作业。间隔11分钟使用包exec dbms_job.remove(21)删除21号作业。

　　对于表而言(常规意义上的堆组织表)，上述分区形式都可以应用(甚至可以对某个分区指定compress属性)，只不过分区依赖列不能是lob,long之类数据类型，每个表的分区或子分区数的总数不能超过1023个。

　　对于索引组织表，只能够支持普通分区方式，不支持组合分区，常规表的限制对于索引组织表同样有效，除此之外呢，还有一些其实的限制，比如要求索引组织表的分区依赖列必须是主键才可以等。

　　注：本篇所有示例仅针对常规表，即堆组织表!

　　对于索引，需要区分创建的是全局索引，或本地索引：

　　l 全局索引(global index)：即可以分区，也可以不分区。即可以建range分区，也可以建hash分区，即可建于分区表，又可创建于非分区表上，就是说，全局索引是完全独立的，因此它也需要我们更多的维护操作。

　　l 本地索引(local index)：其分区形式与表的分区完全相同，依赖列相同，存储属性也相同。对于本地索引，其索引分区的维护自动进行，就是说你add/drop/split/truncate表的分区时，本地索引会自动维护其索引分区。

　　Oracle建议如果单个表超过2G就最好对其进行分区，对于大表创建分区的好处是显而易见的，这里不多论述why，而将重点放在when以及how。

　　WHEN

　　一、When使用Range分区

　　Range分区呢是应用范围比较广的表分区方式，它是以列的值的范围来做为分区的划分条件，将记录存放到列值所在的range分区中，比如按照时间划分，2008年1季度的数据放到a分区，08年2季度的数据放到b分区，因此在创建的时候呢，需要你指定基于的列，以及分区的范围值，如果某些记录暂无法预测范围，可以创建maxvalue分区，所有不在指定范围内的记录都会被存储到maxvalue所在分区中，并且支持指定多列做为依赖列，后面在讲how的时候会详细谈到。

　　二、When使用Hash分区

　　通常呢，对于那些无法有效划分范围的表，可以使用hash分区，这样对于提高性能还是会有一定的帮助。hash分区会将表中的数据平均分配到你指定的几个分区中，列所在分区是依据分区列的hash值自动分配，因此你并不能控制也不知道哪条记录会被放到哪个分区中，hash分区也可以支持多个依赖列。

　　三、When使用List分区

　　List分区与range分区和hash分区都有类似之处，该分区与range分区类似的是也需要你指定列的值，但这又不同与range分区的范围式列值---其分区值必须明确指定，也不同与hash分区---通过明确指定分区值，你能控制记录存储在哪个分区。它的分区列只能有一个，而不能像range或者hash分区那样同时指定多个列做为分区依赖列，不过呢，它的单个分区对应值可以是多个。

　　你在分区时必须确定分区列可能存在的值，一旦插入的列值不在分区范围内，则插入/更新就会失败，因此通常建议使用list分区时，要创建一个default分区存储那些不在指定范围内的记录，类似range分区中的maxvalue分区。

　　四、When使用组合分区

　　如果某表按照某列分区之后，仍然较大，或者是一些其它的需求，还可以通过分区内再建子分区的方式将分区再分区，即组合分区的方式。

　　组合分区呢在10g中有两种：range-hash，range-list。注意顺序哟，根分区只能是range分区，子分区可以是hash分区或list分区。

　　提示：11g在组合分区功能这块有所增强，又推出了range-range,list-range,list-list,list-hash，这就相当于除hash外三种分区方式的笛卡尔形式都有了。为什么会没有hash做为根分区的组合分区形式呢，再仔细回味一下第二点，你一定能够想明白~~。

　　如果想对某个表做分区，必须在创建表时就指定分区，我们可以对一个包含分区的表中的分区做修改，但不能直接将一个未分区的表修改成分区表(起码在10g是不行的，当然你可能会说，可以通过在线重定义的方式，但是这不是直接哟，这也是借助临时表间接实现的)。

　　创建表或索引的语法就不说了，大家肯定比我还熟悉，而想在建表(索引)同时指定分区也非常容易，只需要把创建分区的子句放到";"前就行啦，同时需要注意表的row movement属性，它用来控制是否允许修改列值所造成的记录移动至其它分区存储，有enable|disable两种状态，默认是disable row movement，当disable时，如果记录要被更新至其它分区，则更新语句会报错。

　　下面分别演示不同分区方式的表和索引的创建：

　　1、创建range分区

　　语法如下，图：[range_partitioning.gif]

　　需要我们指定的有：

　　l column:分区依赖列(如果是多个，以逗号分隔);

　　l partition:分区名称;

　　l values less than:后跟分区范围值(如果依赖列有多个，范围对应值也应是多个，中间以逗号分隔);

　　l tablespace_clause:分区的存储属性，例如所在表空间等属性(可为空)，默认继承基表所在表空间的属性。

　　①　创建一个标准的range分区表：

JSSWEB> create table t_partition_range (id number,name varchar2(50)) 　　2 partition by range(id)( 　　3 partition t_range_p1 values less than (10) tablespace tbspart01, 　　4 partition t_range_p2 values less than (20) tablespace tbspart02, 　　5 partition t_range_p3 values less than (30) tablespace tbspart03, 　　6 partition t_range_pmax values less than (maxvalue) tablespace tbspart04 　　7 );

　　表已创建。

　　user_part_tables：记录分区的表的信息;

　　user_tab_partitions：记录表的分区的信息。

　　例如：

JSSWEB> select table_name,partitioning_type,partition_count   2  From user_part_tables where table_name='T_PARTITION_RANGE'; TABLE_NAME                     PARTITI PARTITION_COUNT ------------------------------ ------- --------------- T_PARTITION_RANGE              RANGE                 4 JSSWEB> select partition_name,high_value,tablespace_name   2  from user_tab_partitions where table_name='T_PARTITION_RANGE'   3  order by partition_position; PARTITION_NAME                 HIGH_VALUE TABLESPACE_NAME ------------------------------ ---------- -------------------- T_RANGE_P1                     10         TBSPART01 T_RANGE_P2                     20         TBSPART02 T_RANGE_P3                     30         TBSPART03 T_RANGE_PMAX                   MAXVALUE   TBSPART04

JSSWEB> create index idx_parti_range_id on t_partition_range(id) 　　2 global partition by range(id)( 　　3 partition i_range_p1 values less than (10) tablespace tbspart01, 　　4 partition i_range_p2 values less than (40) tablespace tbspart02, 　　5 partition i_range_pmax values less than (maxvalue) tablespace tbspart03);

　　索引已创建。

　　由上例可以看出，创建global索引的分区与创建表的分区语句格式完全相同，而且其分区形式与索引所在表的分区形式没有关联关系。

　　注意：我们这里借助上面的表t_partition_range来演示创建range分区的global索引，并不表示range分区的表，只能创建range分区的global索引，只要你想，也可以为其创建hash分区的global索引。

　　查询索引的分区信息可以通过user_part_indexes、user_ind_partitions两个数据字典：

JSSWEB> select index_name, partitioning_type, partition_count   2    From user_part_indexes   3   where index_name = 'IDX_PARTI_RANGE_ID'; INDEX_NAME                     PARTITI PARTITION_COUNT ------------------------------ ------- --------------- IDX_PARTI_RANGE_ID             RANGE                 3 JSSWEB> select partition_name, high_value, tablespace_name   2    from user_ind_partitions   3   where index_name = 'IDX_PARTI_RANGE_ID'   4   order by partition_position; PARTITION_NAME                 HIGH_VALUE TABLESPACE_NAME ------------------------------ ---------- -------------------- I_RANGE_P1                     10         TBSPART01 I_RANGE_P2                     40         TBSPART02 I_RANGE_PMAX                   MAXVALUE   TBSPART03

　　仍然借助t_partition_range表来创建索引

　　--首先删除之前创建的global索引

　　JSSWEB> drop index IDX_PARTI_RANGE_ID;

　　索引已删除。

　　JSSWEB> create index IDX_PARTI_RANGE_ID on T_PARTITION_RANGE(id) local;

　　索引已创建。

　　查询相关数据字典：

JSSWEB> select index_name, partitioning_type, partition_count   2    From user_part_indexes   3   where index_name = 'IDX_PARTI_RANGE_ID'; INDEX_NAME                     PARTITI PARTITION_COUNT ------------------------------ ------- --------------- IDX_PARTI_RANGE_ID             RANGE                 4 JSSWEB> select partition_name, high_value, tablespace_name   2    from user_ind_partitions   3   where index_name = 'IDX_PARTI_RANGE_ID'   4   order by partition_position; PARTITION_NAME                 HIGH_VALUE TABLESPACE_NAME ------------------------------ ---------- -------------------- T_RANGE_P1                     10         TBSPART01 T_RANGE_P2                     20         TBSPART02 T_RANGE_P3                     30         TBSPART03 T_RANGE_PMAX                   MAXVALUE   TBSPART04

　　不过呢分区名称，以及分区所在表空间等信息是可以自定义的，例如：

SQL> create index IDX_PART_RANGE_ID ON T_PARTITION_RANGE(id) local ( 　　2 partition i_range_p1 tablespace tbspart01, 　　3 partition i_range_p2 tablespace tbspart01, 　　4 partition i_range_p3 tablespace tbspart02, 　　5 partition i_range_pmax tablespace tbspart02 　　6 );

　　索引已创建。

SQL> select index_name, partitioning_type, partition_count   2   From user_part_indexes   3  where index_name = 'IDX_PART_RANGE_ID'; INDEX_NAME                     PARTITI PARTITION_COUNT ------------------------------ ------- --------------- IDX_PART_RANGE_ID              RANGE                 4 SQL> select partition_name, high_value, tablespace_name   2   from user_ind_partitions   3  where index_name = 'IDX_PART_RANGE_ID'   4  order by partition_position; PARTITION_NAME  HIGH_VALUE      TABLESPACE_NAME --------------- --------------- -------------------- I_RANGE_P1      10              TBSPART01 I_RANGE_P2      20              TBSPART01 I_RANGE_P3      30              TBSPART02 I_RANGE_PMAX    MAXVALUE        TBSPART02

　　语法如下：[图:hash_partitioning.gif]

　　语法看起来比range复杂，其实使用起来比range更简单，这里需要我们指定的有：

　　l column:分区依赖列(支持多个，中间以逗号分隔);

　　l partition:指定分区，有两种方式：

　　n 直接指定分区名，分区所在表空间等信息

　　n 只指定分区数量，和可供使用的表空间。

　　①　创建hash分区表

JSSWEB> create table t_partition_hash (id number,name varchar2(50)) 　　2 partition by hash(id)( 　　3 partition t_hash_p1 tablespace tbspart01, 　　4 partition t_hash_p2 tablespace tbspart02, 　　5 partition t_hash_p3 tablespace tbspart03);

　　表已创建。

　　要实现同样效果，你还可以这样：

JSSWEB> create table t_partition_hash2 (id number,name varchar2(50)) 　　2 partition by hash(id) 　　3 partitions 3 store in(tbspart01,tbspart02,tbspart03);

　　表已创建。

　　提示：这里分区数量和可供使用的表空间数量之间没有直接对应关系。分区数并不一定要等于表空间数。

　　要查询表的分区信息，仍然是通过user_part_tables,user_tab_partitions两个数据字典，这里不再举例。

　　②　Global索引hash分区

　　Hash分区索引的子句与hash分区表的创建子句完全相同，例如：

JSSWEB> create index idx_part_hash_id on t_partition_hash(id) 　　2 global partition by hash(id) 　　3 partitions 3 store in(tbspart01,tbspart02,tbspart03);

　　索引已创建。

　　查询索引的分区信息也仍是通过user_part_indexes、user_ind_partitions两个数据字典，不再举例。

　　③　创建Local索引

　　在前面学习range分区时，我们已经对Local索引的特性做了非常清晰的概述，因此这里也不再举例，如有疑问，建议再仔细复习range分区的相关示例，如果还有疑问，当面问我好了:)

　　综上：

　　Ø 对于global索引分区而言，在10g中只能支持range分区和hash分区，因此后续示例中不会再提及。

　　Ø 对于local索引分区而言，其分区形式完全依赖于索引所在表的分区形式，不管从创建语法还是理解难度均无技术含量，因此后续也不再提供示例。

　　Ø 注意，在创建索引时如果不显式指定global或local，则默认是global。

　　Ø 注意，在创建global索引时如果不显式指定分区子句，则默认不分区(废话)。
全面学习Oracle分区表及分区索引(4)-创建list分区

　　创建语法如下：[图：list_partitioning.gif]

　　需要我们指定的有：

　　l column:分区依赖列，注意：只能是一个;

　　l partition:分区名称;

　　l literal:分区对应值，注意：每个分区可以对应多个值;

　　l tablespace_clause:分区的存储属性，例如所在表空间等属性(可为空)，默认继承基表所在表空间的属性。

　　创建list分区表示例：

　　JSSWEB> create table t_partition_list (id number,name varchar2(50))

　　2 partition by list(id)(

　　3 partition t_list_p1 values (1,2,3,4,5,6,7,8,9) tablespace tbspart01,

　　4 partition t_list_p2 values (10,11,12,13,14,15,16,17,18,19) tablespace tbspart02,

　　5 partition t_list_p3 values (20,21,22,23,24,25,26,27,28,29) tablespace tbspart03,

　　6 partition t_list_pd values (default) tablespace tbspart04);

　　表已创建。

　　上例能够实现与前面range分区示例相同的效果，当然针对本示例而言，list分区显然不好用啊~~~

存储过程（stored procedure）允许将运行于数据库层中的持久性逻辑与运行于中间层中的商务逻辑有效地分离开来。这种分离可以降低整个应用程序的复杂性，并提供其重用性、安全性、性能和可伸缩性。

但是，妨碍存储过程广泛采用的一个主要障碍是不同数据库厂商使用各种专有的、且依赖于数据库的实现语言。使用基于Java的存储过程可以解决这一问题。Oracle已经实现了ANSI标准，这些标准规定了从SQL中将静态Java方法作为过程或函数进行调用的能力。这种实现被简单地称作"Java存储过程"。

在本文中，你将了解基于Java的存储过程如何帮助简化商务逻辑、提高其性能，并扩展数据库的功能。本文将介绍Oracle如何在数据库内启用基于Java的存储过程。还会介绍Java存储过程如何访问数据，以及如何创建基本Java存储过程。

选择PL/SQL还是Java

在考虑Oracle存储过程时，你可能会想到PL/SQL。不过，从Oracle8i开始，Oracle已经在数据库中支持Java，从而为存储过程提供了不同于PL/SQL的开放式和可移植的方法。我可以听到"$64 000问题"："我如何在PL/SQL和Java之间做出选择？我是否应当忘记已经学习的所有PL/SQL相关知识，而变为一个Java天地的新手？"

两种语言都适用于数据库编程，都有自己的优点和弱点。在决定选择哪一种语言时，可以参考下面根据经验得出的通用规则：

对于要求与SQL进行无缝集成的数据库中心来说则逻辑使用PL/SQL，从而完成对数据库对象、类型和特性的访问。

出于与数据库的无关性考虑时，可以选择Java作为开放式的语言来取代PL/SQL，同时也为了集成和沟通SQL、XML、J2EE和Web服务等各个领域。
OralceJVM使得Java可以运行在数据库中

从Oracle8i版本1（Oralce8.1.5）开始，Oracle便提供紧密集成的Java虚拟机（JVM），JVM支持Oralce的数据库会话期结构。任何数据库对话期都可以在第一Java代码调用时启动一个虚拟上专用的JVM，后续的用户可以使用这一已经存在的支持Java的会话期。事实上，所有会话共享同一JVM代码并保持"仅静态"的私有状态，而垃圾则收集在单个对话期空间内，从而为各个Java对话期提供了和SQL操作相同的对话期隔离和数据完整性能力。这里，不需要为了数据完整性而进行单独的Java支持的过程。这一基于对话期的结构提供了较小的内存占用率，并使OracleJVM具有与Oracle数据库一样的线性SMP可伸缩性。

创建Java存储过程

要将Java方法转换为Java存储过程需要几个步骤，包括：用loadjava实用程序将Java类加载到数据库中，利用调用规范（Call Spec）发布Java方法，将Java方法、参数类型和返回类型映射到其SQL的对应部分。下面部分说明如何完成这些步骤。

我将使用一个简单的Hello类，它有一个方法Hello.world()，返回字符串"Hello world"：

public class Hello { public static String world () { return "Hello world"; } }
Loadjava 实用程序

Loadjava是加载Java源文件、Java类文件和Java资源文件的实用程序，它可以用来验证字节码，并将Java类和JAR文件布置到数据库中。它既可以通过命令行调用，也可以通过包含于DBMS_JAVA类中的loadjava()方法调用。为了加载我们的Hello.class示例，输入：

loadjava -user scott/tiger Hello.class

从Oracle9i版本2开始，loadjava允许通过为包含在被处理的类中的方法创建相应的Call Specs来自动将Java类发布为存储过程。Oracle为开发、测试、调试和布置Java存储过程提供了Oracle9i JDeveloper。

The Resolver Spec

基于JDK的JVM在列于CLASSPATH中的目录中查找类引用，并对其进行解析。因为Oracle数据库类存在于数据库模式中，所以OracleJVM利用数据库解析器（resolver）通过列于Resolver Spec中的模式查找并解析类引用。与CLASSPATH不同（CLASSPATH可以应用于所有的类），Resover Spec根据每类的情况进行应用。缺省解析器首先在加载类的模式中搜寻类，然后在公共同义词（public synonyms）中搜索。

 loadjava -resolve <myclass>
你可能需要指定不同的解析器，也可以在使用loadjava时强制进行解析，从而在布置时确定可能在以后运行时发生的任何问题。

loadjava -resolve -resolver "((* SCOTT) (foo/bar/* OTHERS) (* PUBLIC))"
Call Spec和存储过程调用

为了从SQL中调用Java方法（以及从PL/SQl和JDBC中调用），必须首先通过Call Spec发布公共静态方法，它为SQL定义方法采用的参数以及返回的SQL类型。

在我们的例子中，我们将利用SQL＊Plus连接到数据库，并为Hello.world()定义一个顶级Call Spec：

SQL> connect scott/tiger SQL> create or replace function helloworld return VARCHAR2 as language java name 'Hello.world () return java.lang.String'; / Function created.
可以像下面这样调用Java存储过程：

SQL> variable myString varchar2[20]; SQL> call helloworld() into :myString; Call completed. SQL> print myString; MYSTRING --------------------- Hello world
Java存储过程可以通过其Call Spec从以下各项中进行调用：SQL DML语句（INSERT, UPDATE、DELETE、SELECT、CALL、EXPLAIN PLAN、LOCK TABLE和MERGE）、PL/SQL块、子程序、程序包以及数据库触发器。Call Spec的美妙之处在于存储过程实现可以从PL/SQL转换为Java，反之亦可，这一点对于请求者是透明的。

Call Spec从实现语言中（PL/SQL或Java）中抽象出调用界面，因而使之能够在原有应用程序和新的基于Java／J2EE的应用程序之间共享商务逻辑。但是，在从Java客户程序调用在数据库驻留的Java类时，你可能不希望通过PL/SQL包装器(wrapper)。在以后的版本中，Oracle计划提供一种机制，它可以使开发人员略过Call Spec。

高级数据访问控制

Java存储过程可用于控制和限制对Oracle数据的访问，其方法是只允许用户通过存储过程管理数据，而存储过程在其调用者的权限内执行，而不能对表本身进行访问。例如，你可以在特定时间内禁止更新数据，或者使管理者只具有查询工资数据的权利，而不能进行更新，或者记录所有的访问并通知某一安全机构。

原有应用程序与J2EE应用程序之间的数据逻辑共享

因为原有应用程序与J2EE应用程序都通过Call Spec调用存储过程，所以J2EE和非J2EE应用程序可以共享相同的数据逻辑。由于有了Call Spec，所以不用考虑所用的是何种实现语言（无论是PL/SQL还是Java），该数据逻辑都可以共享。

为BMP实体Bean自动生成主关键字

在对EJB实体bean应用BMP时，一个bean实例可以由自动生成的与新插入的数据相关联的主关键字惟一确定，它是ejbCreate()的返回值。可以利用一个插入相应数据的存储过程在一个数据库操作中检索ejbCeater()中的该值，并检索或计算主关键字。作为另一种方法，也可以利用JDBC3.0的RETURN_GENERATED_KEYS特性，以一个SQL语句插入该数据并检索相应的关键字（或ROWID）。但是，存储过程方法在各个JDBC驱动器版本和数据库之间更具可移植性。

可以用以下三个步骤实现这一模式：

定义Call Spec

CREATE OR REPLACE PROCEDURE insertAccount(owner IN varchar, bal IN number, newid OUT number) AS LANGUAGE JAVA NAME 'GenPK.insertAccount( java.lang.String [])'; /

在ejbCreate()内调用存储过程

Public AccountPK ejbCreate(String ownerName, int balance) throws CreateException { try { CallableStatement call = conn.prepareCall{ "{call insertAccount(?, ?, ?)}"}; return new AccountPK(accountID); } }
为CMP实体Bean定制主关键字查找器

查找器方法（Finder methods）用于检索已存在的EJB实体bean实例。主关键字查找器使你能够检索惟一标识的EJB实例。对于CMP实体bean，EJB容器根据声明描述，自动生成主关键字查找器findByPrimaryKey()方法。但是，在某些情况下，可能需要更多的控制，例如可能需要专门的查找器，如findByStoredProcKey()。在这些情况下，你可以结合使用Java存储过程和对象关系框架（如Oracle9i应用服务器[Oracle9iAS] TopLink）来实现定制的主关键字查找器方法。在将EJB查找器定义为REDIRECT或NAMED查找器后，TopLink将生成一个SQL查询用于检索bean实例。

数据驱动的EJB调用

在数据驱动体系结构中，商务逻辑调用可以作为数据库操作（如插入、更新或删除）的结果来触发。实现该数据逻辑的Java存储过程可以被声明为数据库触发器，用以调用运行于中间层J2EE应用服务器的EJB。EJB的调用既可以采用J2EE1.3兼容的服务器通过Interoperable Inter-ORB Protocol（IIOP）标准远程方法调用（remote method invocation，RMI）实现，也可以通过销售商特定的传输协议（如Oracle9iAS/Oc4J的ORMI，或者通过BEA WebLogic的T3）用RMI来实现。每个应用服务器提供商在提供基于IIOP的RMI，以提供互操作性的同时，都有其自己优化的协议。Oracle9iAS同时支持基于IIOP的RMI调用和基于ORMI协议的RMI调用。

数据驱动的消息传送

Oracle9i数据库嵌入了Advanced Queuing（AQ，高级排队），它是一种集成的、稳定、可靠、安全、可扩展和事务处理式的消息排队框架。Oracle通过标准的Java消息传送系统（Java Messaging System，JMS）API为Java开发人员提供AQ功能。Java存储过程可以通过JMS接口调用AQ操作，从而能够实现快速、在会话期内、可扩展的、数据驱动的消息传送。

Java存储过程可以利用JMS调用AQ操作。可以用以下4个步骤实现这一模式：

创建并启动JMS Queue（为此，可以将以下一些操作嵌入SQL脚本内）：

execute dbms_aqadm.create_queue_table(queue_table => 'queue1', queue_payload_type => 'SYS.AQ$_JMS_TEXT_MESSAGE', comment => 'a test queue', multiple_consumers => false, compatible => '8.1.0'); execute dbms_aqadm.create_queue( queue_name => 'queue1', queue_table => 'queue1' ); execute dbms_aqadm.start_queue(queue_name => 'queue1');

创建Java存储过程（代码摘录如下）：

public static void runTest(String msgBody) { try { // get database connection ora_drv = new OracleDriver(); db_conn = ora_drv.defaultConnection(); // setup sender (cf online code sample) .. // create message s_msg = s_session.createTextMessage(msgBody); // send message sender.send(s_msg); s_session.commit(); // receive message r_msg = (TextMessage) receiver.receive(); r_session.commit(); // output message text String body = r_msg.getText(); System.out.println("message was '"+body+"'"); ..} }

创建Call Spec：

create or replace procedure jmsproc (t1 IN VARCHAR) as language java name 'jmsSample.main (java.lang.String[])'; /

调用存储过程：

call jmsproc('hello');
数据库辅助的Web发布（缓冲失效）

各应用程序结构必须面对的一个共同问题是如果可靠地将数据库信息进行缓存，以提高整个系统的性能。JCACHE是一种即将公布的标准规范（JSR 107），它可以解决这一问题。它说明了一种对Java对象临时在内存中进行缓存的方法，包括对象的创建、共享访问、假脱机（spooling）、失效、各JVM的一致性等。它可被用于缓存JSP内最经常读取的数据，如产品目录和价格列表。利用JCACHE，多数查询的反应时间会因为有缓存的数据而加快（内部测试表明反应时间大约快15倍）。

为了跟踪原始数据的所有变化，并刷新已缓存的数据，Java存储过程会作为一个触发器被附加在一个表上。这个表的任何变化都会自动调用该存储过程，后者再调出一个已定义的JSP使JCACHE对象失效，该对象将其状态映射到该数据库表。在失效时，紧跟其后的查询将强制缓存器根据数据库的数据进行更新。 下面的步骤
阅读关于Java存储过程的更多信息
本文摘自白皮书"释放Java存储过程的能量（Unleash the Power of Java Stored Procedures）"，可以在以下位置找到该白皮书：
otn.oracle.com/tech/java/java_db/pdf/
OW_30820_JAVA_STORED_PROC_paper.PDF

Oracle9i数据库第2版中的新PL/SQL特性
otn.oracle.com/tech/pl_sql/pdf/
Paper_30720_Doc.pdf

Resolver Spec
otn.oracle.com/docs/products/oracle9i/
doc_library/release2/java.920/a96659.pdf

OracleJVM and Java 2 Security
otn.oracle.com/docs/products/oracle9i/
doc_library/release2/java.920/a96656.pdf

下载代码
练习本文中的代码示例：
otn.oracle.com/sample_code/tech/
java/jsp/Oracle9iJSPSamples.html

了解作为Web服务的存储过程
otn.oracle.com/tech/webservices
 

扩展数据库的功能

在数据库中直接运行Java代码的一个妙处就在于要实现新的功能，只需要简单地加载代码或库，并利用Call Spec制作可用于SQL、PL/SQL、Java、J2EE和非Java API的进入点（公共静态方法）。Oracle9i数据库用户可以很容易地扩展数据库

沟通SQL、PL/SQL、Java、J2EE、.NET和XML

Oracle XDK是用Java编写的，并将其公共方法可用作Java存储过程，从而扩展了数据库的XML可编程能力。SQL、PL/SQL、Java、J2EE和非Java（.NET）商务逻辑都能够访问XML分析器、XSLT处理器、XPath引擎和XML SQL Utility（XSU）。

XML分析器可以通过xmlparser和xmldom包进行访问。XSU是一种Java实用程序，它可以由SQL查询结果或JDBC ResultSet生成XML文档，并将XML文档中的数据写入数据库表或视图中。利用XSU，XML输出可以输出为文本、Dom树或DTS。通过dbms_xmlquery和dbms_xmlsave包，XSU即可用于PL/SQL。

结论

Oracle数据库与Java VM的集成可以创建可移植、功能强大和与数据库无关的数据逻辑和持续性逻辑（persistence logic）。运行于中间层的商务逻辑和运行于数据库层的数据逻辑之间的分离提高了应用程序的可扩展性、灵活性和可维护性。

小菜毛毛 2010-02-04 12:48 发表评论

]]>

Java代码

1. select * from dba_registry where comp_id = 'JAVAVM'  

select * from dba_registry where comp_id = 'JAVAVM'

Java代码

1. create or replace function fn_oraclecall(mArea in VARCHAR2,mDevID in Number,mPORT in Number)   
2. return varchar2   
3. as   
4. language java name 'Caller.call(java.lang.String,Integer,Integer) return java.lang.String';  

create or replace function fn_oraclecall(mArea in VARCHAR2,mDevID in Number,mPORT in Number)
return varchar2
as
language java name 'Caller.call(java.lang.String,Integer,Integer) return java.lang.String';

Java代码

1. create or replace procedure CHK_SETCAB_NUM   
2. (mArea in VARCHAR2,mDevID in Number,mPORT in Number,v_out out varchar2) is   
3. begin   
4. v_out := fn_oraclecall(mArea,mDevID,mPORT);   
5. end CHK_SETCAB_NUM;  

create or replace procedure CHK_SETCAB_NUM
(mArea in VARCHAR2,mDevID in Number,mPORT in Number,v_out out varchar2) is
begin
v_out := fn_oraclecall(mArea,mDevID,mPORT);
end CHK_SETCAB_NUM;

Java代码

1. loadjava -u sys/sys@sid  -oci8 -verbose -grant user -synonym -resolve -schema user D:\Caller.jar   
2. --这里也可以是class文件,注意兼容oracle的jre版本  

loadjava -u sys/sys@sid  -oci8 -verbose -grant user -synonym -resolve -schema user D:\Caller.jar
--这里也可以是class文件,注意兼容oracle的jre版本

一、如何创建java存储过程？
通常有三种方法来创建java存储过程。

1. 使用oracle的sql语句来创建：

e.g. 使用create or replace and compile java source named "<name>" as
       后边跟上java源程序。要求类的方法必须是public static的，才能用于存储过程。

SQL> create or replace and compile java source named "javademo1"
  2  as
  3  import java.sql.*;
  4  public class JavaDemo1
  5  {
  6  public static void main(String[] argv)
  7  {
  8  System.out.println("hello, java demo1");
  9  }
 10  }
 11  /

Java 已创建。

SQL> show errors java source "javademo1"
没有错误。

SQL> create or replace procedure javademo1
  2  as
  3  language java name ''JavaDemo1.main(java.lang.String[])'';
  4  /

过程已创建。

SQL> set serveroutput on
SQL> call javademo1();

调用完成。

SQL> call dbms_java.set_output(5000);

调用完成。

SQL> call javademo1();
hello, java demo1

调用完成。

SQL> call javademo1();
hello, java demo1
调用完成。
2. 使用外部class文件来装载创建
e.g. 这里既然用到了外部文件，必然要将class文件放到oracle Server的某一目录下边。

public class OracleJavaProc
{
    public static void main(String[] argv)
    {
        System.out.println("It''s a Java Oracle procedure.");
    }
}

SQL> grant create any directory to scott;

授权成功。

SQL> conn scott/tiger@iihero.oracledb
已连接。
SQL> create or   replace   directory   test_dir   as  ''d:\oracle'';

目录已创建。

SQL> create or replace java class using bfile(test_dir, ''OracleJavaProc.CLASS'')
  2  /

Java 已创建。

SQL> create or replace procedure testjavaproc as language java name ''OracleJavaProc.main(java.lang.String[])'';
  2  /

过程已创建。

SQL> call testjavaproc();

调用完成。

SQL> execute testjavaproc;

PL/SQL 过程已成功完成。

SQL> set serveroutput on size 5000
SQL> call dbms_java.set_output(5000);

调用完成。

SQL> execute testjavaproc;
It''s a Java Oracle procedure.
3. 我推荐的一种方法，直接使用loadjava命令远程装载并创建。
    先创建一个类, e.g.

import java.sql.*;
import oracle.jdbc.*;

public class OracleJavaProc ...{

   //Add a salgrade to the database.
   public static void addSalGrade(int grade, int losal, int hisal) ...{

      System.out.println("Creating new salgrade for EMPLOYEE...");

      try ...{
         Connection conn =
            DriverManager.getConnection("jdbc:default:connection:");

         String sql =
            "INSERT INTO salgrade " +
            "(GRADE,LOSAL,HISAL) " +
            "VALUES(?,?,?)";
         PreparedStatement pstmt = conn.prepareStatement(sql);
         pstmt.setInt(1,grade);
         pstmt.setInt(2,losal);
         pstmt.setInt(3,hisal);
         pstmt.executeUpdate();
         pstmt.close();
         }
      catch(SQLException e) ...{
         System.err.println("ERROR! Adding Salgrade: "
           + e.getMessage());
         }
   }
}
使用loadjava命令将其装载到服务器端并编译：

D:eclipse3.1workspacedbtest>loadjava -u scott/tiger@iihero.oracledb -v -resolve Or
acleJavaProc.java
arguments: ''-u'' ''scott/tiger@iihero.oracledb ''-v'' ''-resolve'' ''OracleJavaProc.java''
creating : source OracleJavaProc
loading  : source OracleJavaProc
resolving: source OracleJavaProc
查询一下状态：

连接到:
Oracle9i Enterprise Edition Release 9.2.0.1.0 - Production
With the Partitioning, OLAP and Oracle Data Mining options
JServer Release 9.2.0.1.0 - Production

SQL> SELECT object_name, object_type, status FROM user_objects WHERE object_type LIKE ''JAVA%'';

OBJECT_NAME
--------------------------------------------------------------------------------

OBJECT_TYPE                          STATUS
------------------------------------ --------------
OracleJavaProc
JAVA CLASS                           VALID

OracleJavaProc
JAVA SOURCE                          VALID
测试一下存储过程：

SQL> create or replace procedure add_salgrade(id number, losal number, hisal num
ber) as language java name ''OracleJavaProc.addSalGrade(int, int, int)'';
  2  /

过程已创建。

SQL> set serveroutput on size 2000
SQL> call dbms_java.set_output(2000);

调用完成。

SQL> execute add_salgrade(6, 10000, 15000);
Creating new salgrade for EMPLOYEE...

PL/SQL 过程已成功完成。

SQL> select * from salgrade where grade=6;

     GRADE      LOSAL      HISAL
---------- ---------- ----------
         6      10000      15000
 

二、如何更新你已经编写的java存储过程？ 

假如要往类OracleJavaProc里添加一个存储过程方法，如何开发？
正确的步骤应该是先dropjava, 改程序，再loadjava。

e.g.修改OracleJavaProc类内容如下：

import java.sql.*;
import oracle.jdbc.*;

public class OracleJavaProc ...{

   // Add a salgrade to the database.
   public static void addSalGrade(int grade, int losal, int hisal) ...{

      System.out.println("Creating new salgrade for EMPLOYEE...");

      try ...{
         Connection conn =
            DriverManager.getConnection("jdbc:default:connection:");

         String sql =
            "INSERT INTO salgrade " +
            "(GRADE,LOSAL,HISAL) " +
            "VALUES(?,?,?)";
         PreparedStatement pstmt = conn.prepareStatement(sql);
         pstmt.setInt(1,grade);
         pstmt.setInt(2,losal);
         pstmt.setInt(3,hisal);
         pstmt.executeUpdate();
         pstmt.close();
         }
      catch(SQLException e) ...{
         System.err.println("ERROR! Adding Salgrade: "
           + e.getMessage());
         }
   }
  
   public static int getHiSal(int grade)
   ...{
    try ...{
        Connection conn =
          DriverManager.getConnection("jdbc:default:connection:");
        String sql = "SELECT hisal FROM salgrade WHERE grade = ?";
        PreparedStatement pstmt = conn.prepareStatement(sql);pstmt.setInt(1, grade);
        ResultSet rset = pstmt.executeQuery();
        int res = 0;
        if (rset.next())
        ...{
            res = rset.getInt(1);
        }
        rset.close();
        return res;
       }
    catch (SQLException e)
    ...{
        System.err.println("ERROR! Querying Salgrade: "
           + e.getMessage());
          return -1;
    }   
   }
     
}

如何更新呢？

D:eclipse3.1workspacedbtest>dropjava -u scott -v OracleJavaProc

D:/tiger@iihero.oracledbeclipse3.1workspacedbtest>loadjava -u scott -v -resolve Or
acleJavaProc/tiger@iihero.oracledb.java
arguments: ''-u'' ''scott/tiger@iihero.oracledb'' ''-v'' ''-resolve'' ''OracleJavaProc.java''
creating : source OracleJavaProc
loading  : source OracleJavaProc
resolving: source OracleJavaProc
后边的应用示例：

SQL> create or replace function query_hisal(grade number) return number as langu
age java name ''OracleJavaProc.getHiSal(int) return int'';
  2  /

函数已创建。

SQL> set serveroutput on size 2000
SQL> call dbms_java.set_output(2000);

调用完成。
SQL> select query_hisal(5) from dual;

QUERY_HISAL(5)
--------------
          9999
全文完！

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/thinker28754/archive/2009/03/07/3962989.aspx

　　创建可以采用两种方式：

　　1、已经配置本地服务

以下是引用片段： 　　create public database 　　link fwq12 connect to fzept 　　identified by neu using 'fjept'

　　CREATE DATABASE LINK数据库链接名CONNECT TO 用户名 IDENTIFIED BY 密码 USING ‘本地配置的数据的实例名’;

　　2、未配置本地服务

　　

以下是引用片段： create database link linkfwq 　　 connect to fzept identified by neu 　　 using '(DESCRIPTION = 　　 (ADDRESS_LIST = 　　 (ADDRESS = (PROTOCOL = TCP)(HOST = 10.142.202.12)(PORT = 1521)) 　　 ) 　　 (CONNECT_DATA = 　　 (SERVICE_NAME = fjept) 　　 ) 　　 )';

　　host=数据库的ip地址，service_name=数据库的ssid。

　　其实两种方法配置dblink是差不多的，我个人感觉还是第二种方法比较好，这样不受本地服务的影响。

　　数据库连接字符串可以用NET8 EASY CONFIG或者直接修改TNSNAMES.ORA里定义.

　　数据库参数global_name=true时要求数据库链接名称跟远端数据库名称一样

　　数据库全局名称可以用以下命令查出

　　SELECT * FROM GLOBAL_NAME;

　　查询远端数据库里的表

　　SELECT …… FROM 表名@数据库链接名;

　　查询、删除和插入数据和操作本地的数据库是一样的，只不过表名需要写成“表名@dblink服务器”而已。

　　附带说下同义词创建:

　　CREATE SYNONYM同义词名FOR 表名;

　　CREATE SYNONYM同义词名FOR 表名@数据库链接名;

　　删除dblink：DROP PUBLIC DATABASE LINK linkfwq。

　　如果创建全局dblink，必须使用systm或sys用户，在database前加public。

　　参考资料:

　　http://download-west.oracle.com/docs/cd/B19306_01/server.102/b14231/ds_admin.htm#i1008271

   trigger抛出ORA-04091异常,无非是当前trigger下的事务access了一mutating table,比较常见的就是trigger访问了自身上的表.在一个指定on delete cascade模式下的父子表中,trigger中如果有对其相关的父/子表的访问,依然会抛出ORA-04091.这是比较隐性的.

   拿oracle的示例表emp和dept来做这个试验.
   dept的表结构如下:

    emp表结构如下:

    emp和dept是一对父子表,关联column为DEPTNO.

    接下来创建1个 table:emp_log 和1个语句级 trigger: emp_del_trg.取一个
最简单的业务功能,emp_del_trg的作用就是当表emp记录被删除的时候,触发器将删除的记录的 EMPNO,DNAME和删除时间写入到emp_log中,当子表依赖的父表相关记录删除的时候,emp_log不做处理.
    表emp_log的结构如下:

    触发器trigger代码如下:

    来看看这个触发器是否能正常工作,首先删除emp的记录.

SQL> delete from emp where rownum<5;

4 rows deleted

SQL> select * from emp_log;

ENAME DNAME DATES
——————– ——————– ———–
SMITH RESEARCH 2008-7-1 18
ALLEN SALES 2008-7-1 18
WARD SALES 2008-7-1 18
JONES RESEARCH 2008-7-1 18

SQL> rollback;

Rollback complete

    看似trigger工作正常,删除dept的记录呢?

SQL> delete from dept where rownum<3;

delete from dept

ORA-04091: 表 KEVINYUAN.DEPT 发生了变化, 触发器/函数不能读它
ORA-06512: 在 “KEVINYUAN.EMP_DEL_TRG”, line 2
ORA-04088: 触发器 ‘KEVINYUAN.EMP_DEL_TRG’ 执行过程中出错

    ORA-04091错误如约而至.不难解释,因为父子表指定了级联删除,删除dept的记录
从而引起删除emp表上的相应数据,然后触发了emp_del_trg,由于trigger里有对dept的访问,对当前事务说,dept就是一个mutating table,这是不被允许的.

    如何来解决这个问题而实现这个简单的业务逻辑功能呢?当然,从表结构逻辑设计上来讲,可以将dept表上的dname字段add到emp表,或者不要显式的指定references,用程序来维护数据的完整性和约束,然后调整业务代码.最直接的方法，在trigger中声明一个ora-04091的exception，对此异常不做处理，也可完成目的。

    我们不妨做一下变通处理.将行级级触发器变通成语句级触发器.看下面的处理.

    1.创建一个package:emp_pkg .

    2.创建一个语句级trigger,用来触发trigger的时候清空初始化数据.

    3.创建一个行级trigger:emp_d,问题的核心和关键就在这里,这个trigger
并不参与业务逻辑,只是将触发到的数据载入到emp_pkg.oldRows记录表里面去.

    4.创建一个语句级trigger:emp_d_st,前面3步都是为这一步服务的,这一步
真正参与业务逻辑处理.

    来看一下变通后的触发器是否满足我们的业务要求:

SQL> alter trigger emp_del_trg disable;

Trigger altered

    删除emp数据

SQL> delete from emp where rownum<3;

2 rows deleted

SQL> select * from emp_log;

ENAME DNAME DATES
——————– ——————– ———–
SMITH RESEARCH 2008-7-1 19
ALLEN SALES 2008-7-1 19

SQL> rollback;

Rollback complete

    删除dept数据.

SQL> delete from dept;

4 rows deleted

SQL> select * from emp_log;

ENAME DNAME DATES
——————– ——————– ———–

   至此,目的实现.由于用了多于常规数量的触发器,对系统性能会造成一定影响,而且,无疑会加重系统后期业务维护负担,因此,良好的数据库逻辑设计和代码编写思路是很必要的,否则,只能走另外一些路径,不过,这个由行级触发器变语句级别触发器的思路,还是有必要的，当trigger中无法避免的需要access自身表的时候，这无疑是个可以借鉴的解决方案。

    THE END;

1.基础认识

关于这些函数及DBMS_RANDOM包的文件都包含在SQLPlus中：
     select text   from all_source
      where name = 'DBMS_RANDOM'
       and type = 'PACKAGE' order by line;

   ◆ TYPE      num_array
   ◆ PROCEDURE terminate
   ◆ PROCEDURE seed
   ◆ PROCEDURE initialize
   ◆ FUNCTION random
   ◆ FUNCTION value RETURN NUMBER;
   ◆ FUNCTION value (low IN NUMBER, high IN NUMBER) RETURN NUMBER;
   ◆ FUNCTION normal RETURN NUMBER;
   ◆ FUNCTION string (opt char, len NUMBER) RETURN VARCHAR2;

2.应用举例

SELECT DBMS_RANDOM.RANDOM FROM DUAL;
 
再进一步的要求，比如，产生一个0－100的随机数，稍微变通一下就可以了：
 
select abs(mod(dbms_random.random,100)) from dual

3.进阶说明

dbms_random又有新函数了可以实现这些功能
FUNCTION value RETURN NUMBER;
FUNCTION value (low IN NUMBER, high IN NUMBER) RETURN NUMBER;
FUNCTION normal RETURN NUMBER;
FUNCTION string (opt char, len NUMBER)   RETURN VARCHAR2; 
 
产生N到M之间的随机数
SELECT   DBMS_RANDOM.VALUE(N,M) FROM DUAL;
 
缺省DBMS_RANDOM.VALUE返回0到1之间的随机数

SQL> select dbms_random.value, dbms_random.value(55,100) from dual;
VALUE            DBMS_RANDOM.VALUE(55,100)
--------------- -----------------------------
0.714469037747011      68.5593418279622
 
NORMAL函数返回服从正态分布的一组数。此正态分布标准偏差为1，期望值为0。这个函数返回的数值中有68%是介于-1与+1之间，95%介于-2与+2之间，99%介于-3与+3之间。
最后，是STRING函数。它返回一个长度达60个字符的随机字符串。

用DBMS_RANDOM生成文本和日期值

数字、文本字符串和日期都是用户会在表格里碰到的三种常见数据类型。虽然你可以用PL／SQL程序包里的DBMS_RANDOM随机生成数字——它确实能够做到这一点——它还能够随机生成文本和日期值。

1.产生随机数字
就让我们先从数字开始。VALUE函数会返回一个大于等于0但是小于1的数，精度是38位。

SELECT DBMS_RANDOM.VALUE FROM DUAL;

对于指定范围内的整数，要加入参数low_value和high_value，并从结果中截取小数（最大值不能被作为可能的值）。所以对于0到99之间的整数，你要使用下面的代码：

SELECT TRUNC(DBMS_RANDOM.VALUE(0, 100)) FROM DUAL;

2.产生随机文本字符串
要随机生成文本字符串，就要使用STRING函数并编写代码指定字符串的类型和所希望的长度：

SELECT DBMS_RANDOM.STRING('A', 20) FROM DUAL;

类型代码在《Oracle Database 10g PL／SQL程序包和类型参考（Oracle Database 10g PL/SQL Packages and Types Reference）》有说明。

下面是一些类型的代码：

‘U’用来生成大写字符

‘L’用来生成小写字符

‘A’用来生成大小写混合的字符

3.产生随机日期
Oracle将日期作为过去某个关键日期（如果你好奇的话，我可以告诉你这个日期是公元前4712年1月1日）的整数偏移量来保存。这就意味着你可以通过寻找与你希望的起始日期相对应的整数，然后向它加入一个随机的整数来随机生成一个指定范围内的日期。

使用TO_CHAR函数和‘J’格式代码，你可以为今天的日期生成一个内部日期数：

SELECT TO_CHAR(SYSDATE, 'J') FROM DUAL;

例如，要生成一个2003年内的任意日期，你可以首先确定2003年1月1日的日期整数；

SELECT TO_CHAR(TO_DATE('01/01/03','mm/dd/yy'),'J')FROM DUAL;

系统给的结果是2452641。所以要生成该年度内的任意日期，我们就要用带有low_value等于2452641和high_value等于2452641+364参数的DBMS_RANDOM.VALUE，再把它转换成日期：

SELECT TO_DATE(TRUNC(DBMS_RANDOM.VALUE(2452641,2452641+364)),'J') FROM DUAL;
 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/luojun198610/archive/2009/02/27/3941491.aspx

connect by 是结构化查询中用到的，其基本语法是：
select ... from tablename start with 条件1
connect by 条件2
where 条件3;

例：

select * from table
start with org_id = 'HBHqfWGWPy'
connect by prior org_id = parent_id;

简单说来是将一个树状结构存储在一张表里，比如一个表中存在两个字段:
org_id,parent_id那么通过表示每一条记录的parent是谁，就可以形成一个树状结构。
用上述语法的查询可以取得这棵树的所有记录。
其中：

条件1 是根结点的限定语句，当然可以放宽限定条件，以取得多个根结点，实际就是多棵树。
条件2 是连接条件，其中用PRIOR表示上一条记录，比如 CONNECT BY PRIOR org_id = parent_id就是说上一条记录的org_id 是本条记录的parent_id，即本记录的父亲是上一条记录。
条件3 是过滤条件，用于对返回的所有记录进行过滤。

简单介绍如下：

早扫描树结构表时，需要依此访问树结构的每个节点，一个节点只能访问一次，其访问的步骤如下：
第一步：从根节点开始；
第二步：访问该节点；
第三步：判断该节点有无未被访问的子节点，若有，则转向它最左侧的未被访问的子节，并执行第二步，否则执行第四步；
第四步：若该节点为根节点，则访问完毕，否则执行第五步；
第五步：返回到该节点的父节点，并执行第三步骤。

总之：扫描整个树结构的过程也即是中序遍历树的过程。

1． 树结构的描述
树结构的数据存放在表中，数据之间的层次关系即父子关系，通过表中的列与列间的关系来描述，如EMP表中的EMPNO和MGR。EMPNO表示该雇员的编号，MGR表示领导该雇员的人的编号，即子节点的MGR值等于父节点的EMPNO值。在表的每一行中都有一个表示父节点的MGR（除根节点外），通过每个节点的父节点，就可以确定整个树结构。
在SELECT命令中使用CONNECT BY 和蔼START WITH 子句可以查询表中的树型结构关系。其命令格式如下：
SELECT 。。。
CONNECT BY {PRIOR 列名1=列名2|列名1=PRIOR 裂名2}
[START WITH]；
其中：CONNECT BY子句说明每行数据将是按层次顺序检索，并规定将表中的数据连入树型结构的关系中。PRIORY运算符必须放置在连接关系的两列中某一个的前面。对于节点间的父子关系，PRIOR运算符在一侧表示父节点，在另一侧表示子节点，从而确定查找树结构是的顺序是自顶向下还是自底向上。在连接关系中，除了可以使用列名外，还允许使用列表达式。START WITH 子句为可选项，用来标识哪个节点作为查找树型结构的根节点。若该子句被省略，则表示所有满足查询条件的行作为根节点。

START WITH： 不但可以指定一个根节点，还可以指定多个根节点。
2． 关于PRIOR
运算符PRIOR被放置于等号前后的位置，决定着查询时的检索顺序。
PRIOR被置于CONNECT BY子句中等号的前面时，则强制从根节点到叶节点的顺序检索，即由父节点向子节点方向通过树结构，我们称之为自顶向下的方式。如：
CONNECT BY PRIOR EMPNO=MGR
PIROR运算符被置于CONNECT BY 子句中等号的后面时，则强制从叶节点到根节点的顺序检索，即由子节点向父节点方向通过树结构，我们称之为自底向上的方式。例如：
CONNECT BY EMPNO=PRIOR MGR
在这种方式中也应指定一个开始的节点。
3． 定义查找起始节点
在自顶向下查询树结构时，不但可以从根节点开始，还可以定义任何节点为起始节点，以此开始向下查找。这样查找的结果就是以该节点为开始的结构树的一枝。

4．使用LEVEL
在具有树结构的表中，每一行数据都是树结构中的一个节点，由于节点所处的层次位置不同，所以每行记录都可以有一个层号。层号根据节点与根节点的距离确定。不论从哪个节点开始，该起始根节点的层号始终为1，根节点的子节点为2， 依此类推。图1.2就表示了树结构的层次。

5．节点和分支的裁剪
在对树结构进行查询时，可以去掉表中的某些行，也可以剪掉树中的一个分支，使用WHERE子句来限定树型结构中的单个节点，以去掉树中的单个节点，但它却不影响其后代节点（自顶向下检索时）或前辈节点（自底向顶检索时）。
6．排序显示
象在其它查询中一样，在树结构查询中也可以使用ORDER BY 子句，改变查询结果的显示顺序，而不必按照遍历树结构的顺序。

Oracle代码

1. if conditions then   
2.    statements;   
3. [elseif conditions then    
4.    statements;]   
5. [else    
6.    statements;]   
7. end if;  

if conditions then
statements;
[elseif conditions then
statements;]
[else
statements;]
end if;

Oracle代码

1.     
2.  declare   
3.    v_count number;   
4.  begin   
5.  select count(*) into v_count from cip_temps;   
6.  if(v_count>0) then   
7.  dbms_output.put_line('v_cont的值:'|| v_count);   
8.    end if;   
9.  end;   
10. /   

declare
v_count number;
begin
select count(*) into v_count from cip_temps;
if(v_count>0) then
dbms_output.put_line('v_cont的值:'|| v_count);
end if;
end;
/

Oracle代码

1.  declare   
2.    v_count number;   
3.  begin   
4.    select count(*) into v_count from cip_temps;   
5.      if(v_count>11) then   
6.   dbms_output.put_line('v_cont的值:'|| v_count);   
7.      else    
8.      dbms_output.put_line('v_count的值:'|| v_count);   
9.    end if;   
10.  end;   
11. /   

      declare
v_count number;
begin
select count(*) into v_count from cip_temps;
if(v_count>11) then
dbms_output.put_line('v_cont的值:'|| v_count);
else
dbms_output.put_line('v_count的值:'|| v_count);
end if;
end;
/

Oracle代码

1. declare   
2.   v_count number;   
3. begin   
4.   select count(*) into v_count from cip_temps;   
5.   if(v_count>10) then   
6.     dbms_output.put_line('if操作___v_cont的值:'|| v_count);   
7.   elsif (v_count=10) then   
8.     dbms_output.put_line('elsif操作____v_count的值:'|| v_count);   
9.   else   
10.     dbms_output.put_line('else操作____v_cout的值:'||v_count);   
11.   end if;   
12. end;   
13. /    

declare
v_count number;
begin
select count(*) into v_count from cip_temps;
if(v_count>10) then
dbms_output.put_line('if操作___v_cont的值:'|| v_count);
elsif (v_count=10) then
dbms_output.put_line('elsif操作____v_count的值:'|| v_count);
else
dbms_output.put_line('else操作____v_cout的值:'||v_count);
end if;
end;
/

Oracle代码

1. case  条件选择符   
2.    when   条件值表达式1 then 要执行的操作1；   
3.    when   条件值表达式2 then 要执行的操作2；   
4.     。。。。。。。   
5.    else    
6.      要执行的操作。   
7.    end case;   

   case  条件选择符
when   条件值表达式1 then 要执行的操作1；
when   条件值表达式2 then 要执行的操作2；
。。。。。。。
else
要执行的操作。
end case;

Oracle代码

1. declare   
2.   v_count number;   
3. begi   
4.  select count(*) into v_count from cip_temps;   
5.   case v_count   
6.     when 1 then   
7.       dbms_output.put_line('when 1操作___v_cont的值:'|| v_count);   
8.     when 5 then   
9.      dbms_output.put_line('when 5操作___v_count的值:'|| v_count);   
10.     when 10 then   
11.      dbms_output.put_line('when 10操作____v_count的值:'|| v_count);   
12.   else   
13.     dbms_output.put_line('else操作____v_cout的值:'||v_count);   
14.  end case;   
15. end;   
16. /    

    declare
v_count number;
begi
select count(*) into v_count from cip_temps;
case v_count
when 1 then
dbms_output.put_line('when 1操作___v_cont的值:'|| v_count);
when 5 then
dbms_output.put_line('when 5操作___v_count的值:'|| v_count);
when 10 then
dbms_output.put_line('when 10操作____v_count的值:'|| v_count);
else
dbms_output.put_line('else操作____v_cout的值:'||v_count);
end case;
end;
/

Oracle代码

1. case     
2.    when   条件值表达式1 then 要执行的操作1；   
3.    when   条件值表达式2 then 要执行的操作2；   
4.     。。。。。。。   
5.    else    
6.      要执行的操作。   
7.    end case;   

   case
when   条件值表达式1 then 要执行的操作1；
when   条件值表达式2 then 要执行的操作2；
。。。。。。。
else
要执行的操作。
end case;

Oracle代码

1. declare   
2.   v_count number;   
3. begin   
4.  select count(*) into v_count from cip_temps;   
5.   case    
6.     when v_count>10 then   
7.       dbms_output.put_line('when 1操作___v_cont的值:'|| v_count);   
8.     when v_count>5 then   
9.      dbms_output.put_line('when 5操作___v_count的值:'|| v_count);   
10.     when v_count>4 then   
11.      dbms_output.put_line('when 10操作____v_count的值:'|| v_count);   
12.     else   
13.     dbms_output.put_line('else操作____v_cout的值:'||v_count);   
14.  end case;   
15. end;   
16. /    

    declare
v_count number;
begin
select count(*) into v_count from cip_temps;
case
when v_count>10 then
dbms_output.put_line('when 1操作___v_cont的值:'|| v_count);
when v_count>5 then
dbms_output.put_line('when 5操作___v_count的值:'|| v_count);
when v_count>4 then
dbms_output.put_line('when 10操作____v_count的值:'|| v_count);
else
dbms_output.put_line('else操作____v_cout的值:'||v_count);
end case;
end;
/

Oracle代码

1.  declare   
2.   i int:=1;   
3.  begin   
4.   loop      
5. dbms_output.put_line(i);   
6. exit when i=10;   
7. i:=i+1;   
8. nd loop;   
9.  end;   
10.  /   

    declare
i int:=1;
begin
loop
dbms_output.put_line(i);
exit when i=10;
i:=i+1;
end loop;
end;
/

Oracle代码

1.   declare   
2.    i int:=1;   
3.   begin   
4.    while i<=10 loop      
5.   dbms_output.put_line(i);   
6.  i:=i+1;   
7. end loop;   
8.   end;   
9.   /   

    declare
i int:=1;
begin
while i<=10 loop
dbms_output.put_line(i);
i:=i+1;
end loop;
end;
/

Oracle代码

1. declare   
2.  begin   
3.  for i in reverse  1..10 loop   
4.   dbms_output.put_line(i);   
5.  end loop;   
6.  end;   
7.  /    

   declare
begin
for i in reverse  1..10 loop
dbms_output.put_line(i);
end loop;
end;
/

2.CHR
给出整数,返回对应的字符;
SQL> select chr(54740) zhao,chr(65) chr65 from dual;
 
ZH C
-- -
赵 A
 
3.CONCAT
连接两个字符串;
SQL> select concat('010-','88888888')||'转23'  高乾竞电话 from dual;
 
高乾竞电话
----------------
010-88888888转23
 
4.INITCAP
返回字符串并将字符串的第一个字母变为大写;
SQL> select initcap('smith') upp from dual;
 
UPP
-----
Smith
 

5.INSTR(C1,C2,I,J)
在一个字符串中搜索指定的字符,返回发现指定的字符的位置;
C1    被搜索的字符串
C2    希望搜索的字符串
I     搜索的开始位置,默认为1
J     出现的位置,默认为1
SQL> select instr('oracle traning','ra',1,2) instring from dual;
 
 INSTRING
---------
        9
 

6.LENGTH
返回字符串的长度;
SQL> select name,length(name),addr,length(addr),sal,length(to_char(sal)) from gao.nchar_tst;
 
NAME   LENGTH(NAME) ADDR             LENGTH(ADDR)       SAL LENGTH(TO_CHAR(SAL))
------ ------------ ---------------- ------------ --------- --------------------
高乾竞            3 北京市海锭区                6   9999.99                    7
 
 
 
7.LOWER
返回字符串,并将所有的字符小写
SQL> select lower('AaBbCcDd')AaBbCcDd from dual;
 
AABBCCDD
--------
aabbccdd
 

8.UPPER
返回字符串,并将所有的字符大写
SQL> select upper('AaBbCcDd') upper from dual;
 
UPPER
--------
AABBCCDD
 
 
 
9.RPAD和LPAD(粘贴字符)
RPAD  在列的右边粘贴字符
LPAD  在列的左边粘贴字符
SQL> select lpad(rpad('gao',10,'*'),17,'*')from dual;
 
LPAD(RPAD('GAO',1
-----------------
*******gao*******
不够字符则用*来填满
 

10.LTRIM和RTRIM
LTRIM  删除左边出现的字符串
RTRIM  删除右边出现的字符串
SQL> select ltrim(rtrim('   gao qian jing   ',' '),' ') from dual;
 
LTRIM(RTRIM('
-------------
gao qian jing
 

11.SUBSTR(string,start,count)
取子字符串,从start开始,取count个
SQL> select substr('13088888888',3,8) from dual;
 
SUBSTR('
--------
08888888
 

12.REPLACE('string','s1','s2')
string   希望被替换的字符或变量
s1       被替换的字符串
s2       要替换的字符串
SQL> select replace('he love you','he','i') from dual;
 
REPLACE('H
----------
i love you
 

13.SOUNDEX
返回一个与给定的字符串读音相同的字符串
SQL> create table table1(xm varchar(8));
SQL> insert into table1 values('weather');
SQL> insert into table1 values('wether');
SQL> insert into table1 values('gao');
 
SQL> select xm from table1 where soundex(xm)=soundex('weather');
 
XM
--------
weather
wether
 

14.TRIM('s' from 'string')
LEADING   剪掉前面的字符
TRAILING  剪掉后面的字符
如果不指定,默认为空格符
 
15.ABS
返回指定值的绝对值
SQL> select abs(100),abs(-100) from dual;
 
 ABS(100) ABS(-100)
--------- ---------
      100       100
 

16.ACOS
给出反余弦的值
SQL> select acos(-1) from dual;
 
 ACOS(-1)
---------
3.1415927
 

17.ASIN
给出反正弦的值
SQL> select asin(0.5) from dual;
 
ASIN(0.5)
---------
.52359878
 

18.ATAN
返回一个数字的反正切值
SQL> select atan(1) from dual;
 
  ATAN(1)
---------
.78539816
 

19.CEIL
返回大于或等于给出数字的最小整数
SQL> select ceil(3.1415927) from dual;
 
CEIL(3.1415927)
---------------
              4
 

20.COS
返回一个给定数字的余弦
SQL> select cos(-3.1415927) from dual;
 
COS(-3.1415927)
---------------
             -1
 

21.COSH
返回一个数字反余弦值
SQL> select cosh(20) from dual;
 
 COSH(20)
---------
242582598
 

22.EXP
返回一个数字e的n次方根
SQL> select exp(2),exp(1) from dual;
 
   EXP(2)    EXP(1)
--------- ---------
7.3890561 2.7182818
 

23.FLOOR
对给定的数字取整数
SQL> select floor(2345.67) from dual;
 
FLOOR(2345.67)
--------------
          2345
 

24.LN
返回一个数字的对数值
SQL> select ln(1),ln(2),ln(2.7182818) from dual;
 
    LN(1)     LN(2) LN(2.7182818)
--------- --------- -------------
        0 .69314718     .99999999
 

25.LOG(n1,n2)
返回一个以n1为底n2的对数
SQL> select log(2,1),log(2,4) from dual;
 
 LOG(2,1)  LOG(2,4)
--------- ---------
        0         2
 

26.MOD(n1,n2)
返回一个n1除以n2的余数
SQL> select mod(10,3),mod(3,3),mod(2,3) from dual;
 
MOD(10,3)  MOD(3,3)  MOD(2,3)
--------- --------- ---------
        1         0         2
 

27.POWER
返回n1的n2次方根
SQL> select power(2,10),power(3,3) from dual;
 
POWER(2,10) POWER(3,3)
----------- ----------
       1024         27
 

28.ROUND和TRUNC
按照指定的精度进行舍入
SQL> select round(55.5),round(-55.4),trunc(55.5),trunc(-55.5) from dual;
 
ROUND(55.5) ROUND(-55.4) TRUNC(55.5) TRUNC(-55.5)
----------- ------------ ----------- ------------
         56          -55          55          -55
 

29.SIGN
取数字n的符号,大于0返回1,小于0返回-1,等于0返回0
SQL> select sign(123),sign(-100),sign(0) from dual;
 
SIGN(123) SIGN(-100)   SIGN(0)
--------- ---------- ---------
        1         -1         0
 

30.SIN
返回一个数字的正弦值
SQL> select sin(1.57079) from dual;
 
SIN(1.57079)
------------
           1
 

31.SIGH
返回双曲正弦的值
SQL> select sin(20),sinh(20) from dual;
 
  SIN(20)  SINH(20)
--------- ---------
.91294525 242582598
 

32.SQRT
返回数字n的根
SQL> select sqrt(64),sqrt(10) from dual;
 
 SQRT(64)  SQRT(10)
--------- ---------
        8 3.1622777
 

33.TAN
返回数字的正切值
SQL> select tan(20),tan(10) from dual;
 
  TAN(20)   TAN(10)
--------- ---------
2.2371609 .64836083
 

34.TANH
返回数字n的双曲正切值
SQL> select tanh(20),tan(20) from dual;
 
 TANH(20)   TAN(20)
--------- ---------
        1 2.2371609
 
 
 
35.TRUNC
按照指定的精度截取一个数
SQL> select trunc(124.1666,-2) trunc1,trunc(124.16666,2) from dual;
 
   TRUNC1 TRUNC(124.16666,2)
--------- ------------------
      100             124.16
 
 
 
36.ADD_MONTHS
增加或减去月份
SQL> select to_char(add_months(to_date('199912','yyyymm'),2),'yyyymm') from dual;
 
TO_CHA
------
200002
SQL> select to_char(add_months(to_date('199912','yyyymm'),-2),'yyyymm') from dual;
 
TO_CHA
------
199910
 

37.LAST_DAY
返回日期的最后一天
SQL> select to_char(sysdate,'yyyy.mm.dd'),to_char((sysdate)+1,'yyyy.mm.dd') from dual;
 
TO_CHAR(SY TO_CHAR((S
---------- ----------
2004.05.09 2004.05.10
SQL> select last_day(sysdate) from dual;
 
LAST_DAY(S
----------
31-5月 -04
 

38.MONTHS_BETWEEN(date2,date1)
给出date2-date1的月份
SQL> select months_between('19-12月-1999','19-3月-1999') mon_between from dual;
 
MON_BETWEEN
-----------
          9
SQL>selectmonths_between(to_date('2000.05.20','yyyy.mm.dd'),to_date('2005.05.20','yyyy.mm.dd')) mon_betw from dual;
 
 MON_BETW
---------
      -60
 

39.NEW_TIME(date,'this','that')
给出在this时区=other时区的日期和时间
SQL> select to_char(sysdate,'yyyy.mm.dd hh24:mi:ss') bj_time,to_char(new_time
  2  (sysdate,'PDT','GMT'),'yyyy.mm.dd hh24:mi:ss') los_angles from dual;
 
BJ_TIME             LOS_ANGLES
------------------- -------------------
2004.05.09 11:05:32 2004.05.09 18:05:32
 

40.NEXT_DAY(date,'day')
给出日期date和星期x之后计算下一个星期的日期
SQL> select next_day('18-5月-2001','星期五') next_day from dual;
 
NEXT_DAY
----------
25-5月 -01
 
 
 
41.SYSDATE
用来得到系统的当前日期
SQL> select to_char(sysdate,'dd-mm-yyyy day') from dual;
 
TO_CHAR(SYSDATE,'
-----------------
09-05-2004 星期日
trunc(date,fmt)按照给出的要求将日期截断,如果fmt='mi'表示保留分,截断秒
SQL> select to_char(trunc(sysdate,'hh'),'yyyy.mm.dd hh24:mi:ss') hh,
  2  to_char(trunc(sysdate,'mi'),'yyyy.mm.dd hh24:mi:ss') hhmm from dual;
 
HH                  HHMM
------------------- -------------------
2004.05.09 11:00:00 2004.05.09 11:17:00
 
 
 
42.CHARTOROWID
将字符数据类型转换为ROWID类型
SQL> select rowid,rowidtochar(rowid),ename from scott.emp;
 
ROWID              ROWIDTOCHAR(ROWID) ENAME
------------------ ------------------ ----------
AAAAfKAACAAAAEqAAA AAAAfKAACAAAAEqAAA SMITH
AAAAfKAACAAAAEqAAB AAAAfKAACAAAAEqAAB ALLEN
AAAAfKAACAAAAEqAAC AAAAfKAACAAAAEqAAC WARD
AAAAfKAACAAAAEqAAD AAAAfKAACAAAAEqAAD JONES
 

43.CONVERT(c,dset,sset)
将源字符串 sset从一个语言字符集转换到另一个目的dset字符集
SQL> select convert('strutz','we8hp','f7dec') "conversion" from dual;
 
conver
------
strutz
 

44.HEXTORAW
将一个十六进制构成的字符串转换为二进制
 

45.RAWTOHEXT
将一个二进制构成的字符串转换为十六进制
 
 
 
46.ROWIDTOCHAR
将ROWID数据类型转换为字符类型
 
 
 
47.TO_CHAR(date,'format')
SQL> select to_char(sysdate,'yyyy/mm/dd hh24:mi:ss') from dual;
 
TO_CHAR(SYSDATE,'YY
-------------------
2004/05/09 21:14:41
 
 
 
48.TO_DATE(string,'format')
将字符串转化为ORACLE中的一个日期
 

49.TO_MULTI_BYTE
将字符串中的单字节字符转化为多字节字符
SQL>  select to_multi_byte('高') from dual;
 
TO
--
高
 

50.TO_NUMBER
将给出的字符转换为数字
SQL> select to_number('1999') year from dual;
 
     YEAR
---------
     1999
 

51.BFILENAME(dir,file)
指定一个外部二进制文件
SQL>insert into file_tb1 values(bfilename('lob_dir1','image1.gif'));
 

52.CONVERT('x','desc','source')
将x字段或变量的源source转换为desc
SQL> select sid,serial#,username,decode(command,
  2  0,'none',
  3  2,'insert',
  4  3,
  5  'select',
  6  6,'update',
  7  7,'delete',
  8  8,'drop',
  9  'other') cmd  from v$session where type!='background';
 
      SID   SERIAL# USERNAME                       CMD
--------- --------- ------------------------------ ------
        1         1                                none
        2         1                                none
        3         1                                none
        4         1                                none
        5         1                                none
        6         1                                none
        7      1275                                none
        8      1275                                none
        9        20 GAO                            select
       10        40 GAO                            none
 

53.DUMP(s,fmt,start,length)
DUMP函数以fmt指定的内部数字格式返回一个VARCHAR2类型的值
SQL> col global_name for a30
SQL> col dump_string for a50
SQL> set lin 200
SQL> select global_name,dump(global_name,1017,8,5) dump_string from global_name;
 
GLOBAL_NAME                    DUMP_STRING
------------------------------ --------------------------------------------------
ORACLE.WORLD                   Typ=1 Len=12 CharacterSet=ZHS16GBK: W,O,R,L,D
 

54.EMPTY_BLOB()和EMPTY_CLOB()
这两个函数都是用来对大数据类型字段进行初始化操作的函数
 
55.GREATEST
返回一组表达式中的最大值,即比较字符的编码大小.
SQL> select greatest('AA','AB','AC') from dual;
 
GR
--
AC
SQL> select greatest('啊','安','天') from dual;
 
GR
--
天
 

56.LEAST
返回一组表达式中的最小值
SQL> select least('啊','安','天') from dual;
 
LE
--
啊
 

57.UID
返回标识当前用户的唯一整数
SQL> show user
USER 为"GAO"
SQL> select username,user_id from dba_users where user_id=uid;
 
USERNAME                         USER_ID
------------------------------ ---------
GAO                                   25
 
 
 
58.USER
返回当前用户的名字
SQL> select user from  dual;
 
USER
------------------------------
GAO
 

59.USEREVN
返回当前用户环境的信息,opt可以是:
ENTRYID,SESSIONID,TERMINAL,ISDBA,LABLE,LANGUAGE,CLIENT_INFO,LANG,VSIZE
ISDBA  查看当前用户是否是DBA如果是则返回true
SQL> select userenv('isdba') from dual;
 
USEREN
------
FALSE
SQL> select userenv('isdba') from dual;
 
USEREN
------
TRUE
SESSION
返回会话标志
SQL> select userenv('sessionid') from dual;
 
USERENV('SESSIONID')
--------------------
                 152
ENTRYID
返回会话人口标志
SQL> select userenv('entryid') from dual;
 
USERENV('ENTRYID')
------------------
                 0
INSTANCE
返回当前INSTANCE的标志
SQL> select userenv('instance') from dual;
 
USERENV('INSTANCE')
-------------------
                  1
LANGUAGE
返回当前环境变量
SQL> select userenv('language') from dual;
 
USERENV('LANGUAGE')
----------------------------------------------------
SIMPLIFIED CHINESE_CHINA.ZHS16GBK
LANG
返回当前环境的语言的缩写
SQL> select userenv('lang') from dual;
 
USERENV('LANG')
----------------------------------------------------
ZHS
TERMINAL
返回用户的终端或机器的标志
SQL> select userenv('terminal') from dual;
 
USERENV('TERMINA
----------------
GAO
VSIZE(X)
返回X的大小(字节)数
SQL> select vsize(user),user from dual;
 
VSIZE(USER) USER
----------- ------------------------------
          6 SYSTEM
 
 
 
60.AVG(DISTINCT|ALL)
all表示对所有的值求平均值,distinct只对不同的值求平均值
SQLWKS> create table table3(xm varchar(8),sal number(7,2));
语句已处理。
SQLWKS>  insert into table3 values('gao',1111.11);
SQLWKS>  insert into table3 values('gao',1111.11);
SQLWKS>  insert into table3 values('zhu',5555.55);
SQLWKS> commit;
 
SQL> select avg(distinct sal) from gao.table3;
 
AVG(DISTINCTSAL)
----------------
         3333.33
 
SQL> select avg(all sal) from gao.table3;
 
AVG(ALLSAL)
-----------
    2592.59
 

61.MAX(DISTINCT|ALL)
求最大值,ALL表示对所有的值求最大值,DISTINCT表示对不同的值求最大值,相同的只取一次
SQL> select max(distinct sal) from scott.emp;
 
MAX(DISTINCTSAL)
----------------
            5000
 

62.MIN(DISTINCT|ALL)
求最小值,ALL表示对所有的值求最小值,DISTINCT表示对不同的值求最小值,相同的只取一次
SQL> select min(all sal) from gao.table3;
 
MIN(ALLSAL)
-----------
    1111.11
 

63.STDDEV(distinct|all)
求标准差,ALL表示对所有的值求标准差,DISTINCT表示只对不同的值求标准差
SQL> select stddev(sal) from scott.emp;
 
STDDEV(SAL)
-----------
  1182.5032
 
SQL> select stddev(distinct sal) from scott.emp;
 
STDDEV(DISTINCTSAL)
-------------------
           1229.951
 
 
 
64.VARIANCE(DISTINCT|ALL)
求协方差
 
SQL> select variance(sal) from scott.emp;
 
VARIANCE(SAL)
-------------
    1398313.9
 

65.GROUP BY
主要用来对一组数进行统计
SQL> select deptno,count(*),sum(sal) from scott.emp group by deptno;
 
   DEPTNO  COUNT(*)  SUM(SAL)
--------- --------- ---------
       10         3      8750
       20         5     10875
       30         6      9400
 
 
 
66.HAVING
对分组统计再加限制条件
SQL> select deptno,count(*),sum(sal) from scott.emp group by deptno having count(*)>=5;
 
   DEPTNO  COUNT(*)  SUM(SAL)
--------- --------- ---------
       20         5     10875
       30         6      9400
SQL> select deptno,count(*),sum(sal) from scott.emp having count(*)>=5 group by deptno ;
 
   DEPTNO  COUNT(*)  SUM(SAL)
--------- --------- ---------
       20         5     10875
       30         6      9400
 

67.ORDER BY
用于对查询到的结果进行排序输出
SQL> select deptno,ename,sal from scott.emp order by deptno,sal desc;
 
   DEPTNO ENAME            SAL
--------- ---------- ---------
       10 KING            5000
       10 CLARK           2450
       10 MILLER          1300
       20 SCOTT           3000
       20 FORD            3000
       20 JONES           2975
       20 ADAMS           1100
       20 SMITH            800
       30 BLAKE           2850
       30 ALLEN           1600
       30 TURNER          1500
       30 WARD            1250
       30 MARTIN          1250
       30 JAMES            950
 

视图的优点：

1.对数据库的访问，因为视图可以有选择性的选取数据库里的一部分。

2.用户通过简单的查询可以从复杂查询中得到结果。

3.维护数据的独立性，试图可从多个表检索数据。

4.对于相同的数据可产生不同的视图。

视图分为简单视图和复杂视图：

1、简单视图只从单表里获取数据，复杂视图从多表；

2、简单视图不包含函数和数据组，复杂视图包含；

3、简单视图可以实现DML操作，复杂视图不可以。

视图的创建：

CREATE [OR REPLACE] [FORCE|NOFORCE] VIEW view_name   [(alias[, alias]...)] AS subquery [WITH CHECK OPTION [CONSTRAINT constraint]] [WITH READ ONLY]

其中：OR REPLACE    ：若所创建的试图已经存在，ORACLE自动重建该视图；

FORCE：不管基表是否存在ORACLE都会自动创建该视图；

NOFORCE       ：只有基表都存在ORACLE才会创建该视图：

alias：为视图产生的列定义的别名；

subquery  ：一条完整的SELECT语句，可以在该语句中定义别名；

WITH CHECK OPTION  ：插入或修改的数据行必须满足视图定义的约束；

WITH READ ONLY        ：该视图上不能进行任何DML操作。

例如：

CREATE OR REPLACE VIEW dept_sum_vw(name,minsal,maxsal,avgsal) AS SELECT d.dname,min(e.sal),max(e.sal),avg(e.sal) FROM    emp e,dept d WHERE e.deptno=d.deptno GROUP BY d.dname;

视图的定义原则：

1.视图的查询可以使用复杂的SELECT语法，包括连接/分组查询和子查询；

2.在没有WITH CHECK OPTION和 READ ONLY 的情况下，查询中不能使用ORDER BY 子句；

3.如果没有为CHECK OPTION约束命名，系统会自动为之命名，形式为SYS_Cn；

4.OR REPLACE选项可以不删除原视图便可更改其定义并重建，或重新授予对象权限。

视图的查询：

视图创建成功后，可以从视图中检索数据，这点和从表中检索数据一样。

还可以查询视图的全部信息和指定的数据行和列。 如：检索数据：

SQL>SELECT * FROM dept_sum_vw；

查询视图定义：

SELECT view_name,text from user_views;

其中text显示的内容为视图定义的SELECT语句，可通过DESC USER_VIEWS 得到相关信息。

修改视图：

通过OR REPLACE 重新创建同名视图即可。

视图上的DML 操作：

DML操作应遵循的原则：

1.简单视图可以执行DML操作；

2.在视图包含GROUP 函数，GROUP BY子句，DISTINCT关键字时不能

删除数据行；

3.在视图不出现下列情况时可通过视图修改基表数据或插入数据：

a.视图中包含GROUP 函数，GROUP BY子句，DISTINCT关键字；

b.使用表达式定义的列；

c.ROWNUM伪列。

d.基表中未在视图中选择的其他列定义为非空且无默认值。

视图可用于保持数据库的完整性，但作用有限。

通过视图执行引用完整性约束可在数据库级执行约束。

WITH CHECK OPTION 子句限定：

通过视图执行的INSERTS和UPDATES操作不能创建该视图检索不到的数据行，因为它会对插入或修改的数据行执行完整性约束和数据有效性检查。

例如：

CREATE OR REPLACE VIEW vw_emp20 AS SELECT * FROM emp WHERE deptno=20 WITH CHECK OPTION constraint vw_emp20_ck;

视图 已建立。

查询结果：

SELECT empno,ename,job FROM vw_emp20; EMPNO    ENAME    JOB ---------------------  -------------- ------------- 7369     SMITH    CLERK 7566     JONES   MANAGER 7902     FORD    ANALYST

修改：

UPDATE vw_emp20 SET        deptno=20 WHERE   empno=7902;

将产生错误：

UPDATE vw_emp20

*

ERROR 位于第一行：

ORA-01402：视图WITH CHECK OPTION 违反WHERE 子句

视图的删除：DROP VIEW VIEW_NAME语句删除视图。删除视图的定义不影响基表中的数据。只有视图所有者和具备DROP VIEW权限的用户可以删除视图。视图被删除后，基于被删除视图的其他视图或应用将无效。

假设我们有一个表Student，包括以下字段与数据：

drop table student;

create table student
(
id int primary key,
name nvarchar2(50) not null,
score number not null
);

insert into student values(1,'Aaron',78);
insert into student values(2,'Bill',76);
insert into student values(3,'Cindy',89);
insert into student values(4,'Damon',90);
insert into student values(5,'Ella',73);
insert into student values(6,'Frado',61);
insert into student values(7,'Gill',99);
insert into student values(8,'Hellen',56);
insert into student values(9,'Ivan',93);
insert into student values(10,'Jay',90);

commit;

• Union和Union All的区别。

select *
from student
where id < 4

union

select *
from student
where id > 2 and id < 6

结果将是

1    Aaron    78
2    Bill    76
3    Cindy    89
4    Damon    90
5    Ella    73

如果换成Union All连接两个结果集，则返回结果是：

1    Aaron    78
2    Bill    76
3    Cindy    89
3    Cindy    89
4    Damon    90
5    Ella    73

可以看到，Union和Union All的区别之一在于对重复结果的处理。

接下来我们将两个子查询的顺序调整一下，改为

--Union

select *
from student
where id > 2 and id < 6

union

select *
from student
where id < 4

看看执行结果是否和你期望的一致？

--Union All

select *
from student
where id > 2 and id < 6

union all

select *
from student
where id < 4

那么这个呢？

据此我们可知，区别之二在于对排序的处理。Union All将按照关联的次序组织数据，而Union将进行依据一定规则进行排序。那么这个规则是？我们换个查询方式看看：

select score,id,name
from student
where id > 2 and id < 6

union

select score,id,name
from student
where id < 4

结果如下：

73    5    Ella
76    2    Bill
78    1    Aaron
89    3    Cindy
90    4    Damon

和我们预料的一致：将会按照字段的顺序进行排序。之前我们的查询是基于id,name,score的字段顺序，那么结果集将按照id优先进行排序；而现在新的字段顺序也改变了查询结果的排序。并且，是按照给定字段a,b,c...的顺序进行的order by。即结果是order by a,b,c...........的。我们看下一个查询：

select score,id,name
from student
where id > 2

union

select score,id,name
from student
where id < 4

结果如下：

56    8    Hellen
61    6    Frado
73    5    Ella
76    2    Bill
78    1    Aaron
89    3    Cindy
90    4    Damon
90    10    Jay
93    9    Ivan
99    7    Gill

可以看到，对于score相同的记录，将按照下一个字段id进行排序。如果我们想自行控制排序，是不是用order by指定就可以了呢？答案是肯定的，不过在写法上有需要注意的地方：

select score,id,name
from student
where id > 2 and id < 7

union

select score,id,name
from student
where id < 4

union

select score,id,name
from student
where id > 8
order by id desc

order by子句必须写在最后一个结果集里，并且其排序规则将改变操作后的排序结果。对于Union、Union All、Intersect、Minus都有效。

=================================================================================================================

Intersect和Minus的操作和Union基本一致，这里一起总结一下：

Union，对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序；

Union All，对两个结果集进行并集操作，包括重复行，不进行排序；

Intersect，对两个结果集进行交集操作，不包括重复行，同时进行默认规则的排序；

Minus，对两个结果集进行差操作，不包括重复行，同时进行默认规则的排序。

可以在最后一个结果集中指定Order by子句改变排序方式。

反之：
select a.studentno, a.studentname, b.classname
       from students a, classes b
      where a.classid = b.classid(+);

（另外一种写法：
select a.studentno,a.studentname,b.classname
        from students left join class on students.classid=class.classid
）

STUDENTNO STUDENTNAM CLASSNAME
---------- ---------- ------------------------------
            1 周虎          一年级一班
            2 周林          一年级二班
            3 钟林达

则是左连接，无论这个学生有没有一个能在一个班级中得到匹配的部门号，
这个学生的记录都会被显示。

即是左连接是以左边这个表为基准，右表表不足的地方用NULL填充

select a.studentno, a.studentname, b.classname
       from students a, classes b
      where a.classid = b.classid;
（另外一种写法：
select a.studentno,a.studentname,b.classname
        from students inner join class on students.classid=class.classid
）

这个则是通常用到的内连接,显示两表都符合条件的记录

总之,

左连接显示左边全部的和右边与左边相同的
右连接显示右边全部的和左边与右边相同的
内连接是只显示满足条件的!

文章出处：http://www.diybl.com/course/7_databases/oracle/Oracleshl/200869/123806.html